devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32CubeIDE开发(二十五)， 物联网应用之stm32的蓝牙通信设计_cubemx+蓝牙

作者：羊村懒王 | 2024-02-27 13:54:26

赞

踩

cubemx+蓝牙

目录

一、蓝牙通信技术

二、MCU及蓝牙模块

 三、cubeMX配置MCU及蓝牙接口

        【1】创建工程

         【2】CubeMX配置

 四、代码设计

        【1】首先创建usart1接口的调试输出支持

        【2】创建按键驱动、LED驱动、延时函数功能的支持

        【3】创建串口驱动程序，主要是复写串口回调功能

        【4】创建蓝牙驱动

五、编译及测试

        【1】功能调用及编译

        【2】程序测试

一、蓝牙通信技术

        蓝牙技术是一种点对点点对面的网络构架，他可以在限制的范围内以很快的速度传输网络数据，在物联网应用中，支持网状网络的物联网短距离无线通信。目前它还被广泛用于智能可穿戴设备、智能门锁、智能医疗设备、智能照明设备、智能家电等消费电子、工业采集、汽车电子、智能建筑等所有的物联网智能产品中。

        蓝牙是无线个人局域网，最初由爱立信制作，后来由蓝牙技术联盟制定了技术标准。蓝牙产品包括小型蓝牙模块，以及支持连接的蓝牙无线电和软件。 如果两台蓝牙设备想相互交流，则需要进行配对，一台设备将成为主设备，所有其他设备都将成为从设备。 通信时，主站侧需要进行检索并开始配对，如果构建链成功，则双方需要能够发送接收数据。在通信状态下，主侧和从侧的设备都开始切断，可以切断蓝牙链接。蓝牙通信本质上就是无线电传输技术，蓝牙的工作波段为2400–2483.5MHz（包括防护频带）。这是全球范围内无需取得执照（但并非无管制的）的工业、科学和医疗用（ISM）波段的 2.4 GHz 短距离无线电频段。

二、MCU及蓝牙模块

        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：

        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。

         蓝牙模块为JDY-08 蓝牙透传模块，基于蓝牙 4.0 协议标准，工作频段为 2.4GHZ 范围，调制 方式为 GFSK，最大发射功率为 0db，最大发射距离 80 米，采用 TICC2541 芯片设计，支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。

        TICC2541 芯片 引脚：

         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：

         以及本文用到两个AT指令：

 三、cubeMX配置MCU及蓝牙接口

        本工程设计功能如下：

        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。

        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。

        功能：

  •         按键功能，用于按键时向蓝牙模块发送AT指令；
  •         LED功能，用于接收蓝牙模块数据时做出闪灯响应；
  •         蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
  •         串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。

        【1】创建工程

        1）新建stm32工程，选择芯片STM32F103C8T6

         2）为工程命名完成创建

         【2】CubeMX配置

        1）开启sys mode接口

         2）开启RCC

         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。

         4）开启串口USART1、USART2中断功能

         5）串口引脚参数配置

         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：

        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。

          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。

 四、代码设计

        【1】首先创建usart1接口的调试输出支持

        1）禁用syscalls.c，右键选择该文件进入属性页面设置。

         2）在工程目录下创建源码目录ICore，添加文件夹print及print.h/print.c，实现对系统printf函数的映射到usart1输出显示功能。

        print.h

  1. #ifndef INC_RETARGET_H_
  2. #define INC_RETARGET_H_
  3.  
  4. #include "stm32f1xx_hal.h"
  5. #include "stdio.h"//用于printf函数串口重映射
  6. #include <sys/stat.h>
  7.  
  8. void ResetPrintInit(UART_HandleTypeDef  *huart);
  9.  
  10. int _isatty(int fd);
  11. int _write(int fd, char* ptr, int len);
  12. int _close(int fd);
  13. int _lseek(int fd, int ptr, int dir);
  14. int _read(int fd, char* ptr, int len);
  15. int _fstat(int fd, struct stat* st);
  16.  
  17. #endif /* INC_RETARGET_H_ */

        print.c

  1. #include <_ansi.h>
  2. #include <_syslist.h>
  3. #include <errno.h>
  4. #include <sys/time.h>
  5. #include <sys/times.h>
  6. #include <limits.h>
  7. #include <signal.h>
  8. #include <stdint.h>
  9. #include <stdio.h>
  10.  
  11. #include "print.h"
  12.  
  13. #if !defined(OS_USE_SEMIHOSTING)
  14. #define STDIN_FILENO  0
  15. #define STDOUT_FILENO 1
  16. #define STDERR_FILENO 2
  17.  
  18. UART_HandleTypeDef *gHuart;
  19.  
  20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
  21.   gHuart = huart;
  22.   /* Disable I/O buffering for STDOUT  stream, so that
  23.    * chars are sent out as soon as they are  printed. */
  24.   setvbuf(stdout, NULL, _IONBF, 0);
  25. }
  26. int _isatty(int fd) {
  27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  28.     return 1;
  29.   errno = EBADF;
  30.   return 0;
  31. }
  32. int _write(int fd, char* ptr, int len) {
  33.   HAL_StatusTypeDef hstatus;
  34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
  35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
  36.     if (hstatus == HAL_OK)
  37.       return len;
  38.     else
  39.       return EIO;
  40.   }
  41.   errno = EBADF;
  42.   return -1;
  43. }
  44. int _close(int fd) {
  45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  46.     return 0;
  47.   errno = EBADF;
  48.   return -1;
  49. }
  50. int _lseek(int fd, int ptr, int dir) {
  51.   (void) fd;
  52.   (void) ptr;
  53.   (void) dir;
  54.   errno = EBADF;
  55.   return -1;
  56. }
  57. int _read(int fd, char* ptr, int len) {
  58.   HAL_StatusTypeDef hstatus;
  59.   if (fd == STDIN_FILENO) {
  60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
  61.     if (hstatus == HAL_OK)
  62.       return 1;
  63.     else
  64.       return EIO;
  65.   }
  66.   errno = EBADF;
  67.   return -1;
  68. }
  69. int _fstat(int fd, struct stat* st) {
  70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
  71.     st->st_mode = S_IFCHR;
  72.     return 0;
  73.   }
  74.   errno = EBADF;
  75.   return 0;
  76. }
  77.  
  78. #endif //#if !defined(OS_USE_SEMIHOSTING)

        【2】创建按键驱动、LED驱动、延时函数功能的支持

         1）在ICore添加delay目录，并添加delay.h/delay.c源文件

        delay.h

  1. #ifndef DELAY_DELAY_H_
  2. #define DELAY_DELAY_H_
  3.  
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
  5. void delay_us(uint32_t us); //C文件中的函数声明
  6.  
  7. #endif /* DELAY_DELAY_H_ */

        delay.c

  1. #include "delay.h"
  2.  
  3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
  4. {
  5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
  6.     while (delay--); //循环delay次，达到1微秒延时
  7. }

        2）在ICore添加key目录，并添加key.h/key.c源文件

        key.h

  1. #ifndef KEY_KEY_H_
  2. #define KEY_KEY_H_
  3.  
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
  5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
  6. #include "../delay/delay.h"
  7.  
  8. uint8_t KEY_1(void);//按键1
  9. uint8_t KEY_2(void);//按键2
  10.  
  11. #endif /* KEY_KEY_H_ */

        key.c

  1. #include "key.h"
  2.  
  3. uint8_t KEY_1(void)
  4. {
  5. 	uint8_t a;
  6. 	a=0;//如果未进入按键处理，则返回0
  7. 	if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  8. //		HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
  9. 		delay_us(20000);//延时去抖动
  10. 		if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  11. 			a=1;//进入按键处理，返回1
  12. 		}
  13. 	}
  14. 	while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
  15. 	delay_us(20000);//延时去抖动（避开按键放开时的抖动）
  16. 	return a;
  17. }
  18.  
  19. uint8_t KEY_2(void)
  20. {
  21. 	uint8_t a;
  22. 	a=0;//如果未进入按键处理，则返回0
  23. 	if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  24. //		HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
  25. 		delay_us(20000);//延时去抖动
  26. 		if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  27. 			a=1;//进入按键处理，返回1
  28. 		}
  29. 	}
  30. 	while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
  31. 	delay_us(20000);//延时去抖动（避开按键放开时的抖动）
  32. 	return a;
  33. }

        3）在ICore添加led目录，并添加led.h/led.c源文件

        key.h

  1. #ifndef LED_LED_H_
  2. #define LED_LED_H_
  3.  
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
  5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
  6.  
  7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
  8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
  9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
  10. void LED_1_Contrary(void);//LED1状态取反
  11. void LED_2_Contrary(void);//LED2状态取反
  12.  
  13. #endif /* LED_LED_H_ */

        key.c

  1. #include "led.h"
  2.  
  3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
  4. {
  5. 	if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
  6. 	else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
  7. }
  8. void LED_2(uint8_t a)//LED2独立控制函数（0为熄灭，其他值为点亮）
  9. {
  10. 	if(a)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
  11. 	else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
  12. }
  13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
  14. {
  15. 	if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
  16. 	else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
  17. 	if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
  18. 	else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
  19. }
  20. void LED_1_Contrary(void){
  21. 	HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
  22. }
  23. void LED_2_Contrary(void){
  24. 	HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
  25. }

        【3】创建串口驱动程序，主要是复写串口回调功能

        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

        usart.h

  1. #ifndef INC_USART_H_
  2. #define INC_USART_H_
  3.  
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
  5. #include <string.h>//用于字符串处理的库
  6. #include "../print/print.h"//用于printf函数串口重映射
  7.  
  8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
  9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
  10.  
  11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
  12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
  13.  
  14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
  15. extern uint16_t USART1_RX_STA;//接收状态标记
  16. extern uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
  17.  
  18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
  19. extern uint16_t USART2_RX_STA;//接收状态标记
  20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
  21.  
  22.  
  23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
  24.  
  25. #endif /* INC_USART_H_ */

        usart.c

  1. #include "usart.h"
  2.  
  3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
  4. /*
  5.  * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
  6.  * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
  7.  * bit13:预留
  8.  * bit12:预留
  9.  * bit11~0：接收到的有效字节数目(0~4095)
  10.  */
  11. uint16_t USART1_RX_STA=0;
  12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
  13.  
  14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
  15. uint16_t USART2_RX_STA=0;
  16. uint8_t USART2_NewData;
  17.  
  18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
  19. {
  20. 	if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
  21.     {
  22. //		printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
  23. 		if(USART1_NewData==0x0d){//回车标记
  24. 			USART1_RX_STA|=0x8000;//标记接到回车
  25. 		}else{
  26. 			if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
  27. 				USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
  28. 				USART1_RX_STA++;  //数据长度计数加1
  29. 			}else{
  30. 				USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
  31. 			}
  32.         }
  33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
  34.     }
  35. 	if(huart ==&huart2)//判断中断来源（串口2：BT模块）
  36. 	{
  37. //		printf("%c",USART2_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
  38. 		if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,（手机APP“蓝牙调试器”回复数据以0x5A为结束符）
  39. 			USART2_RX_STA|=0x8000;//标记接到回车
  40. 		}else{
  41. 			if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
  42. 				USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组
  43. 				USART2_RX_STA++;  //数据长度计数加1
  44. 			}else{
  45. 				USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
  46. 			}
  47.         }
  48. 		HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
  49. 	}
  50. }

        【4】创建蓝牙驱动

        该驱动主要实现通过usart2向蓝牙模块写入数据，（读取数据主要通过串口usart2回调，在usart.c中实现）。在ICore添加bt目录，并添加bt.h/bt.c源文件，实现蓝牙驱动功能

        bt.h

  1. #ifndef BT_BT_H_
  2. #define BT_BT_H_
  3.  
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
  5. #include "main.h"
  6. #include "../usart/usart.h"
  7. #include "../delay/delay.h"
  8. #include <string.h>//用于字符串处理的库
  9. #include <stdarg.h>
  10. #include <stdlib.h>
  11. #include "stdio.h"
  12.  
  13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
  14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
  15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
  16.  
  17. #endif /* BT_BT_H_ */

        bt.c

  1. #include "bt.h"
  2.  
  3. //蓝牙模块唤醒函数
  4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
  5. void BT_WEEKUP (void)
  6. {
  7. 	HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
  8. 	delay_us(100);
  9. 	HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
  10. }
  11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
  12. //调用方法：BT_printf("123"); //向UART2发送字符123
  13. void BT_printf (char *fmt, ...)
  14. {
  15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
  16.     uint16_t i=0;
  17.     va_list arg_ptr;
  18.     va_start(arg_ptr, fmt);
  19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
  20.     i=strlen(buff);//得出数据长度
  21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
  22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
  23.     va_end(arg_ptr);
  24. }
  25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

五、编译及测试

        【1】功能调用及编译

        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：

  1. /* USER CODE END Header */
  2. /* Includes ------------------------------------------------------------------*/
  3. #include "main.h"
  4.  
  5. /* Private includes ----------------------------------------------------------*/
  6. /* USER CODE BEGIN Includes */
  7. #include "../../ICore/led/led.h"
  8. #include "../../ICore/key/key.h"
  9. #include "../../ICore/delay/delay.h"
  10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
  11. #include "../../ICore/bt/bt.h"
  12. /* USER CODE END Includes */
  13.  
  14. /* Private typedef -----------------------------------------------------------*/
  15. /* USER CODE BEGIN PTD */
  16.  
  17. /* USER CODE END PTD */
  18.  
  19. /* Private define ------------------------------------------------------------*/
  20. /* USER CODE BEGIN PD */
  21. /* USER CODE END PD */
  22.  
  23. /* Private macro -------------------------------------------------------------*/
  24. /* USER CODE BEGIN PM */
  25.  
  26. /* USER CODE END PM */
  27.  
  28. /* Private variables ---------------------------------------------------------*/
  29. UART_HandleTypeDef huart1;
  30. UART_HandleTypeDef huart2;
  31.  
  32. /* USER CODE BEGIN PV */
  33.  
  34. /* USER CODE END PV */
  35.  
  36. /* Private function prototypes -----------------------------------------------*/
  37. void SystemClock_Config(void);
  38. static void MX_GPIO_Init(void);
  39. static void MX_USART1_UART_Init(void);
  40. static void MX_USART2_UART_Init(void);
  41. /* USER CODE BEGIN PFP */
  42.  
  43. /* USER CODE END PFP */
  44.  
  45. /* Private user code ---------------------------------------------------------*/
  46. /* USER CODE BEGIN 0 */
  47.  
  48. /* USER CODE END 0 */
  49.  
  50. /**
  51.   * @brief  The application entry point.
  52.   * @retval int
  53.   */
  54. int main(void)
  55. {
  56.   /* USER CODE BEGIN 1 */
  57.  
  58.   /* USER CODE END 1 */
  59.  
  60.   /* MCU Configuration--------------------------------------------------------*/
  61.  
  62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  63.   HAL_Init();
  64.  
  65.   /* USER CODE BEGIN Init */
  66.  
  67.   /* USER CODE END Init */
  68.  
  69.   /* Configure the system clock */
  70.   SystemClock_Config();
  71.  
  72.   /* USER CODE BEGIN SysInit */
  73.  
  74.   /* USER CODE END SysInit */
  75.  
  76.   /* Initialize all configured peripherals */
  77.   MX_GPIO_Init();
  78.   MX_USART1_UART_Init();
  79.   MX_USART2_UART_Init();
  80.   /* USER CODE BEGIN 2 */
  81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
  82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
  83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
  84.   /* USER CODE END 2 */
  85.  
  86.   /* Infinite loop */
  87.   /* USER CODE BEGIN WHILE */
  88.   while (1)
  89.   {
  90. 	  //demo 蓝牙02
  91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
  92.     	 BT_printf("%c",USART2_RX_STA);
  93.     	 if((USART2_RX_STA&0x7FFF) == 1)	//判断接收数量1个（手机控制程序）
  94.     	 {
  95.     		 BT_printf("%c",USART2_RX_BUF[0]);
  96.     		 switch (USART2_RX_BUF[0]){//判断接收数据的内容
  97. 				case 0x41:
  98. 					LED_1(1);//LED1控制
  99. 					BT_printf("Relay ON");//返回数据内容，在手机APP上显示
  100. 					break;
  101. 				case 0x44:
  102. 					LED_1(0);//LED1控制
  103. 					BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
  104. 					break;
  105. 				case 0x42:
  106. 					LED_2(1);//LED1控制
  107. 					BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
  108. 					break;
  109. 				case 0x45:
  110. 					LED_2(0);//LED1控制
  111. 					BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
  112. 					break;
  113. 				case 0x43:
  114. 					LED_1(0);//LED1控制
  115. 					LED_2(0);//LED1控制
  116. 					BT_printf("BEEP");//返回数据内容，在手机APP上显示
  117. 					break;
  118. 				case 0x46:
  119. 					BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
  120. 					HAL_Delay(1000);//延时
  121. 					NVIC_SystemReset();//系统软件复位函数
  122. 					break;
  123. 				default:
  124. 					//冗余语句
  125. 					break;
  126. 			  }
  127. 		 }
  128. 		printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
  129.          USART2_RX_STA=0;//标志位清0，准备下次接收
  130.       }
  131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
  132.       if(USART1_RX_STA&0xC000){//结束标记
  133.     	  BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
  134.     	  USART1_RX_STA=0;//接收重新开始
  135.     	  HAL_Delay(100);//等待
  136.       }
  137. 	  if(KEY_1())//按下KEY1判断
  138. 	  {
  139. 		  LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
  140. 		  LED_2(0);//LED2控制
  141. 		  BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
  142. 	  }
  143. 	  if(KEY_2())//按下KEY2判断
  144. 	  {
  145. 		  LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
  146. 		  LED_2(1);//LED2控制
  147. 		  BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
  148. 	  }
  149.     /* USER CODE END WHILE */
  150.  
  151.     /* USER CODE BEGIN 3 */
  152.   }
  153.   /* USER CODE END 3 */
  154. }

       2）设置编译输出支持，右键工程进入项目属性设置页面：

          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：

        【2】程序测试

        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：

        FlyMCU加载工具，将生成的.hex程序文件加载到板子上

        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入

        蓝牙调试器工具，本文用的是1.9安卓版本。

         后续补充，应读者要求，提供CSDN下载链接：        https://download.csdn.net/download/py8105/87174936

        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：

         3）手机打开蓝牙调试器（别忘了开启手机蓝牙功能），进入界面，搜索蓝牙，点击蓝牙边上“+”按钮连接蓝牙模块，采用SSCOM串口工具连接到usart1上，就可以通过蓝牙通信实现手机（蓝牙调试器）与电脑（串口工具）的通信了，在蓝牙调试器发送数据时，十六进制时需要加上“0A”作为结尾，如果十进制发送时，注意加上换行再发送：

        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：

  1. if(KEY_1())//按下KEY1判断
  2. 	  {
  3. 		  LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
  4. 		  LED_2(0);//LED2控制
  5. 		  BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
  6. 	  }

        串口发送数据：

        可以进入按钮控制页面进行指令定制设置

         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号