精华内容
下载资源
问答
  • STM32串口控制LED灯

    2018-06-28 09:10:34
    程序是基于STM32F103ZET6的一个实验程序。可通过发送指令控制LED灯,可以开启和关闭LED灯,以及蜂鸣器等外设
  • 程序通过keil5软件编写,你可以通过串口发送指令,来控制STM32F103C8T6单片机,并且通过串口返回LED的状态。(注意:程序中我使用的是PB8引脚和USART1串口。结和自己情况可以改变程序中的引脚,同时你也可以在引脚上...
  • 实验1:串口控制LED灯 目的:根据教程学习了跑马灯和串口通信实验,,因之前在学校有自学过一点Unity3d软体基础使用,为了将这些融合在一起,就想做用unity3d做上位机程序,通过串口通信,控制LED灯亮和灭。 数据...

    实验1:串口控制LED灯

    目的:根据教程学习了跑马灯和串口通信实验,,因之前在学校有自学过一点Unity3d软体基础使用,为了将这些融合在一起,就想做用unity3d做上位机程序,通过串口通信,控制LED灯亮和灭。

     

     

    数据处理部分:串口接收函数返回的数据类型是字符,判断:Res == '1',控制灯灭;Res == ‘0’,判断灯亮

    Res =USART_ReceiveData(USART1);

    代码链接:https://pan.baidu.com/s/1odWlKqIFnkBc9ns28UEEmw 
    提取码:v9ow

    展开全文
  • arduino程序-串口控制开关uart_led,使用蓝牙模块。
  • 串口控制RGB灯程序

    千次阅读 2018-04-30 12:39:00
    STM32收到数据进入中断程序原封不动返回上位机,并且根据收到的信息产出相应的进行操作.(1- led_on 2 – ledoff...); 源码 方法1: bsp_usart.c #include "bsp_usart.h" static void NVIC_Configuration...

    实验目的:

    1. 通过上位机给串口发送数据(字符);
    2. STM32收到数据进入中断程序原封不动返回上位机,并且根据收到的信息产出相应的进行操作.(1- led_on  2 – ledoff...);

     

    源码

          方法1:

    bsp_usart.c

    #include "bsp_usart.h"
    
    static void NVIC_Configuration(void)
    {
      NVIC_InitTypeDef NVIC_InitStructure;
    
      /* 嵌套向量中断控制器组选择 */
      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
      /* 配置USART为中断源 */
      NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
      /* 抢断优先级*/
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
      /* 子优先级 */
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
      /* 使能中断 */
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
      /* 初始化配置NVIC */
      NVIC_Init(&NVIC_InitStructure);
    }
    
    void USART_Config(void)
    {
    	GPIO_InitTypeDef GPIO_InitStructure;
    	USART_InitTypeDef USART_InitStructure;
    
    	// 打开串口GPIO的时钟
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    	// 打开串口外设的时钟
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    
    	// 将USART Tx的GPIO配置为推挽复用模式
    	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    	GPIO_Init(GPIOA, &GPIO_InitStructure);
    
            // 将USART Rx的GPIO配置为浮空输入模式
    	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    	GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    	// 配置串口的工作参数
    	// 配置波特率
    	USART_InitStructure.USART_BaudRate = 115200;
    	// 配置 针数据字长
    	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    	// 配置停止位
    	USART_InitStructure.USART_StopBits = USART_StopBits_1;
    	// 配置校验位
    	USART_InitStructure.USART_Parity = USART_Parity_No ;
    	// 配置硬件流控制
    	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	// 配置工作模式,收发一起
    	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    	// 完成串口的初始化配置
    	USART_Init(USART1, &USART_InitStructure);
    
    	// 串口中断优先级配置
    	NVIC_Configuration();
    
    	// 使能串口接收中断
           USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    
    	// 使能串口
    	USART_Cmd(USART1, ENABLE);
    }
    
    /* 发送一个字节 8 位*/
    /*STM32 USART只能一次发送8位*/
    void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data)
    {
    	USART_SendData(pUSARTx, data);
    	while( USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET );
    }
    
    /* 发送两个字节的数据 * 16位*/
    /*分两次发送*/
    void Usart_SendHalfWord(USART_TypeDef* pUSARTx, uint16_t data)
    {
    	uint8_t temp_h,temp_l;/*高低8位*/
    
    	temp_h = (data&0xff00) >> 8 ;
    	temp_l = data&0xff;
    	/*先发送高8位*/
    	USART_SendData(pUSARTx, temp_h);
    	while( USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET );
    	/*在发送低8位*/
    	USART_SendData(pUSARTx, temp_l);
    	while( USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET );
    }
    
    /* 发送8位数据的数组 */
    void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array,uint8_t num)
    {
    	uint8_t i;
    	for( i=0; i<num; i++ )
      {
    		Usart_SendByte(pUSARTx, array[i]);
    	}
    	//发送8位是判读,TXE,大于8位判断TC
    	while( USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET );
    }
    
    /* 发送字符串 */
    void Usart_SendStr(USART_TypeDef* pUSARTx, uint8_t *str)
    {
    	uint8_t i=0;
    	do
      {
    		Usart_SendByte(pUSARTx, *(str+i));
    		i++;
    	}while(*(str+i) != '\0');
    	while( USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET );
    }
    
    ///重定向c库函数printf到串口,重定向后可使用printf函数
    int fputc(int ch, FILE *f)
    {
    		/* 发送一个字节数据到串口 */
    		USART_SendData(USART1, (uint8_t) ch);
    
    		/* 等待发送完毕 */
    		while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    
    		return (ch);
    }
    
    //重定向c库函数scanf到串口,重写向后可使用scanf、getchar等函数
    int fgetc(FILE *f)
    {
    		/* 等待串口输入数据 */
    		while (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET);
    
    		return (int)USART_ReceiveData(USART1);
    }
    
    

    bsp_usart.h

    #ifndef __BSP_USART_H
    #define __BSP_USART_H
    
    #include "stm32f10x.h"
    #include <stdio.h>
    
    void USART_Config(void);
    void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data);
    void Usart_SendHalfWord(USART_TypeDef* pUSARTx, uint16_t data);
    void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array,uint8_t num);
    void Usart_SendStr(USART_TypeDef* pUSARTx, uint8_t *str);
    
    
    
    #endif
    

     

    main.c

    #include "stm32f10x.h"
    #include "bsp_led.h"
    #include "bsp_usart.h"
    
    
    
    /**
      * @brief  主函数
      * @param  无
      * @retval 无
      */
    int main(void)
    {
    	USART_Config(); //初始化USART1
    	LED_GPIO_Config(); //初始化GPIO
    
    	printf( "这是一个串口控制RGB灯的程序\n" ); //向上位机发送一个字符串
    
    	while (1)
    	{
    		
    	
    	}
    }

     

    stm32f10x_it.c

    // 串口中断服务函数
    void USART1_IRQHandler(void)
    {
    uint8_t ucTemp;
    if(USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)
    {    
    ucTemp = USART_ReceiveData(USART1);
    USART_SendData(USART1,ucTemp); 
    }     
    switch(ucTemp)
    {
    case '1': LED_ON;
    break;
    
    case '2': LED_OFF;
    break;
    
    default: LED_OFF;
    break;
    }
    }

    对应上面的方法,我们也可以在stm32f10x_it.c中定义一个全局变量,然后在主函数中进行switch判断.

     

    方法2:

    不采用中断的方式,采用查询的方法(将中断函数USART1_IRQHandler(void))注释掉.  采用我们重定向的两个函数进行修改.

    在主函数改为:

     

    uint8_t ch;
        USART_Config();
        LED_GPIO_Config();
        
        printf( "这是一个串口控制RGB灯的程序\n" );
     
        while (1)
        {
          ch = getchar(); //等待用户输入返回信息
          printf( "ch=%c\n",ch );//返回给上位机
       
            switch(ch)
       {
                case '1': LED_ON;
                    break;
             
                case '2': LED_OFF;
                  break;
             
                default: LED_OFF;
                break;
         }
        }
    }

     

    转载于:https://www.cnblogs.com/wenshinlee/p/8973385.html

    展开全文
  • 前面两节讨论了如何利用 C语言编程单片机,控制普通 LED 小灯实现类似手机上面的“呼吸”,但是这两节介绍的方法交互性比较差,一旦程序烧写,就无法再从外界控制 LED 小灯的动作了。提升交互性所以,上一节介绍了...

    前面两节讨论了如何利用 C语言编程单片机,控制普通 LED 小灯实现类似手机上面的“呼吸灯”,但是这两节介绍的方法交互性比较差,一旦程序烧写,就无法再从外界控制 LED 小灯的动作了。

    41702ed7438334f2dcb0db0492139d5b.png

    提升交互性

    所以,上一节介绍了单片机和电脑通信的方法,旨在能够通过电脑发送命令给单片机控制 LED 小灯的动作。例如制定以下协议:

    • 电脑端输入 led twinkle 命令,单片机立刻控制 LED 小灯闪烁。
    • 电脑端输入 led breath 命令,单片机立刻控制 LED 小灯成为“呼吸灯”。
    • 电脑端输入 led off 命令,单片机立刻关闭 LED 小灯。

    最终实现如下效果:

    8c838bd6648f39e14f1f19343e67eff6.gif

    使用更加轻量级的通信函数

    上一节说到,keil 将 printf 的输出重定向到串口后,51 单片机也能很方便的使用 printf 将内部信息传输给电脑端。但是,使用这种方法开销非常大:

    01035c4eecda116eb9fa05760bad1223.png

    可以看出,上面的C语言代码仅比下面代码多了一个 printf(“”) 函数,最终编译生成的代码 size 却多处近 1 倍!这对于资源匮乏的 51 单片机来说,是不可接受的。因此自己实现一个轻量级的通信函数是非常必要的。

    这其实也是嵌入式程序开发的特点,不能浪费甚至一个字节。所以,嵌入式程序员都是勤俭持家的好手。

    那么,怎样实现轻量级的 printf 函数呢?嵌入式开发中常见的还有一个词——“裁剪”。顾名思义,就是为了节约资源,嵌入式程序员常常把一个模块中用不到的功能剔除,仅留下核心功能。

    现在想想,我们仅需 printf 发送字符串的功能,就可以完成需求。所以单片机往电脑端发送数据的C语言函数可以如下定义:

    void prints(char* str){ unsigned char i = 0; TI = 0; for(;str[i]!='0'; i++){  SBUF = str[i]; while(!TI); TI = 0; }}

    代码很简单,prints() 函数将 str 逐字节传递给 SBUF 寄存器,单片机则会自动将 SBUF 中的数据传输到串口,并且传送完毕后,将 TI 寄存器置 1。

    制定协议,实现电脑用“命令”控制 LED 小灯

    现在通信没问题了,那么怎样实现“命令”控制 LED 小灯呢?可以这么干:单片机随时检测串口数据,一旦接收到我们前面定义的命令,就做出相应的动作。所以,C语言代码可以如下写:

    #define TWINKLE "led twinkle"#define BREATH "led breath"#define LEDOFF "led off"if(is_new_cmd_ready()){ cmd_len = get_uart_cmd(cmd); prints("recv cmd:");prints(cmd);prints(""); if(is_cmd_match(cmd, BREATH, cmd_len)){ prints(" match ");prints(BREATH);prints(""); action = 1; }else if(is_cmd_match(cmd, TWINKLE, cmd_len)){ prints(" match ");prints(TWINKLE);prints(""); action = 2; }else if(is_cmd_match(cmd, LEDOFF, cmd_len)){ prints(" match ");prints(LEDOFF);prints(""); action = 3; }else{ prints(" cmd not match"); action = 0; } }
    ab20338a92fffa52825319e5a9dcf3cb.png

    上面的C语言代码中, action 会随着电脑端发送过来的命令做出相应改变。例如,电脑端发送“led twinkle”可以把 action 设置为 1,电脑端发送“led off”,可以让 action 等于 3。

    接下来,把相应的 LED 小灯动作写入不同的 action 就可以了:

    switch(action){ case 1: // 呼吸灯 break; case 2: // 闪烁的小灯 break; case 3: // 关闭小灯 break; default: break;  }

    “呼吸灯”,闪烁小灯,以及关闭小灯的动作前面几节已经介绍过,将其填入即可:

    31cb8b468b4d8b1387f986a87d29687f.png

    现在控制程序也就写好了,编译程序并烧写到单片机。

    实验,电脑通过发送命令,控制 LED 小灯变化

    初始状态如下图,因为电脑端还没有输入相应的命令,所以 LED 小灯处于熄灭状态。

    4b865a742072e81192a77ab3b81c5a69.png

    接着,在串口调试工具输入“led twinkle”,发送到单片机:

    f7ebb831cda618ddd4bd506d213532eb.png

    可以看到 LED 小灯开始闪烁了:

    0b87bf69418c98f2bffff305b5cd0838.gif

    然后再在电脑端输入“led breath”,发送到单片机:

    f7d0afa4c73b6a6ae80381786c4eee90.png

    会发现 LED 小灯变成呼吸灯了:

    10747506a36f4c81bb3ee84459bf9478.gif

    最后再输入“led off”,能够发现 LED 小灯被熄灭了。

    ebafbffa624bc64fb32d2df1b2bf7539.png

    完整的流程,请看文章开头的视频。

    至此,我们就实现了从电脑端发送命令,控制 LED 小灯动作。

    欢迎在评论区一起讨论,质疑。文章都是手打原创,每天最浅显的介绍C语言、linux等嵌入式开发,喜欢我的文章就关注一波吧,可以看到最新更新和之前的文章哦。

    展开全文
  • 本实验是为了测试STM32F407开发板和迪文DGUS串口屏通信是否正常做的一个测试程序,试验的目的是能通过触摸屏和开发板按键都能控制led 的亮灭,并且开始(key1)键和停止(key2)键按键按下后,状态反馈到触目屏的...
  • Qt串口控制cc2530led灯

    2021-04-06 21:04:19
    适合学习Qt和单片机程序开发的初学者
  • Android串口开发实现控制led灯的开关

    千次阅读 2019-04-01 15:49:56
    因为这篇帖子讲的是需要通过Android程序向继电器发送串口命令来控制继电器的开关,继而来控制led灯的开关,所以这篇帖子看起来比较枯燥。 串口开发首先要有串口的开发环境,此处用的是aar包。 下载地址: 串口开发...

     

    • 因为这篇帖子讲的是需要通过Android程序向继电器发送串口命令来控制继电器的开关,继而来控制led灯的开关,所以这篇帖子看起来比较枯燥。
    • 串口开发首先要有串口的开发环境,此处用的是aar包。

                下载地址: 串口开发环境

                 //串口 

                 api(name: 'serialport-1.0.1', ext: 'aar')   

     

    • 将以上arr库下载下来之后,导入项目的libs包下,然后在app的build.gradle文件中添加以下代码,即可通过代码让Android        程序向继电器发送串口命令:
    • 完成之后点击Sysn Now,在开始正式开发之前,一定要认真阅读Android开发板和继电器的开发说明,弄清开发板上所有的串口所对应的位置,同时搞清继电器所使用的波特率(如果串口名称或者波特率对应不上的话,使用Android程序向继电器发送串口命令可能会没有反应)。
    1. 以下是打开串口对应的串口的代码: 
        /**
         * 打开串口,接收,发送数据数据
         * 通过串口,接收单片机发送来的数据
         */
        public boolean openSerialPort(String port_name,int port_clound) {
            try {
                serialPort = new SerialPort(new File(port_name), port_clound, 0);
                //调用对象SerialPort方法,获取串口中"读和写"的数据流
                inputStream = serialPort.getInputStream();
                outputStream = serialPort.getOutputStream();
                isStart = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
            getSerialPort();
            return isStart;
        }

           上边的方法,首先看参数,port_name就是开发板上的对应的串口的名称,向继电器板发送命令就是通过该串口发送的,串口的名称一定要用开发板上的串口名称并且与串口所对应的位置一致,否则可能报错SecurityException。

           port_clound是继电器的波特率,一定要和继电器的波特率对应好,不然可能会没有反应。

           然后根据串口的名称和波特率创建SerialPort的实例,然后创建输入流(用来接收继电器返回的数据,一般时候也用不到,你只要看着灯亮了,关了就好了,还在乎继电器返回的数据干嘛~),输出流(用来向继电器发送串口命令),改变串口打开的状态isStart = true,同时调用了getSerialPort(),接下来看一下getSerialPort()里边的东西;   

    private void getSerialPort() {
        mReceiveThread = new ReceiveThread();
        mReceiveThread.start();
    }

             这里只是开启了一个ReceiveThread线程,看一下这个线程里边作了什么。      

    /**
     * 接收串口数据的线程
     */
    private class ReceiveThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (isStart) {
                if (inputStream == null) {
                    return;
                }
                byte[] readData = new byte[1024];
                try {
                    int size = inputStream.read(readData);
                    if (size > 0) {
                        String readString = DataUtils.ByteArrToHex(readData, 0, size);
                        if (!StringUtils.isEmpty(readString)) {
    
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

           注释也说的很明白了,就是用来接收继电器返回的的数据用的,while (isStart) 说明只要你打开了串口,就开启一个死循环,在死循环里输入流一直在读取继电器返回来的数据。

    • 有打开串口的方法,肯定就要有关闭串口的方法,接下来看一下关闭串口的方法。
    /**
     * 关闭串口
     * 关闭串口中的输入输出流
     */
    public void closeSerialPort() {
        Log.i("test", "关闭串口");
        try {
            if (inputStream != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
            isStart = false;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

            这里只是将输入流和输出进行关闭,并改变串口的打开状态:isStart = false; 终止ReceiveThread线程中的循环。

    • 接下来看一下看一下最重要的,向继电器发送串口命令。        
    /**
         * 发送数据
         * 通过串口,发送数据到继电器
         *
         * @param data 要发送的数据
         */
        public void sendSerialPort(String data) {
            try {
                byte[] sendData = DataUtils.HexToByteArr(data);
    //            byte[] sendData = data.getBytes();
                outputStream.write(sendData);
                outputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

           其实也很简单就是通过DataUtils.HexToByteArr(data);将String类型的串口命令转换为字节数组,通过输出流将串口命令字节数组进行发送。

    • 到这有的猿(媛)就要问了,那String类型的串口命令你怎么知道发送什么啊,别急,看下边:

               串口命令可以通过工具进行获取:串口命令获取工具

               使用串口线将你的电脑和开发板进行连接,连接之后打开串口命令获取工具

            刚打开的页面是这样的,输入开发板的串口名称,之后将对应的串口名称输入进去,点击打开串口按钮,之后会提示打开串口是否成功,对应的位置的两个线进行短路(短路之后你给串口发送什么串口命令,返回什么串口命令显示在左边的白色框内),然后点击Open按钮发送打开继电器的命令,如果你短路成功的话继电器命令会显示在左边白色框内,点击close按钮和点击Open按钮同理。

            以上代码均出自:

    /**
     * Created by tehike
     * Time : 2018/11/29.10:55
     * data : 开关读写串口的工具类
     */
    
    public class SerialPortUtil {
        private SerialPort serialPort = null;
        private InputStream inputStream = null;
        private OutputStream outputStream = null;
        private ReceiveThread mReceiveThread = null;
        private boolean isStart = false;
    
        private static SerialPortUtil portUtil;
    
        //单例模式获取工具类的实例
        public static SerialPortUtil getPortUtil() {
            if (portUtil == null) {
                portUtil = getInstance();
            }
            return portUtil;
        }
    
        /**
         * 创建实例时加同步锁
         *
         * @return 返回当前实例
         */
        private synchronized static SerialPortUtil getInstance() {
            if (portUtil == null) {
                portUtil = new SerialPortUtil();
            }
            return portUtil;
        }
    
        /**
         * 打开串口,接收,发送数据数据
         * 通过串口,接收单片机发送来的数据
         */
        public boolean openSerialPort(String port_name,int port_clound) {
            try {
                serialPort = new SerialPort(new File(port_name), port_clound, 0);
    //            调用对象SerialPort方法,获取串口中"读和写"的数据流
                inputStream = serialPort.getInputStream();
                outputStream = serialPort.getOutputStream();
                isStart = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
            getSerialPort();
            return isStart;
        }
    
        /**
         * 关闭串口
         * 关闭串口中的输入输出流
         */
        public void closeSerialPort() {
            Log.i("test", "关闭串口");
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
                isStart = false;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 发送数据
         * 通过串口,发送数据到单片机
         *
         * @param data 要发送的数据
         */
        public void sendSerialPort(String data) {
            try {
                byte[] sendData = DataUtils.HexToByteArr(data);
    //            byte[] sendData = data.getBytes();
                outputStream.write(sendData);
                outputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        private void getSerialPort() {
            mReceiveThread = new ReceiveThread();
            mReceiveThread.start();
        }
    
        /**
         * 接收串口数据的线程
         */
        private class ReceiveThread extends Thread {
            @Override
            public void run() {
                super.run();
                while (isStart) {
                    if (inputStream == null) {
                        return;
                    }
                    byte[] readData = new byte[1024];
                    try {
                        int size = inputStream.read(readData);
                        if (size > 0) {
                            String readString = DataUtils.ByteArrToHex(readData, 0, size);
                            if (!StringUtils.isEmpty(readString)) {
    
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    最后附上DataUtils工具类的代码:

    public class DataUtils {
        //-------------------------------------------------------
        // 判断奇数或偶数,位运算,最后一位是1则为奇数,为0是偶数
        public static int isOdd(int num) {
            return num & 1;
        }
    
        //-------------------------------------------------------
        //Hex字符串转int
        public static int HexToInt(String inHex) {
            return Integer.parseInt(inHex, 16);
        }
    
        public static String IntToHex(int intHex){
            return Integer.toHexString(intHex);
        }
    
        //-------------------------------------------------------
        //Hex字符串转byte
        public static byte HexToByte(String inHex) {
            return (byte) Integer.parseInt(inHex, 16);
        }
    
        //-------------------------------------------------------
        //1字节转2个Hex字符
        public static String Byte2Hex(Byte inByte) {
            return String.format("%02x", new Object[]{inByte}).toUpperCase();
        }
    
        //-------------------------------------------------------
        //字节数组转转hex字符串
        public static String ByteArrToHex(byte[] inBytArr) {
            StringBuilder strBuilder = new StringBuilder();
            for (byte valueOf : inBytArr) {
                strBuilder.append(Byte2Hex(Byte.valueOf(valueOf)));
                strBuilder.append(" ");
            }
            return strBuilder.toString();
        }
    
        //-------------------------------------------------------
        //字节数组转转hex字符串,可选长度
        public static String ByteArrToHex(byte[] inBytArr, int offset, int byteCount) {
            StringBuilder strBuilder = new StringBuilder();
            int j = byteCount;
            for (int i = offset; i < j; i++) {
                strBuilder.append(Byte2Hex(Byte.valueOf(inBytArr[i])));
            }
            return strBuilder.toString();
        }
    
        //-------------------------------------------------------
        //转hex字符串转字节数组
        public static byte[] HexToByteArr(String inHex) {
            byte[] result;
            int hexlen = inHex.length();
            if (isOdd(hexlen) == 1) {
                hexlen++;
                result = new byte[(hexlen / 2)];
                inHex = "0" + inHex;
            } else {
                result = new byte[(hexlen / 2)];
            }
            int j = 0;
            for (int i = 0; i < hexlen; i += 2) {
                result[j] = HexToByte(inHex.substring(i, i + 2));
                j++;
            }
            return result;
        }
    
        /**
         * 按照指定长度切割字符串
         *
         * @param inputString 需要切割的源字符串
         * @param length      指定的长度
         * @return
         */
        public static List<String> getDivLines(String inputString, int length) {
            List<String> divList = new ArrayList<>();
            int remainder = (inputString.length()) % length;
            // 一共要分割成几段
            int number = (int) Math.floor((inputString.length()) / length);
            for (int index = 0; index < number; index++) {
                String childStr = inputString.substring(index * length, (index + 1) * length);
                divList.add(childStr);
            }
            if (remainder > 0) {
                String cStr = inputString.substring(number * length, inputString.length());
                divList.add(cStr);
            }
            return divList;
        }
    
        /**
         * 计算长度,两个字节长度
         *
         * @param val value
         * @return 结果
         */
        public static String twoByte(String val) {
            if (val.length() > 4) {
                val = val.substring(0, 4);
            } else {
                int l = 4 - val.length();
                for (int i = 0; i < l; i++) {
                    val = "0" + val;
                }
            }
            return val;
        }
    
        /**
         * 校验和
         *
         * @param cmd 指令
         * @return 结果
         */
        public static String sum(String cmd) {
            List<String> cmdList = DataUtils.getDivLines(cmd, 2);
            int sumInt = 0;
            for (String c : cmdList) {
                sumInt += DataUtils.HexToInt(c);
            }
            String sum = DataUtils.IntToHex(sumInt);
            sum = DataUtils.twoByte(sum);
            cmd += sum;
            return cmd.toUpperCase();
        }
    
    }
    • 一定要注意串口名称以及位置,和串口的波特率的问题。
    展开全文
  • 程序使用STM32-PZ6806L开发板,实现USART3与PC端串口的超级终端通信,通过超级终端,用户从PC机键盘输入按键可以控制开发板的LED等状态改变。内含Keil5环境的项目源码和HyperTerminal超级终端软件。
  • TX522与STM32串口通信(控制LED灯亮灭) ...这篇文章将通过一个串口通信的小程序,使STM32读取TX522发送过来的卡号控制LED灯亮灭。 TX522相关资料 mifare卡读写模块TX522B应用指南_V1.06 这是TX522的模块资料
  • 通过延时函数,中断函数,9600波特率,switch ——case等函数完成程序 使用串口助手发送16进制数控制相应的led灯的亮灭
  • 串口助手发送特定字符来控制LED的亮灭?? 或者给个思路吧!核心的代码写一点也好啊! 有没有大神帮忙把控制部分的程序写下,谢谢啦!刚开始学,请教啊!
  • 一、硬件介绍本程序使用开发板:STM32-PZ6806L1、GPIO控制LED开发板中LED的硬件电路参看:直接通过寄存器地址操作控制LED灯2、串口开发板中连接了MCU的2个串口,分别为USART1和USART3,其中USART1通过CH340G接PC端...
  • Android通过jni控制LED灯.zip,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • 2)收到 PC 发送过来的数据,通过数据内容分析控制 LED   注:嵌入式开发中,当程序能跑起来后,串口是第一个要跑起来的外设,所有的工作状态,交互信息都会从串口输出。用的USB转串口芯片是世界上最好的串口芯片 ...
  • 这是一个我自己写的上位机控制单片机LED灯亮灭的程序,里面包括上位机和下位机源码。软件涉及到数据传输过程中的打包与解包算法,具有可扩展性。对于第一次写上位机的同学或专业人士来说,这可以作为一个参考。
  • Arduino学习(3)——串口LED灯控制

    千次阅读 2019-04-09 21:55:21
    直接上程序 /*---------------------------------------------------------------------------- 相关函数: Serial.begin(speed) 串口定义波特率函数,speed表示波特率,如9600,115200等 int Serial.available() ...
  • 单片机串口控制+程序

    2018-10-10 21:38:05
    1.实现串口控制多个LED小灯。 2.实现 串口控制温度模块使单片机显示板能显示当前温度。 3.实现串口控制一个继电器接风扇 4.以上串口的控制,利用单片机上所留的RX、TX口输入数据,实现控制(比如,我往TX口发送字母...
  • 串口控制FPGA Led亮灭

    2015-01-08 23:31:18
    http://blog.csdn.net/mybelief321/article/details/42532247 自己用C#写的通过串口控制FPGA的LED灯亮灭,数码管显示LED亮的个数,FPGA的程序也是自己看书编写修改的,分享出来吧,但愿对你有用
  • OK6410串口通信控制LED

    千次阅读 2012-07-05 10:25:24
    串口控制LED灯的点亮。我们要实现的功能是: 在PC的超级终端里 输入 1,LED1点亮,并关闭其他灯。 输入 2,LED2点亮,并关闭其他灯。 输入 3,LED3点亮,并关闭其他灯。 输入 4,LED4点亮,并关闭其他灯。 ...
  • 实验六键盘控制LED灯实验1实验目的(1)通过实验掌握中断式键盘控制与设计方法;(2)熟练编写S3C2410中断服务程序。2实验设备(1)S3C2410嵌入式开发板,JTAG仿真器。(2)软件:PC机操作系统WindowsXP,ADS1.2集成开发环境...
  • arduino实现超声波测距控制LED灯

    千次阅读 2019-06-20 10:21:53
    今天我们来学习一下用arduino 实现用超声波来控制LED灯显示。 工具/原料 : ardunio UNO板 超声波传感器 LED灯 连接线 方法/步骤: (1) 编写好代码,准备硬件 (2) 用线连接硬件 (3) 编译程序,上传代码; (4) 用手...
  • VB上位机控制51单片机LED灯(包含上位机和下位机程序),单片机通过串口与电脑连接,波特率9600
  • Stm32CubeMx实现串行通信控制LED灯

    千次阅读 2020-06-08 14:53:40
    Stm32CubeMx实现串行通信控制LED灯知识储备USART和UART使用串口和电脑进行通信Stm32CubeMx配置代码编写重写fputc添加stdio.h修改中断服务程序添加自定义函数的声明定义变量编写 USART 接收中断服务函数编写main函数 ...
  • 上篇“【物联网(IoT)开发】Arduino 入门 Hello World(LED闪烁)”只是通过将一段程序烧录到Arduino开发板上控制LEC闪烁,没有任何连网动作,也就是说断开网络提供电源依然还可以工作。本文将介绍如何开发一个应用...
  • stm32+ESP8266实现最简单的手机控制LED灯

    万次阅读 多人点赞 2019-07-07 20:12:05
    上一篇文章中,我们讲了ESP8266和USB转TTL模块直接相连实现在串口调试助手里发送AT指令,从而达到最简单的控制ESP8266的方式。通过这种方式,也可以使我们进一步加深对于AT指令的理解。这篇文章是在之前的基础上,将...
  • 代码注释清楚了,可以直接看。 #include "stm32f10x.h" ...//在此程序中,需要将bsp_usart.c中的NVIC中断部分注释掉否则报错 int main(void) { uint8_t ch; USART_Config(); //配置串口 LED_GPIO_Config(); /...
  • 目标1、认识声音传感器2、读取声音传感器数值3、制作声控灯实验材料X-TACO板配套USB数据线配套磁吸线配套声音传感器配套LED灯内容实验步骤①将声音传感器的四个针脚连接磁吸线上的四个针脚②将磁吸线连接到X-TACO板...
  • 上篇“【物联网(IoT)开发】Arduino 入门 Hello World(LED闪烁)”只是通过将一段程序烧录到Arduino开发板上控制LEC闪烁,没有任何连网动作,也就是说断开网络提供电源依然还可以工作。本文将介绍如何开发一个应用...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 162
精华内容 64
关键字:

串口控制led灯程序