一、蓝牙通信技术
! R2 j, K) }4 [" B) j+ A$ ?        蓝牙技术是一种点对点点对面的网络构架，他可以在限制的范围内以很快的速度传输网络数据，在物联网应用中，支持网状网络的物联网短距离无线通信。目前它还被广泛用于智能可穿戴设备、智能门锁、智能医疗设备、智能照明设备、智能家电等消费电子、工业采集、汽车电子、智能建筑等所有的物联网智能产品中。
& f" A# c! J/ ^& T
        蓝牙是无线个人局域网，最初由爱立信制作，后来由蓝牙技术联盟制定了技术标准。蓝牙产品包括小型蓝牙模块，以及支持连接的蓝牙无线电和软件。 如果两台蓝牙设备想相互交流，则需要进行配对，一台设备将成为主设备，所有其他设备都将成为从设备。 通信时，主站侧需要进行检索并开始配对，如果构建链成功，则双方需要能够发送接收数据。在通信状态下，主侧和从侧的设备都开始切断，可以切断蓝牙链接。蓝牙通信本质上就是无线电传输技术，蓝牙的工作波段为2400–2483.5MHz（包括防护频带）。这是全球范围内无需取得执照（但并非无管制的）的工业、科学和医疗用（ISM）波段的 2.4 GHz 短距离无线电频段。

6 ]# V0 ]- K+ Y0 _2 {
二、MCU及蓝牙模块
. }' x, T; c+ p$ I6 w4 r        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：

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


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

0 F! {1 R: m3 \8 ^9 _/ `7 J8 W        TICC2541 芯片 引脚：
- v) G  }/ p/ P# n


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



         以及本文用到两个AT指令：
/ N7 S0 a/ \5 A1 K* U, |


三、cubeMX配置MCU及蓝牙接口
: m2 C7 @& ~* N7 J* ]9 j+ h        本工程设计功能如下：

) }0 M/ y" [  i- }1 |& P, R( q        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。
+ E7 }5 M/ ^  G. o, l3 x
7 b5 ^! J: b8 b2 D  q& [        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。
! `+ d- a( ~" O8 ~4 j' U
/ g  E2 W1 X2 t. f# R        功能：
5 s9 k& L5 p, Y8 m0 E0 O        按键功能，用于按键时向蓝牙模块发送AT指令；
& `" r2 x& l8 V% r4 `8 i( G+ I) }) v        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
4 z" u* q4 I+ ?$ v3 R        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
; s( h& p, r$ i0 R        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
        1）新建stm32工程，选择芯片STM32F103C8T6
! N4 E2 P$ m; ~


7 M! i: `  x& J         2）为工程命名完成创建



         【2】CubeMX配置
9 ?$ \0 x, d. w9 w  C* j7 B/ {/ m        1）开启sys mode接口



         2）开启RCC


$ A) j4 h) J7 ^* o
, M% n" |$ ]2 i! X         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。

) F/ `8 ~5 C6 o1 F( W8 h" v' B* f' `
- c9 A& @; [* z
' X3 A$ t2 j1 I         4）开启串口USART1、USART2中断功能
% v) u7 z2 I4 y
8 R( J( S5 ~# m, }* S- |/ n
5 l9 S/ \0 [$ i9 _
         5）串口引脚参数配置



: z# U1 @* ^* \& E3 Q; i( e         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：

% g/ H+ F6 i) E; @

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



; X8 N9 W4 t, g/ B+ E. @6 j' }          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。

2 F" D0 c7 @' @& t
: g& w! g3 {% Y* o

& L  q: J9 l9 h- ]4 u 四、代码设计
. Q; C. E. j/ ^( p; ]4 o( O        【1】首先创建usart1接口的调试输出支持
2 p6 d  e$ H% y        1）禁用syscalls.c，右键选择该文件进入属性页面设置。
, |* q) Q* \! g


         2）在工程目录下创建源码目录ICore，添加文件夹print及print.h/print.c，实现对系统printf函数的映射到usart1输出显示功能。
" X5 g- `9 i# p
  N- p; ]: D* ^7 V8 X6 ~        print.h

1. #ifndef INC_RETARGET_H_
   5 T, A1 _( Y! x% _  n* X
2. #define INC_RETARGET_H_
   7 n$ X  g- W6 w9 m- G
3. 
   * b2 Q% a& t' x+ Y1 g
4. #include "stm32f1xx_hal.h"
   ( @/ W2 H# X) Q# C) ~- b
5. #include "stdio.h"//用于printf函数串口重映射
   ) D7 n- [" l, L8 J' X4 K& }9 k
6. #include <sys/stat.h>
   & R% [" x" s' P# q8 H
7. 
   
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   
9. 
     {. w- {, u8 `- z9 A) y' L' ^
10. int _isatty(int fd);
    
11. int _write(int fd, char* ptr, int len);
    
12. int _close(int fd);
    ' U1 `8 \; Z. Z4 J. ~% d5 n
13. int _lseek(int fd, int ptr, int dir);
    , j' J! @3 E/ C/ i% R/ C, }
14. int _read(int fd, char* ptr, int len);
    
15. int _fstat(int fd, struct stat* st);
    
16. 
    3 R# W  I2 p0 Z$ I1 x# n4 @/ N
17. #endif /* INC_RETARGET_H_ */

复制代码

* d) \2 s& [% b' s        print.c
7 m0 t* H) M; @, m* c- i1 \& e: A

1. #include <_ansi.h>
   
2. #include <_syslist.h>
   6 z; F: j+ p4 [9 k6 j4 z
3. #include <errno.h>
   4 p& p# Q  |  S. K9 T0 O
4. #include <sys/time.h>
   
5. #include <sys/times.h>
   
6. #include <limits.h>
   & C( v- @9 A% @+ d/ {
7. #include <signal.h>
   
8. #include <stdint.h>
   8 F: Z9 {. C; C9 E8 ~( T) b
9. #include <stdio.h>
   ' i8 `/ `7 Y9 B
10. 
    0 W+ L* i1 V2 @5 i) M
11. #include "print.h"
    
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    ! k8 Y/ l0 f2 e; H) @" {& m
16. #define STDERR_FILENO 2
    
17. 
    
18. UART_HandleTypeDef *gHuart;
    4 s$ Q" h, D& B
19. 
    
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    2 q5 N' E: ]) z2 h
21.   gHuart = huart;
    $ _0 A+ ?8 W+ C# K! L( |! P
22.   /* Disable I/O buffering for STDOUT  stream, so that
    + K; E. I$ P  ^
23.    * chars are sent out as soon as they are  printed. */
    ; j0 C1 R2 u5 ~$ V. [$ [
24.   setvbuf(stdout, NULL, _IONBF, 0);
    
25. }
    
26. int _isatty(int fd) {
    
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    ! G0 g/ q1 O* s0 b# D  C! q+ E
29.   errno = EBADF;
    
30.   return 0;
    
31. }
    7 u2 j/ t, F9 b7 m9 V) B
32. int _write(int fd, char* ptr, int len) {
    * e% V9 [* e) ~  ^' \3 W* ]  a
33.   HAL_StatusTypeDef hstatus;
    . b- P+ h6 Q7 E* K. n
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)
    5 Y! z1 _6 P$ n; F( G% Y1 r
37.       return len;
    
38.     else
    
39.       return EIO;
    
40.   }
    
41.   errno = EBADF;
    # R8 U8 }4 K. y9 M* M8 Y
42.   return -1;
    
43. }
    . U! G% A$ M& F, [
44. int _close(int fd) {
    
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    8 W1 L9 G3 j& ^4 U
46.     return 0;
    ; Y2 m! R2 B9 D6 F
47.   errno = EBADF;
    
48.   return -1;
    
49. }
    8 d! q) h' ~4 Z* L* x  y  `
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    
52.   (void) ptr;
    " \0 r& V5 p3 h2 A
53.   (void) dir;
    ) l" m* y& J1 @( M; Q/ p) Q
54.   errno = EBADF;
    - O; V$ R* n3 T2 v2 N  e
55.   return -1;
    
56. }
    + H- f; U! e0 Z; Y. ]
57. int _read(int fd, char* ptr, int len) {
    
58.   HAL_StatusTypeDef hstatus;
    
59.   if (fd == STDIN_FILENO) {
    $ H. L8 B9 N% A( G+ @8 ]( e9 B/ j
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    4 X) n2 O+ D5 \! P" e) D
62.       return 1;
    % i. q+ p. r3 P+ J* w6 W& c$ R
63.     else
    : K) [+ z$ P2 Y/ n
64.       return EIO;
    5 V0 |8 x2 O  d! Y- W2 v; b
65.   }
    ; Y4 `# T5 V( `8 I" A9 M
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.   }
    ; h5 w( W3 _: Y0 }' I" }
74.   errno = EBADF;
    ! y' p# y5 D* m' S
75.   return 0;
    7 B6 V( s2 |$ Y7 ]# `) C' m+ y
76. }
    
77. 
    
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

        【2】创建按键驱动、LED驱动、延时函数功能的支持
         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
2 F- t( R2 {0 v1 w7 ?' A% `8 A( I        delay.h

1. #ifndef DELAY_DELAY_H_
   % r% ^7 V! V9 _) Q3 _& X4 G, P, p" o
2. #define DELAY_DELAY_H_
   * k$ p7 `3 E0 H8 ~: d/ A9 G$ V# }
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. void delay_us(uint32_t us); //C文件中的函数声明
   
6. 
   
7. #endif /* DELAY_DELAY_H_ */

复制代码

5 n8 N; c. M2 t5 v( H        delay.c
: Q# M$ @5 W; k$ e

1. #include "delay.h"
   6 Q6 e% _' N3 H5 N% [; h
2. 
   
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
   % l- h$ y+ E6 D. V) B2 B
4. {
   
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   % p6 N2 }  E) E: h
6.     while (delay--); //循环delay次，达到1微秒延时
   
7. }

复制代码

        2）在ICore添加key目录，并添加key.h/key.c源文件
1 K$ k1 T" F) b$ i, I( n
/ h- q& a, P4 F$ k        key.h
8 ~) q% d1 G# W. c

1. #ifndef KEY_KEY_H_
   + m+ y. e! g; g- e" X
2. #define KEY_KEY_H_
   2 w, b! B; W5 @9 a& l) d* e
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   ! k) Q( _# p% N2 _
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   
6. #include "../delay/delay.h"
   ) d1 G9 P: D3 K
7. 
   
8. uint8_t KEY_1(void);//按键1
   : X: \* d4 c# M$ C2 Y
9. uint8_t KEY_2(void);//按键2
   
10. 
    
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c
( F: _; `9 _% L4 [

1. #include "key.h"
   $ a( l  R# h- C! [  l- a  I
2. 
   
3. uint8_t KEY_1(void)
   + l8 K5 u( }3 v) d2 M
4. {
   & b; P8 g, D# V/ t% ?" e
5.         uint8_t a;
   
6.         a=0;//如果未进入按键处理，则返回0
   
7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
   + T- l6 L6 x: d- H# K
8. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
   $ X/ ^/ W; ~  x* ~
9.                 delay_us(20000);//延时去抖动
   
10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    / z1 C( O2 s% ]
11.                         a=1;//进入按键处理，返回1
    
12.                 }
    
13.         }
    
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    # r( D; A2 D+ ]+ w, W/ M/ y7 Y, Q
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    3 F3 |+ d/ P5 x; t
16.         return a;
    
17. }
    7 {$ O* w/ C/ c- I$ _* g: Y2 p! O
18. 
    $ ^+ J5 R/ o4 H) B" ~
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);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    3 J$ S) E- e" [. w3 ]6 ~
25.                 delay_us(20000);//延时去抖动
    6 J0 L4 u2 [; f: `3 L1 A/ X
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
27.                         a=1;//进入按键处理，返回1
    
28.                 }
    ) _% O8 B( n# g9 ~' u$ h0 Z- e
29.         }
    
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    4 r+ S# K2 f4 N0 T
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    0 H3 ^$ R7 B7 @( ?: ?$ ^/ f
32.         return a;
    7 i: y7 P4 p! E
33. }

复制代码

        3）在ICore添加led目录，并添加led.h/led.c源文件
9 Y' g# R1 u' w7 w% a+ g/ ^; l1 j$ d1 u
        key.h
- ^- b8 |2 @, S1 t! X

1. #ifndef LED_LED_H_
   + a( ]  e8 m7 J& C4 ~, B
2. #define LED_LED_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   
6. 
   ; i; r/ _3 A9 R- A8 }- t7 i
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   4 \; z- p' N. |' [8 j1 J' a6 Y! [
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   , g# s, m% q, A6 ]5 e7 W$ m
10. void LED_1_Contrary(void);//LED1状态取反
    $ o2 g; b% _& V5 q# G
11. void LED_2_Contrary(void);//LED2状态取反
    0 {% G2 i, V- `, _+ M5 H" z
12. 
    ( y1 k  j. Y4 Q6 k1 t
13. #endif /* LED_LED_H_ */

复制代码

        key.c

1. #include "led.h"
   
2. 
   0 H9 T0 P2 ~$ ?6 Y
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   : V% n/ x( F. F  M  i4 m
4. {
   / E2 k' i' l* r
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为熄灭，其他值为点亮）
   - k) k& ?! b9 U1 V4 t0 Y# Q
9. {
   * l  J& ]( `  n8 Y
10.         if(a)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    - A2 H2 K" D2 L1 H# g# m
11.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    : |, [% k8 J3 t5 C2 I7 c0 V6 H
12. }
    
13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
    ( X) Z+ n+ u3 {& u7 o- i3 L4 ]
14. {
    . G; g0 Y( y8 I3 V+ [
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    , f" C" |+ C) Q& |& z  i2 H. R
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    * p& {) t* \6 G" l$ |# }* ~
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){
    ) N8 y9 A, o8 [3 ^+ M
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    # ^8 u$ O  o' _% H2 d3 d  B, T* L
22. }
    
23. void LED_2_Contrary(void){
    / D9 P& R. W: f" n
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    ( e+ k* q# o0 k$ w. g0 @- G, j
25. }

复制代码

8 [, w+ j$ D; ^- g( ~        【3】创建串口驱动程序，主要是复写串口回调功能
        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

        usart.h
- ~) ^, ?- A8 B

1. #ifndef INC_USART_H_
   
2. #define INC_USART_H_
   
3. 
   " ~: ^) i$ Y8 p1 u; X2 n
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include <string.h>//用于字符串处理的库
   " F5 e8 c5 T$ ]
6. #include "../print/print.h"//用于printf函数串口重映射
   
7. 
   ' K6 Q9 w/ c. J
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   & j( X3 M( H% n! R: @
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   2 b3 N3 ?' X1 _& L& X% q
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个字节.末字节为换行符
    : A7 H  R+ v  d6 [
15. extern uint16_t USART1_RX_STA;//接收状态标记
    ! Z) G+ _4 p) Y2 c9 i6 V$ g: g* v
16. extern uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    
17. 
    / _# v; }4 |$ Q* t$ |
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. 
    ( ]: p% o6 H/ O, }- T6 o
22. 
    7 U# K$ ?# n% u$ `# N. K; ?6 v
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    8 m8 `! ^9 l/ I- A
24. 
    
25. #endif /* INC_USART_H_ */

复制代码

( f0 X8 ~# j0 p. i; t3 r        usart.c

1. #include "usart.h"
   
2. 
   $ |5 q- R9 S& u4 A
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   / F3 J# |) v/ r0 U- F5 q5 z
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   & i5 H: K4 F1 E- M' x
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    
11. uint16_t USART1_RX_STA=0;
    
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    ; C' ?& z$ ?. ^" d' S- y( s
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. {
    - E% H" }$ D* u! r
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    6 c+ P: N  a  p: ?) D3 d
21.     {
    
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    
23.                 if(USART1_NewData==0x0d){//回车标记
    4 B& b4 w  Q5 x
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    2 y5 I/ g3 d5 u6 ^1 p/ W4 B( J
25.                 }else{
    
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    & [& U$ a. a* B7 s6 x" ?, u2 J" [
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    
28.                                 USART1_RX_STA++;  //数据长度计数加1
    " g9 C% ?/ V% _2 \" y
29.                         }else{
    4 T5 s# U$ r- @5 y$ \* ]/ K
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    ' ~) E. N; X% X4 w$ \. U
31.                         }
    
32.         }
    
33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
    " D" C! t0 ^! n! Z' x" _' S: e
34.     }
    9 R6 Z: K" \& F; @4 @+ W7 \
35.         if(huart ==&huart2)//判断中断来源（串口2：BT模块）
    
36.         {
    
37. //                printf("%c",USART2_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    : e. n- N8 A1 t+ [' @. U0 h
38.                 if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,（手机APP“蓝牙调试器”回复数据以0x5A为结束符）
    
39.                         USART2_RX_STA|=0x8000;//标记接到回车
    ( w* ~# s- T1 B% V! `
40.                 }else{
    / F( C# k/ X. s/ F  s3 l
41.                         if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
    / O# T4 p# v, V- t
42.                                 USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组
    : q& _# s7 w7 `, k, U" W
43.                                 USART2_RX_STA++;  //数据长度计数加1
    
44.                         }else{
    : b! t, h+ T% \
45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    0 e3 ~* M% @5 e  [6 D4 K" s
46.                         }
    
47.         }
      |: ]9 w* @) E* Y0 ~
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    
49.         }
    
50. }

复制代码

6 J+ M0 A4 V/ V        【4】创建蓝牙驱动
8 p( K$ O) f/ D$ g. \, h5 V        该驱动主要实现通过usart2向蓝牙模块写入数据，（读取数据主要通过串口usart2回调，在usart.c中实现）。在ICore添加bt目录，并添加bt.h/bt.c源文件，实现蓝牙驱动功能

        bt.h
8 N! R. C3 g  I" i5 x: k. C! e6 j

1. #ifndef BT_BT_H_
   
2. #define BT_BT_H_
   - G- o8 r/ N& ^3 Q& _
3. 
   ( ~. J- o* W  O  c; N8 C2 z; A
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>
   . F  y$ Z4 }) u* @  a
10. #include <stdlib.h>
    , F/ o$ |+ V& g: j, c3 a$ g* {
11. #include "stdio.h"
    5 ]! o, |$ Q0 {2 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
# X) ^9 t  \% f4 r" E

1. #include "bt.h"
   
2. 
   5 A# o5 s/ G4 h  p5 J. c
3. //蓝牙模块唤醒函数
   ( x+ x( F! x) K8 F  i& s
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   
5. void BT_WEEKUP (void)
   6 I8 a- }, [# t' m5 x  b4 E
6. {
   / h( u8 u# @) p* s
7.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
   : a' c. Q, l7 G0 [, Z; U
8.         delay_us(100);
   / U. p5 r: r6 I) y+ M# [
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
     q" ^& c: i! X) b8 N
10. }
    # `! u2 E- Z/ T$ u2 a
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    ; }3 E' F# p, R; T
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    
13. void BT_printf (char *fmt, ...)
    1 I7 l% L" D+ R( M! p
14. {
    8 v+ V( N; a9 h
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
16.     uint16_t i=0;
    $ r8 m) ~! g: h, Z5 C5 x
17.     va_list arg_ptr;
    5 }- `  L; K6 |( @' T$ }. s9 R
18.     va_start(arg_ptr, fmt);
    + w* f4 A- Y# z' k2 ~* O% {1 b5 _
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    
20.     i=strlen(buff);//得出数据长度
    + |$ E, E  ~* J5 Z4 v: f- K+ q* j
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. }
    ! d% i. v" S) l# I
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

五、编译及测试
        【1】功能调用及编译
* i4 K* H/ W8 w( G$ D        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：

1. /* USER CODE END Header */
   * i) N2 m1 V: p; B! e$ W
2. /* Includes ------------------------------------------------------------------*/
   7 {  e5 \0 M$ q
3. #include "main.h"
   
4. 
   6 u$ s5 }  r. j- w  l
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"
    0 V* i% H% M* v' _& ]5 ~% |( A
12. /* USER CODE END Includes */
    " n  M1 s( N# n, d. ?
13. 
    
14. /* Private typedef -----------------------------------------------------------*/
    * H+ H! i& m  \3 E
15. /* USER CODE BEGIN PTD */
    
16. 
    $ C9 r& p3 P/ R9 ^- u
17. /* USER CODE END PTD */
    . \& g+ B5 \7 ?  Q" M! O% }
18. 
    7 t$ h( Q5 {1 J' Z2 P' a$ d
19. /* Private define ------------------------------------------------------------*/
    ( [- [  \' N* i6 \& j- e  i3 l
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    
22. 
    
23. /* Private macro -------------------------------------------------------------*/
    2 \: A8 \3 E" O& {( x4 ~4 ^
24. /* USER CODE BEGIN PM */
    " k, @# g6 a$ C8 {
25. 
    
26. /* USER CODE END PM */
    
27. 
    
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    
30. UART_HandleTypeDef huart2;
    3 x  O7 ?/ V# L0 m5 S
31. 
    4 v! N! g2 c: S2 p
32. /* USER CODE BEGIN PV */
    % c% o4 O5 m3 V* V  U
33. 
    5 S6 K6 Y" y2 S
34. /* USER CODE END PV */
    / o2 W' f! g$ W% e
35. 
    
36. /* Private function prototypes -----------------------------------------------*/
    & p+ {/ K% q+ E7 M  f" A6 l
37. void SystemClock_Config(void);
      J+ v* j, b! }0 }. O, w4 W
38. static void MX_GPIO_Init(void);
    
39. static void MX_USART1_UART_Init(void);
    
40. static void MX_USART2_UART_Init(void);
    ! \9 E1 G! j8 y- B4 `4 @
41. /* USER CODE BEGIN PFP */
    3 z* Y, e1 j7 D" P
42. 
    5 a. b. c7 u: B, w" ?+ o
43. /* USER CODE END PFP */
    
44. 
    
45. /* Private user code ---------------------------------------------------------*/
    ; I. O! |4 i' v9 T  D6 o3 D
46. /* USER CODE BEGIN 0 */
    
47. 
    
48. /* USER CODE END 0 */
    - v3 J1 i$ h- \3 _1 ~" {
49. 
    & m- K4 V' ^; l( n0 A( y, R5 Z- t
50. /**
    
51.   * @brief  The application entry point.
    ' c! k9 s* q( X! m
52.   * @retval int
    
53.   */
    
54. int main(void)
    # R# Z6 f- D1 F; ]3 s
55. {
    0 @  b, p: m1 l
56.   /* USER CODE BEGIN 1 */
    3 \2 J9 k! r$ f7 }6 X5 ]& n# Q$ X
57. 
    
58.   /* USER CODE END 1 */
    1 R8 [+ c& U/ @# Y$ W
59. 
    
60.   /* MCU Configuration--------------------------------------------------------*/
    + A( b- ^: @6 s2 S" s, m2 f: L
61. 
    
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
63.   HAL_Init();
    
64. 
    + T# z4 J; M9 A. ^
65.   /* USER CODE BEGIN Init */
    6 m. E: S9 v1 p% i3 ?; W# ^; g7 N/ C
66. 
    : y& A# q% a4 y
67.   /* USER CODE END Init */
    
68. 
    
69.   /* Configure the system clock */
    
70.   SystemClock_Config();
    5 a2 }- c" o. a' x9 R+ x$ v. j
71. 
    
72.   /* USER CODE BEGIN SysInit */
    ! i! ]# w& x4 `' ^
73. 
    ; `7 R; B3 r7 b, J
74.   /* USER CODE END SysInit */
    
75. 
    
76.   /* Initialize all configured peripherals */
    3 I3 t+ G' C8 {7 |  |0 V" q" T, n1 D2 G
77.   MX_GPIO_Init();
    $ @. a5 l# B  @' I- b' p' @+ G4 q6 X
78.   MX_USART1_UART_Init();
    - I/ d( h$ c4 Q# _
79.   MX_USART2_UART_Init();
    
80.   /* USER CODE BEGIN 2 */
    
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    8 B  D  E" J9 h- B" @8 W: i2 K" P
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 */
    8 \* a) Y+ }% C  q" R
85. 
    
86.   /* Infinite loop */
    0 F! `# P9 i; Z9 ?7 J- @* |/ X
87.   /* USER CODE BEGIN WHILE */
    
88.   while (1)
    $ S" @  n) ~" b* i5 h9 r0 L6 c. j# q
89.   {
    4 ~/ k* G% @# T+ W) S; C! j, D
90.           //demo 蓝牙02
    
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    
92.              BT_printf("%c",USART2_RX_STA);
    " C: v& E. ?) U; [
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    
94.              {
    / U' i, C. o9 ?/ F0 R# C% z( V8 d
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控制
     4 @4 B5 U3 l2 w: a) N) }, H
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     , r7 Z* d1 ~6 G; w9 M
104.                                         break;
     % }" y8 ?! v1 }' m
105.                                 case 0x42:
     9 U5 ?0 O) {. m# H
106.                                         LED_2(1);//LED1控制
     7 N  v" J1 M7 Q! ?. g: O, g' L1 I
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     # A1 N! Z- V. D" L( v
108.                                         break;
     
109.                                 case 0x45:
     % A) H' }# p. m9 {8 j4 D$ |: v+ a4 _
110.                                         LED_2(0);//LED1控制
     ) B  d/ \; a# x" G* i
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     ! z, b# d0 J9 ~. I& P+ Q
112.                                         break;
     
113.                                 case 0x43:
     
114.                                         LED_1(0);//LED1控制
     
115.                                         LED_2(0);//LED1控制
     & O% p4 H( B# t+ n, U% \
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     6 V! T! x( N* D
117.                                         break;
     
118.                                 case 0x46:
     $ Y3 ?3 o- B- U# s, w
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     
120.                                         HAL_Delay(1000);//延时
     ) S+ ^) `/ b  E. M- K! f( h: x
121.                                         NVIC_SystemReset();//系统软件复位函数
     
122.                                         break;
     3 k! B, s' |/ Z
123.                                 default:
     
124.                                         //冗余语句
     + k. G, M  x8 ~/ `" k  G
125.                                         break;
     
126.                           }
     6 D$ b% j6 r$ ~& s, w
127.                  }
     
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     + Z9 o3 E" f5 }/ N/ Q1 f8 `# c
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
     - u$ c' y9 y) p9 c
130.       }
     
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     1 d4 B1 G+ R6 R' S' N/ a
132.       if(USART1_RX_STA&0xC000){//结束标记
     
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     ( I5 E7 ?# |2 H; V
134.               USART1_RX_STA=0;//接收重新开始
     
135.               HAL_Delay(100);//等待
     8 L$ |% w* z6 Z6 U
136.       }
     ! y$ G2 r' Z0 z) j( x
137.           if(KEY_1())//按下KEY1判断
     
138.           {
     " d- U" n+ k! W, J
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     % z( D, K5 U9 m3 j5 }
140.                   LED_2(0);//LED2控制
     + _# j6 W. Z; l( K" ?
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     5 Y; G! C/ |( \, s8 a/ J, i. t3 P2 _
142.           }
     
143.           if(KEY_2())//按下KEY2判断
     6 O% @/ z# _% f/ n+ d- E. G: F
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     5 D' k" f+ y/ ]) K6 A
146.                   LED_2(1);//LED2控制
     * n* p# J8 ]: R! g1 D( [
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     ) P3 {5 `; D4 B
148.           }
     " w" j0 E& \, M" u! p
149.     /* USER CODE END WHILE */
     . R& o2 |& \( [3 h4 E7 s
150. 
     ( I) b! H4 n  ?# A5 W7 c
151.     /* USER CODE BEGIN 3 */
     
152.   }
     % ]. e4 o; C9 E
153.   /* USER CODE END 3 */
     ! a1 H" Y# A2 ?& u7 u7 o
154. }

复制代码

# h7 ~% ], q# d3 c5 ?; E       2）设置编译输出支持，右键工程进入项目属性设置页面：


' S' I+ j0 a# \9 J9 K2 G
          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：
  F" P6 w- |2 x3 N6 o
9 F" W$ ~7 M  V8 x: I
  D& i/ m2 b( K) _6 N
* g# Y+ E1 @* u. _/ s" {        【2】程序测试
        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
        蓝牙调试器工具，本文用的是1.9安卓版本。


, o4 e/ O4 r9 f4 k. D

3 x) c% \7 g; X+ S        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：



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


        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：
" r! s! j$ I: O% a# w' Q* p

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

复制代码

& K/ z( s8 J, l1 Z0 d9 |' V. n        串口发送数据：

$ P. X3 B. w( ^) b. {2 a" F9 Y) X
, K: G8 X+ S8 h. S+ c* C9 x

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

4 ]6 R  n& \# C5 o+ Z

         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
& \. ~7 G, W$ Q0 }8 E& @/ T————————————————
* G! Y) T$ q4 Y; o# Q版权声明：py_free-物联智能
如有侵权请联系删除
' Q3 c% T2 X2 H1 U9 f

' ?3 G# j9 S, W4 v
, A# f# g; A. U# o