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

- J. \# p  i3 _9 o9 w( ]# H- A3 C
) \3 d' o. ~) b- W6 S$ O0 r二、MCU及蓝牙模块
        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：

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


  `1 R' e" y: d0 S
5 o; _; B6 X- {2 w         蓝牙模块为JDY-08 蓝牙透传模块，基于蓝牙 4.0 协议标准，工作频段为 2.4GHZ 范围，调制 方式为 GFSK，最大发射功率为 0db，最大发射距离 80 米，采用 TICC2541 芯片设计，支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。

1 c* ~! {6 k; P  y& b( M        TICC2541 芯片 引脚：

$ J& e$ F8 m/ M6 \

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

; Q, D5 \' m2 U; I6 d$ E
5 `( f7 q8 S# @8 Q& G- L/ d( @
         以及本文用到两个AT指令：
0 \6 P* \. o+ |% t: g8 k


三、cubeMX配置MCU及蓝牙接口
        本工程设计功能如下：
& Y& Y! `! y, k8 g3 H0 }, W( B
) x3 z/ b/ \1 o  L0 [: ]        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。

% J% K1 h; x/ ]8 K( O        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。

$ G) p* Z8 g; P3 {# Z6 V        功能：
3 n: v0 z  i6 Z2 A        按键功能，用于按键时向蓝牙模块发送AT指令；
( l0 R  }- b7 n- J, Y        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
) J1 e7 O" u3 j  K        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
( L6 \. t6 t7 r* H, X        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
1 E7 U8 H* S' x$ a- k( @        1）新建stm32工程，选择芯片STM32F103C8T6
: F0 K  P8 N: l6 }$ I* M- |
9 U9 W" X9 [1 B5 x% n' W+ u
  T, i9 |& o# o, e& _, s! h; r. y
3 h/ E+ h  _' b7 Q         2）为工程命名完成创建

4 u/ o; n, O0 x% @% n1 [8 Y

         【2】CubeMX配置
        1）开启sys mode接口



         2）开启RCC

. \# ~! W" F! e5 `  b

7 p2 L9 ^  T1 c3 ]$ W6 _4 o         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。

; H6 k/ U: w! H4 j8 z/ f$ c4 z$ J

         4）开启串口USART1、USART2中断功能
. Y$ J  r1 f$ r' m& {7 c

3 M/ ~- ?+ d. g8 k
/ J9 L7 T) ?0 `% U6 E9 r         5）串口引脚参数配置
- u/ c5 k$ _# `( A
5 y) _1 @# j1 Z+ c

% [1 h, G) B0 |1 f         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：

) b$ h7 r1 z6 I1 {5 R& {. g
4 _8 E  l  f4 h1 o
  {. E. D5 y8 l9 c        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。

& I: w' z- ]& L+ y3 _
+ j$ F1 k- `2 I) l; N
7 L+ K+ M- e, \9 m% m          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。




四、代码设计
2 {. m! S* e1 H: s) r        【1】首先创建usart1接口的调试输出支持
4 I8 m1 R  _. Y        1）禁用syscalls.c，右键选择该文件进入属性页面设置。

4 |6 Z  P! t0 z- Q

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

        print.h

1. #ifndef INC_RETARGET_H_
   
2. #define INC_RETARGET_H_
   $ f8 A% q9 I. v3 C1 k$ h6 U
3. 
   
4. #include "stm32f1xx_hal.h"
   
5. #include "stdio.h"//用于printf函数串口重映射
   
6. #include <sys/stat.h>
   2 }1 A) g7 a! D& ?1 M3 @, _
7. 
   - b, u9 g0 o  R! n/ D: D* [
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   
9. 
   + U- }# `4 S! ~5 @, M
10. int _isatty(int fd);
    0 g  N5 ], ?8 [
11. int _write(int fd, char* ptr, int len);
    - F, P* F# j' t3 U0 z
12. int _close(int fd);
    
13. int _lseek(int fd, int ptr, int dir);
    ! ]% u5 h9 y7 L
14. int _read(int fd, char* ptr, int len);
    " i& p) f4 S; B" ~
15. int _fstat(int fd, struct stat* st);
    # \7 C+ G5 ~8 Y6 ^# g
16. 
    
17. #endif /* INC_RETARGET_H_ */

复制代码

, h5 o; s' n! l& x, @        print.c
/ M* h, U# R. |, u7 Y. F! s0 _6 W

1. #include <_ansi.h>
   ! k; a0 a5 K/ e7 G0 G2 {
2. #include <_syslist.h>
   # R' s" i( v1 _5 w3 X
3. #include <errno.h>
   ) S+ \) f# t" U0 t0 C+ J
4. #include <sys/time.h>
   / t. s4 ?, ]3 I; y3 B7 f) k7 K2 A
5. #include <sys/times.h>
   6 m! L( S+ Q6 k( t) r2 p
6. #include <limits.h>
   
7. #include <signal.h>
   ! _$ ]6 a  E: l: w- x
8. #include <stdint.h>
   
9. #include <stdio.h>
   
10. 
    1 [$ t4 z3 t4 [$ \
11. #include "print.h"
    
12. 
    + }( |& X# d2 O6 q# K
13. #if !defined(OS_USE_SEMIHOSTING)
    
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    
16. #define STDERR_FILENO 2
    - j+ }3 G4 e& a7 L& \
17. 
    
18. UART_HandleTypeDef *gHuart;
    
19. 
    
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    9 A* K0 }$ I  ]' o0 I4 v: X; ~
21.   gHuart = huart;
    
22.   /* Disable I/O buffering for STDOUT  stream, so that
    . `/ ?$ }& l$ z1 r9 s
23.    * chars are sent out as soon as they are  printed. */
    
24.   setvbuf(stdout, NULL, _IONBF, 0);
    ! F* ?/ L0 _( j- n  i; S  ^8 M" l
25. }
    8 n7 P5 f4 P" j; B2 S) l2 P( A
26. int _isatty(int fd) {
    ) V- x0 w" T) }* D: r0 i
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    & ~7 z( ^. i  A, r7 Q3 k' Z* w
29.   errno = EBADF;
    ( ~2 _% w. q- r; H% P9 X
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) {
    2 Z6 K& J/ B, P4 O  Y2 H9 h3 h$ G
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    4 U/ p8 F! j, B9 b4 {# U- x6 g
36.     if (hstatus == HAL_OK)
    ' N+ N# r) J  g/ G7 Y
37.       return len;
    , {" Y. x/ v6 t. ~( b& H/ K! R. L6 Z
38.     else
    
39.       return EIO;
    
40.   }
    
41.   errno = EBADF;
    $ X! B5 @8 U! R/ J/ E
42.   return -1;
    
43. }
    
44. int _close(int fd) {
    ( C; d$ x7 J. W) u
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    " G0 K3 c% y# }
46.     return 0;
    2 ~  h9 _  O% W% a2 E  Q% |
47.   errno = EBADF;
    ; d; S  y: _+ m& M) ]8 I, Q
48.   return -1;
    
49. }
    
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    ) S. j, k# G* _' g
52.   (void) ptr;
    2 {5 z. `6 j: a) n- A) l
53.   (void) dir;
    
54.   errno = EBADF;
    ; c+ k- ^: J% x9 K2 C
55.   return -1;
    : r9 ~$ w5 v5 H# Y4 B1 Y2 t  J
56. }
    ( @& y  u' |) W) q5 F
57. int _read(int fd, char* ptr, int len) {
    
58.   HAL_StatusTypeDef hstatus;
    
59.   if (fd == STDIN_FILENO) {
    9 \& h; B. G7 X( r7 B
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    
62.       return 1;
    1 X( t  P, U) j8 X
63.     else
    * w, J0 T$ M' t5 b
64.       return EIO;
    0 z2 ^5 q/ A/ q
65.   }
    & B$ b' [7 P5 r8 N& B" y2 q
66.   errno = EBADF;
    
67.   return -1;
    ) @; i# b$ o, E& _' a" I0 K, Q
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;
      e& P% d! l+ |; b
76. }
    ' \: z( ?! v% ?9 o: N& h( A
77. 
    
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

0 P! E/ V# |. j# v( T6 L, m3 u. ~        【2】创建按键驱动、LED驱动、延时函数功能的支持
         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
        delay.h
4 u" e) z8 K  O  Z6 ~6 Q% U0 m

1. #ifndef DELAY_DELAY_H_
   ; K. ?5 }7 |0 Y6 p+ B  l6 O$ U
2. #define DELAY_DELAY_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. void delay_us(uint32_t us); //C文件中的函数声明
   9 X  ]" a2 ^% u, v" a, v
6. 
   6 L( ]# O* @, ~. i
7. #endif /* DELAY_DELAY_H_ */

复制代码

        delay.c

1. #include "delay.h"
   . ]8 U/ M# X4 K! q# c, R
2. 
     }1 p0 I; C) H! e( l/ p) v
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
     `# l3 L, ?4 v! k% ]9 U
4. {
   . r* W/ ]' ]' n2 |7 |2 U  T' F
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   
6.     while (delay--); //循环delay次，达到1微秒延时
   $ }' ^/ [4 z6 B8 M! j: l
7. }

复制代码

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

        key.h

1. #ifndef KEY_KEY_H_
   6 X& v9 T. r7 P1 U
2. #define KEY_KEY_H_
   
3. 
   . b' B8 q$ {. O/ o" C
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   + v5 u/ z- v; l+ L# G- A
6. #include "../delay/delay.h"
   9 O. _4 d; F5 q2 V- n/ S5 W$ g. n1 O
7. 
     ]: \: a5 h' \9 @/ W3 t
8. uint8_t KEY_1(void);//按键1
   1 {1 Z  b, D6 X9 E
9. uint8_t KEY_2(void);//按键2
   
10. 
    # W# A2 ]7 D: }7 i0 W% l
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c

1. #include "key.h"
   5 z. E+ W% d! u- h
2. 
   7 U" l2 N1 `+ M4 V9 @' a* F+ [
3. uint8_t KEY_1(void)
   5 a. p, F& f, M# B# s
4. {
   0 G, E% r1 R8 |# [$ x
5.         uint8_t a;
   ( m% [/ u  }; W( t7 V4 \$ D
6.         a=0;//如果未进入按键处理，则返回0
   . x; L" f! G: y) @  R! R5 B
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
    * w& p$ T: E, r. X9 t8 m
12.                 }
    ( ]4 H' N, r+ f: r+ P
13.         }
    " P* E/ K! D: M* V
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    & W1 O' m/ W1 k/ G7 {, k+ z* x
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    . T; c9 z3 b4 k' r' Q8 M
16.         return a;
    ( w# m( h, `# x7 o
17. }
    
18. 
    + `! \4 Q. G% z: N
19. uint8_t KEY_2(void)
    / q1 i0 m  q7 g4 ]
20. {
    ) T3 B2 k# [3 ]6 V+ g$ X
21.         uint8_t a;
    
22.         a=0;//如果未进入按键处理，则返回0
    
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    9 V# S$ B. F! Z8 M0 {
25.                 delay_us(20000);//延时去抖动
    
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
27.                         a=1;//进入按键处理，返回1
      G) u& z. `9 Q. L. J! R1 g/ p
28.                 }
    + e6 m7 B3 n! {# ?6 {, |
29.         }
    ! p' z( w9 ^0 m
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    ; ^: `7 C3 T8 h% p- G# |9 m
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
32.         return a;
    
33. }

复制代码

+ k2 X( J" Z& Q6 B7 y: c% U+ c        3）在ICore添加led目录，并添加led.h/led.c源文件
6 {7 B. v: ^. |9 U
7 d1 r# J! e8 X+ N+ a        key.h
$ \2 y/ }4 K/ {" H

1. #ifndef LED_LED_H_
   6 c1 X8 g' ^$ s. D9 ?+ c
2. #define LED_LED_H_
   
3. 
   + R/ X' E3 G3 T2 c) |6 H
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   
6. 
   
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   ' l; L% s, L$ z/ v
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   0 I3 z$ d# h9 f, V( N$ @1 {
10. void LED_1_Contrary(void);//LED1状态取反
    
11. void LED_2_Contrary(void);//LED2状态取反
    
12. 
    : l6 {6 M7 p+ R5 j. O* j! I
13. #endif /* LED_LED_H_ */

复制代码

* f% ~7 b, s6 p: }. O0 l0 w        key.c
7 v3 I4 K8 s, o' H, N3 O  ~

1. #include "led.h"
   
2. 
   / ~" `0 D. Q, K# w
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   + E4 X; I& \3 I- p# ?' n
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);
    1 t# k( v4 m. E1 l6 f3 S, f
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）
    8 \7 f5 G$ H9 V+ b" p9 Q
14. {
    ; k( `2 U( `4 `
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    0 V2 @3 h$ G2 `# o$ A+ J
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    
17.         if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    ' ?* s* \. |( X0 Z7 y
18.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    
19. }
    , ^& |9 e3 G2 o3 R4 y# b1 p
20. void LED_1_Contrary(void){
    3 W8 k; J) q! w/ Y1 E8 j
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    
22. }
    ; ~" [3 r2 ?4 m$ g. j( @: k. K
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源文件，实现串口驱动功能

, ^: x, |+ u; v" ^/ w( _' O4 y$ A8 @1 p        usart.h

1. #ifndef INC_USART_H_
   : V9 m! j4 ^% d( X, z3 `& h0 V
2. #define INC_USART_H_
   
3. 
   / A- `+ y/ T% b6 t9 P
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   , M: j- [  i. C- D/ a" p
7. 
   
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   
10. 
    
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    - I; v2 C( \5 O+ y( S4 p' h
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    5 P5 A3 X0 Y4 Z4 y/ M; G. W
13. 
    6 u3 ?7 L2 L. O) S6 n7 e. _3 q
14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
15. extern uint16_t USART1_RX_STA;//接收状态标记
    " `' z5 e& A. H* K0 z) l
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;//接收状态标记
    " r, c9 \: q# u
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    
21. 
    & [; `7 |0 a* ]5 ]1 i$ t
22. 
    
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    & J: Y( U" X  ]) S$ l- V. O
24. 
    
25. #endif /* INC_USART_H_ */

复制代码

        usart.c
0 `( P$ M- q- n! N. g& Z' E. M" _

1. #include "usart.h"
   
2. 
   " @- R) H7 w: t) i  V, ^5 P9 W2 K; B
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   ! d3 C% t( N0 u, H7 z
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   & Z- ^! |$ E: n
7. * bit13:预留
   
8. * bit12:预留
   + S8 @; H# M5 q
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    
11. uint16_t USART1_RX_STA=0;
    2 P% b7 d" ^& M% {3 v
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    ' k' }- L! ^  a3 H2 I! y2 p: @
13. 
    + l5 g4 V5 q. R& f' W9 W
14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
    
15. uint16_t USART2_RX_STA=0;
    / Y  \2 M/ L, \* m$ y
16. uint8_t USART2_NewData;
    ; I, k: L' U" i# B( `+ O9 o3 n
17. 
    . f- P& _% u/ }# e" n2 b& P
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    5 L. O+ m) P/ H5 H2 v3 F
19. {
    
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    
21.     {
    
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    
23.                 if(USART1_NewData==0x0d){//回车标记
    % o# ~" M) V2 I' D* j/ d* N
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    
25.                 }else{
    * Z, {3 D6 J% A' o; f4 U1 I
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{
    + }7 ?( ]- f% o1 u% t2 q8 }5 E
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
31.                         }
    
32.         }
    / F# Q: u5 Y, F, {4 c7 y* \4 D, t
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{
    $ W& V  b7 `4 z
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.                         }
    6 k0 m( p) \2 k1 \/ y7 q0 u5 r3 t
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    3 L7 L2 Q5 e. }% k( W1 j
49.         }
    
50. }

复制代码

        【4】创建蓝牙驱动
7 W7 f* B2 _/ b9 v1 P% ?        该驱动主要实现通过usart2向蓝牙模块写入数据，（读取数据主要通过串口usart2回调，在usart.c中实现）。在ICore添加bt目录，并添加bt.h/bt.c源文件，实现蓝牙驱动功能

/ W0 U% [* J. s! V# J! ?' v4 }        bt.h

1. #ifndef BT_BT_H_
   
2. #define BT_BT_H_
   4 l7 M" a& {# e
3. 
   ) L& b+ x. X$ V
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>
   , c' y  d! ?& A* W8 T0 E2 ~
10. #include <stdlib.h>
    * P$ x- n4 {; d% Z  `/ C: r* c
11. #include "stdio.h"
    
12. 
    
13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
    
14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
    % R6 o# ^4 l! p+ @) ^
15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    % C- [- Z) ^' O& N
16. 
    
17. #endif /* BT_BT_H_ */

复制代码

        bt.c

1. #include "bt.h"
   . U4 f5 O. b3 T# _
2. 
   + ?* x/ R( B0 S4 g6 `# A2 U( h
3. //蓝牙模块唤醒函数
   
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   ( C' q4 N; [9 P+ a5 O. ]
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);
   * e% {. f( g) Y- q2 L  {
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
   # k) V1 _. e- }4 A. f6 a
10. }
    
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    ( L: \% F6 i0 A$ S9 M2 i/ c
13. void BT_printf (char *fmt, ...)
    & w6 x- m8 g2 y4 c' D8 E: j- G
14. {
    1 M& p! |7 C% D: W+ R1 `1 o! j# j
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    & g2 f/ G! k$ [
16.     uint16_t i=0;
    
17.     va_list arg_ptr;
    
18.     va_start(arg_ptr, fmt);
    % [- f5 u- F1 z' t9 b  ~
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);//串口发送函数（串口号，内容，数量，溢出时间）
    : `9 a) s1 D, @: I2 V& W
23.     va_end(arg_ptr);
    
24. }
    ' K8 Z) P0 I' Y" X
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

* @' F5 y- f2 G5 x8 ~% T/ |& A五、编译及测试
        【1】功能调用及编译
        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：
1 l+ ]: i: X" }8 S2 a8 X

1. /* USER CODE END Header */
   
2. /* Includes ------------------------------------------------------------------*/
   : f4 m$ Y1 n0 m/ l) T& G) j
3. #include "main.h"
   
4. 
   : [* @6 G/ l% m
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"
   5 E) B. A3 z! x$ q( u. W# \0 Y
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    7 |# R* k; y) L2 i3 u! B
11. #include "../../ICore/bt/bt.h"
    : i/ Q2 [' x: S  k7 ^) P$ T  {
12. /* USER CODE END Includes */
    + d- h. p& }9 t1 {0 N; @
13. 
    
14. /* Private typedef -----------------------------------------------------------*/
    : j$ |& M9 z+ Y  i0 n
15. /* USER CODE BEGIN PTD */
    
16. 
    
17. /* USER CODE END PTD */
    8 g& Q- [' }- \" S, U1 h
18. 
    
19. /* Private define ------------------------------------------------------------*/
    
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    
22. 
    ' _1 c$ D  y2 P2 M% E
23. /* Private macro -------------------------------------------------------------*/
    
24. /* USER CODE BEGIN PM */
    ( F* Y. C; [4 J. a9 [4 A
25. 
    7 P  x- i2 J% m3 J" h7 h( p
26. /* USER CODE END PM */
    0 C2 G, g- o: Y! R$ |# U
27. 
    $ i4 W4 C  m$ d! x' {  Y
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    ' d( A$ d* u7 C& s! @
30. UART_HandleTypeDef huart2;
    
31. 
    
32. /* USER CODE BEGIN PV */
    9 C% s) h4 v0 r5 ?9 Q
33. 
    
34. /* USER CODE END PV */
    
35. 
    - o* t4 a( r: N$ h+ l
36. /* Private function prototypes -----------------------------------------------*/
    5 g% }2 ^1 k4 \2 \4 X6 t6 {1 i
37. void SystemClock_Config(void);
    , k9 b6 l% l  k# k) V6 R) N6 k
38. static void MX_GPIO_Init(void);
    ) m. D' r1 |/ c% G( s" b+ B8 |
39. static void MX_USART1_UART_Init(void);
    
40. static void MX_USART2_UART_Init(void);
    * K4 ~5 l) N  G6 ]- M
41. /* USER CODE BEGIN PFP */
    0 P7 q5 b! C# H8 l. Q, L( k! m5 a
42. 
    
43. /* USER CODE END PFP */
    1 i( ]$ q' d* b* t' W/ v$ f, `
44. 
    3 s* I4 H  H( R! m& g# l# w
45. /* Private user code ---------------------------------------------------------*/
    
46. /* USER CODE BEGIN 0 */
    5 Q& B# X: s8 B9 ]( P* {4 C
47. 
    + m$ G/ ?( p! l7 F
48. /* USER CODE END 0 */
    
49. 
    
50. /**
    
51.   * @brief  The application entry point.
    
52.   * @retval int
    : `/ U9 [* y* w8 {: S
53.   */
    . n" ~9 Y- J6 A6 q1 R  G- C& M
54. int main(void)
    ) p; k' L" {$ S
55. {
    6 p: T- B  s' s0 d
56.   /* USER CODE BEGIN 1 */
    / e+ e+ k! M8 @  z
57. 
    + X) y) U% [% b4 U1 k
58.   /* USER CODE END 1 */
    3 x3 e8 p' Z/ }- o  O1 W8 z
59. 
    
60.   /* MCU Configuration--------------------------------------------------------*/
    : J3 b+ m+ `. n1 J
61. 
    3 ^7 p+ ]# n2 K. L; R, u
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
63.   HAL_Init();
    
64. 
    + w2 b% z; S; b: ?) W3 |) y3 g
65.   /* USER CODE BEGIN Init */
      h- M% W* D# c6 z# i* I
66. 
    , B7 P" [6 k. \0 _
67.   /* USER CODE END Init */
    
68. 
    
69.   /* Configure the system clock */
    
70.   SystemClock_Config();
    
71. 
    
72.   /* USER CODE BEGIN SysInit */
    8 D* _: \, @' G4 N8 @1 _; L
73. 
    
74.   /* USER CODE END SysInit */
    
75. 
    
76.   /* Initialize all configured peripherals */
    $ l- R# `0 l4 H8 c4 I) P
77.   MX_GPIO_Init();
    ; k; C' G: c. ?' t& G! P
78.   MX_USART1_UART_Init();
    4 |8 A* ~* V6 m
79.   MX_USART2_UART_Init();
    
80.   /* USER CODE BEGIN 2 */
    
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    7 [, e% B4 j# y1 B
82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
    
83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
    ) q( r( p' v0 R+ X$ b
84.   /* USER CODE END 2 */
    
85. 
    & S- |  K0 n+ S7 |
86.   /* Infinite loop */
    
87.   /* USER CODE BEGIN WHILE */
    + M" w# c0 ^7 B' T: d) E
88.   while (1)
    ) M9 ?; E, A$ M- X/ j
89.   {
    $ `6 [3 w6 B5 a% O5 m
90.           //demo 蓝牙02
    1 V! i2 o1 }' c7 x$ `
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    6 G0 o* G6 D3 m/ o3 F
92.              BT_printf("%c",USART2_RX_STA);
    8 P5 H$ A/ k$ R5 X0 u! x: u
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    
94.              {
    7 P/ }% ^. f7 ]
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    4 v3 V4 D0 i- O$ J" _7 q4 F1 O0 L
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    ) c. F' L6 U9 O) C
97.                                 case 0x41:
    8 C4 \) g  ]  g# {5 A' N" l: S7 H& v
98.                                         LED_1(1);//LED1控制
    / Q; W5 Y4 X1 s$ x* U; t9 \
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
    # c# ~! n1 u: O# ?$ n9 G
100.                                         break;
     6 ?5 n0 r2 S7 i6 r4 g/ _4 c# q
101.                                 case 0x44:
     
102.                                         LED_1(0);//LED1控制
     
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     
104.                                         break;
     * A0 n7 O/ `9 D" ?* @% _$ i& k6 E
105.                                 case 0x42:
     + p* P# d. a: ]2 h: S. M  M
106.                                         LED_2(1);//LED1控制
     - [4 \1 m! z: C2 [
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     ; P) @. T" q0 H
108.                                         break;
     1 o. s3 p% A. q% m% ?* L1 s
109.                                 case 0x45:
     6 o; r6 k$ ?5 @, E* y
110.                                         LED_2(0);//LED1控制
     8 F6 |. z% ]0 Q# \! t3 o
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     # ]- v1 p% u0 F$ n! \
112.                                         break;
     ' L8 Z) @5 p) D. l1 S
113.                                 case 0x43:
     
114.                                         LED_1(0);//LED1控制
     + Z0 y5 x& K$ v* V
115.                                         LED_2(0);//LED1控制
     0 q% y4 U# o7 A  d0 e4 r$ b3 h
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     & A" j8 w' w3 x7 [
117.                                         break;
     
118.                                 case 0x46:
     " F' ~. g8 p% i, N7 T3 p( x
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     # y: H- ]3 o3 B) u2 W: n
120.                                         HAL_Delay(1000);//延时
     
121.                                         NVIC_SystemReset();//系统软件复位函数
     1 O6 ^2 {2 K0 e+ g1 I
122.                                         break;
     
123.                                 default:
     " q) i) L  s; n( g8 c) s( x
124.                                         //冗余语句
     ; `8 u/ q7 C/ f7 `! N
125.                                         break;
     " E- p) k+ Y' G7 b# |$ M1 b
126.                           }
     
127.                  }
     , J) w# n$ ?( }/ ~, F: P9 _4 z8 G
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){//结束标记
     % n  F3 ~$ N" y
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     
134.               USART1_RX_STA=0;//接收重新开始
     9 G+ z' s& l8 r: A  c
135.               HAL_Delay(100);//等待
     7 _% a$ j8 `' v- X. D
136.       }
     
137.           if(KEY_1())//按下KEY1判断
     , [: F& u* c: G7 ?" o% E8 K5 z, |
138.           {
     
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     5 J9 Y3 a7 n2 {, T, l
140.                   LED_2(0);//LED2控制
     
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     
142.           }
     - `  _$ L  v; W6 V
143.           if(KEY_2())//按下KEY2判断
     
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     7 ~0 t, H6 t% t4 H/ J
146.                   LED_2(1);//LED2控制
     
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     3 |% O, Z3 p7 U: v
148.           }
     
149.     /* USER CODE END WHILE */
     
150. 
     . K% d( }) l! [  @7 B
151.     /* USER CODE BEGIN 3 */
     9 [4 f* L7 h( p8 M( p
152.   }
     - H' Y" p  \5 x7 b  @
153.   /* USER CODE END 3 */
     
154. }

复制代码

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


4 g( @2 V( b( Y2 i9 l
          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：

6 u4 {5 u* i7 p* z4 V+ U8 W0 A
0 T1 f1 v+ w, W9 E
( Y! P/ N: }2 G2 b- q, D( [        【2】程序测试
        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
5 P4 }# c! m, }* Z: ], a" H) N        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
; y) `9 w+ p3 {  Y9 ~- q, m0 n5 g        蓝牙调试器工具，本文用的是1.9安卓版本。
# ~7 A* K6 S' t3 x* O: R. z6 q* ~
: `$ R) I- ?" ?, }6 p+ z

3 `5 E& h* j$ y& R9 F
4 t" H# l* a2 G( O0 u        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：
7 X& n0 R9 R/ k

! k! D2 T. r4 I0 X$ C  C
         3）手机打开蓝牙调试器（别忘了开启手机蓝牙功能），进入界面，搜索蓝牙，点击蓝牙边上“+”按钮连接蓝牙模块，采用SSCOM串口工具连接到usart1上，就可以通过蓝牙通信实现手机（蓝牙调试器）与电脑（串口工具）的通信了，在蓝牙调试器发送数据时，十六进制时需要加上“0A”作为结尾，如果十进制发送时，注意加上换行再发送：
) ?/ ]1 k  I6 i- d
5 l) Y# `: |2 t) ]  J

        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：
+ b0 ~' s0 ^/ U2 V: y

1. if(KEY_1())//按下KEY1判断
   & M" {2 X$ q8 P6 t( O; F
2.           {
   9 M0 j2 R, j# R$ G
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   
4.                   LED_2(0);//LED2控制
   7 Z9 v- |' b7 p1 l& z" R* C
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   : ]4 U! V( S7 y4 k1 `; o
6.           }

复制代码

0 A8 s! C$ z2 j8 z        串口发送数据：


$ e9 I. ?6 s5 A# }- |8 O
! e0 }  @; C1 n3 j+ G* |
        可以进入按钮控制页面进行指令定制设置
+ |/ k0 a# B+ }- X4 P

. U+ `3 W1 L6 _% n0 M. s
         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
4 d4 u5 y/ Z( U# o3 P( ^————————————————
/ u8 R9 c; [, ]版权声明：py_free-物联智能
. E4 P; V1 @# i( A9 `如有侵权请联系删除