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

* G: U3 Z5 |* r& k- v: W, S# W
二、MCU及蓝牙模块
6 Y- j# l  L9 B( [        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：
2 F5 k6 i' Z' v
        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。

# G/ R$ X4 O' a. E+ D: C

, h# [5 W+ a: S' T  y: d         蓝牙模块为JDY-08 蓝牙透传模块，基于蓝牙 4.0 协议标准，工作频段为 2.4GHZ 范围，调制 方式为 GFSK，最大发射功率为 0db，最大发射距离 80 米，采用 TICC2541 芯片设计，支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。
- {' P. p( e1 L3 G3 I/ o! f$ |) @2 X  y
        TICC2541 芯片 引脚：


5 p3 f% b7 M: g7 P
8 B! V, Q( B) D1 S2 x4 Y6 _         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：


& Y1 t+ H' I. R+ g
; u5 B; ~) c) s2 ^+ g         以及本文用到两个AT指令：
  V; S9 P/ {* n. C* O' u( I
! j1 A: O+ E- ]
4 }/ \' Y) k) ?. |" ~
三、cubeMX配置MCU及蓝牙接口
$ D8 q; c2 ^% y2 E' E/ S        本工程设计功能如下：

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

$ ?" ?: @' {; E( G" e        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。

! D4 n) j" g+ |7 U0 n2 h1 i' S        功能：
5 N5 @- Z. H0 V& ]" L" V' V        按键功能，用于按键时向蓝牙模块发送AT指令；
) o* C' W! q3 H7 C: ?) ~9 v        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
4 Z2 H# F  E  I% K        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
: K& i/ }7 p* R7 V) A        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
3 g. |# L8 d/ w% R' a0 r        1）新建stm32工程，选择芯片STM32F103C8T6
9 _3 _2 E! y* ~/ s7 I& _3 |


4 A; |+ P" o9 s; `% m4 Y         2）为工程命名完成创建
  g9 {$ L' X1 D' l
+ I8 Y7 U* {! ^- s

         【2】CubeMX配置
        1）开启sys mode接口
9 ~2 v% c3 c: z& z& u1 x7 N


* K4 D$ r* R" F7 R" W         2）开启RCC
. G; e" A7 ]/ s; L
) ?6 \5 [6 S3 {" z+ r( S  o

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

7 ]* {( {' b8 J- W8 }3 ?4 S7 r9 d% b

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

; a  s& m3 j& c  v1 M+ v

         5）串口引脚参数配置


, f3 b2 O+ g* ]. u- R6 J. O
1 r& `) P8 x) I$ F4 ?1 u         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：
2 w- y5 x; Z7 ?; [: S: [

" }+ R4 x6 M) v% Z& K
1 |% r* `# O: e( I* g+ \1 l        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。


  S1 f% Q/ l% x
' I4 x- g7 d3 P8 i( u3 A          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。

! Z. b( T  [6 [4 A) n" h  y$ v

/ V' t4 Z4 l* ]6 f$ h( H" ^. a
四、代码设计
        【1】首先创建usart1接口的调试输出支持
        1）禁用syscalls.c，右键选择该文件进入属性页面设置。
4 W3 Y7 S& C5 ~% j; w, l


% ^  |( I3 |6 ]# x* b. W         2）在工程目录下创建源码目录ICore，添加文件夹print及print.h/print.c，实现对系统printf函数的映射到usart1输出显示功能。
+ K: H* J7 r$ R8 i4 z2 P
' @. P! b+ g2 |' `* g% a, \        print.h

1. #ifndef INC_RETARGET_H_
   
2. #define INC_RETARGET_H_
   
3. 
   ; r0 O5 ^1 ?+ \
4. #include "stm32f1xx_hal.h"
   / x* ~. f' ^4 Q  I# [
5. #include "stdio.h"//用于printf函数串口重映射
   2 ~( P9 E% @# |  M2 z
6. #include <sys/stat.h>
   0 y* o  Q) \5 [/ K+ }9 v) M1 t$ V
7. 
   
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   5 ]" I2 a- P+ |2 t6 a' D  y
9. 
   # ^3 Q- i/ z  _3 M+ j6 [' C
10. int _isatty(int fd);
    9 o/ q, Z, n3 c, |2 ?
11. int _write(int fd, char* ptr, int len);
    4 `/ z  }, k6 d9 w: [: G" N4 V
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. 
    4 W+ r2 q- \1 M' e
17. #endif /* INC_RETARGET_H_ */

复制代码

        print.c

1. #include <_ansi.h>
   
2. #include <_syslist.h>
   ) t% X/ i) g9 E
3. #include <errno.h>
   
4. #include <sys/time.h>
   + Y: j, `7 l  T7 E" I) x
5. #include <sys/times.h>
   1 b4 e7 p) |6 x; n. h! O$ G0 j
6. #include <limits.h>
   
7. #include <signal.h>
   # B+ M* [7 z+ J3 R8 a& i8 N8 u- N. C
8. #include <stdint.h>
   0 H& I) y" h) e$ a2 `4 J) G2 I
9. #include <stdio.h>
   
10. 
    $ n* F( l) i' y- O3 M) g
11. #include "print.h"
    ( S. o5 Y% I) p& |& U' Y2 X3 u
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    ; A$ a6 \! M: k! b: ]4 a0 R
16. #define STDERR_FILENO 2
    
17. 
    2 @5 v0 X4 G0 _! I' f! S( f. u% H* v
18. UART_HandleTypeDef *gHuart;
      [: [: F/ i( v( S
19. 
    
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    
21.   gHuart = huart;
    # b$ _4 m$ g" X9 ?8 L4 J6 n& |9 T* g
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. }
    # N+ K6 s& y8 ~! o8 [% _+ z
26. int _isatty(int fd) {
    2 v' h! ~0 V+ k- t6 i6 N# k$ H! ^) b
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    ' q' {! t! @4 n
28.     return 1;
    + g; @# r3 K6 T' l# n
29.   errno = EBADF;
    
30.   return 0;
      h/ c& K$ W$ n. J( v1 `$ L5 A5 |* }+ a
31. }
    
32. int _write(int fd, char* ptr, int len) {
    
33.   HAL_StatusTypeDef hstatus;
    
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    ) L( F' F2 T5 y' T. z0 Z
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    
36.     if (hstatus == HAL_OK)
    ' W+ N7 A, G6 g0 }4 S% B6 W) w
37.       return len;
    + [8 c. ?( p) n/ A( z/ J7 h
38.     else
    
39.       return EIO;
    2 E/ U0 W( t8 D9 `
40.   }
    # X) A  y/ Q# O4 u6 |7 X& z
41.   errno = EBADF;
    0 G" Z& O: ^1 h: X
42.   return -1;
    
43. }
    " W. e& c! ]7 y6 V
44. int _close(int fd) {
    " f- O+ g2 Z/ Q3 u: `. V
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    / l5 k  J8 i7 P9 c, Y3 P. w2 M" ?
46.     return 0;
    
47.   errno = EBADF;
    
48.   return -1;
    
49. }
    7 q' S$ \& c$ X- J
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    & g7 E  Q* N" v9 `4 s; O
52.   (void) ptr;
    
53.   (void) dir;
    
54.   errno = EBADF;
    ' ^/ f! a% v& e. @1 D4 ?
55.   return -1;
    
56. }
    
57. int _read(int fd, char* ptr, int len) {
    
58.   HAL_StatusTypeDef hstatus;
    
59.   if (fd == STDIN_FILENO) {
    5 z8 V2 n4 E! l; k& ?; O
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    1 n( W+ I+ \2 Q% b1 r, M/ f5 |
62.       return 1;
    ; [, }' `6 m4 l
63.     else
    . f- G% K9 q( h8 H( z; g1 N
64.       return EIO;
    7 ~' b2 u3 m1 O2 j: T$ k/ U; ?6 t0 Q4 l
65.   }
    4 Y- c# d1 r6 Z4 B, G8 d
66.   errno = EBADF;
    1 b3 d0 l/ z: Y  s/ w4 v( @" _
67.   return -1;
    
68. }
    
69. int _fstat(int fd, struct stat* st) {
    
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    ! k$ J! D# i) D5 f, @
71.     st->st_mode = S_IFCHR;
    
72.     return 0;
    ! n- Y! P5 L  d. O
73.   }
    : @1 ~. m2 D7 U* C, B& L
74.   errno = EBADF;
    
75.   return 0;
    
76. }
    / J; m6 ^3 A- x' g0 j; E! Z+ g  k
77. 
    7 v; F  ~( l1 M) V" }6 X
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

        【2】创建按键驱动、LED驱动、延时函数功能的支持
         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
        delay.h

1. #ifndef DELAY_DELAY_H_
   : R. A  O) F9 F  O6 \
2. #define DELAY_DELAY_H_
   
3. 
   0 A, M. z0 z) Y2 [6 }. t
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   ! B% \0 ^5 W- \/ V0 e
5. void delay_us(uint32_t us); //C文件中的函数声明
   
6. 
   ; @; c. M3 D0 V: t
7. #endif /* DELAY_DELAY_H_ */

复制代码

! Q' m8 Q5 r# N# U2 y        delay.c
% w) X% B' R. p0 d5 E

1. #include "delay.h"
   & C% u6 J( K$ o3 J7 }# u3 \0 v$ e. @
2. 
   
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
   8 N: C, |2 s- j; }& P! d2 q
4. {
   
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   - A8 n) i2 Q( W
6.     while (delay--); //循环delay次，达到1微秒延时
   / [8 F. \7 R1 k4 Y  y
7. }

复制代码

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

1 o( _& T0 l# ~& N9 k        key.h

1. #ifndef KEY_KEY_H_
   
2. #define KEY_KEY_H_
   
3. 
   ! n: X- |6 z  _2 ]3 s
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   1 ~& p  H% }$ y! T
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   
6. #include "../delay/delay.h"
   
7. 
   0 K3 n2 A$ y! P8 v# w3 A, j/ k
8. uint8_t KEY_1(void);//按键1
   , E8 T3 j9 P( Q8 ?+ W7 M
9. uint8_t KEY_2(void);//按键2
   
10. 
    
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c
5 H. [2 L/ d3 Y1 }+ A- T

1. #include "key.h"
   / {: m$ ~4 R- [" J
2. 
   4 y' @" ^5 N8 X% P+ h" W
3. uint8_t KEY_1(void)
   9 O6 ]. \; i7 P0 U
4. {
   $ v! T2 P& K6 X) v" ~3 n1 ^
5.         uint8_t a;
   
6.         a=0;//如果未进入按键处理，则返回0
   * o- ]1 v2 ?* B# T" y  [! O
7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
   
8. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
   6 C/ H, M7 G$ `: W
9.                 delay_us(20000);//延时去抖动
   + b! w6 X- c4 |
10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
11.                         a=1;//进入按键处理，返回1
    
12.                 }
    4 r& u. s! A2 _
13.         }
    
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    1 m7 _$ b, ^/ h( b3 u
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    . r" n. H4 l  u; i. ]& S6 ]
16.         return a;
    9 j. E, I* j2 o5 N
17. }
    3 Y5 D! X$ z8 V- B: |
18. 
    0 b7 p- e! d! L2 q
19. uint8_t KEY_2(void)
    ( \* m4 ?9 }6 q4 g6 t! w
20. {
    ) d+ T4 j4 e- I" @; h; [- f
21.         uint8_t a;
    
22.         a=0;//如果未进入按键处理，则返回0
      F1 o8 p: W0 I6 U: H& C
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
      t% T9 ], c* q, |
25.                 delay_us(20000);//延时去抖动
    3 }$ H+ p% U( H2 w
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
27.                         a=1;//进入按键处理，返回1
    ) @5 i4 j' Q! h, w6 F" a+ n0 A; |
28.                 }
    1 A0 C% `8 d( o
29.         }
    
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    6 [7 p# c+ ?5 K) {) Z5 k) b$ X
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
32.         return a;
    ! f2 L# x+ e$ @, e
33. }

复制代码

. b- H. Q, W0 u2 V) n$ w        3）在ICore添加led目录，并添加led.h/led.c源文件

        key.h
1 j% Z, B' ?1 @# r( o

1. #ifndef LED_LED_H_
   
2. #define LED_LED_H_
   
3. 
   . y! {8 |# \) `: c* p7 l1 l) u* p6 q
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   " ]) c  m9 e0 ^* `: S% @7 I- V8 ?
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）
   " Z4 y6 e& d0 i- b* j
10. void LED_1_Contrary(void);//LED1状态取反
    ; e) ?  w5 R" Q  ]: h, l* P
11. void LED_2_Contrary(void);//LED2状态取反
    6 n3 C' s. P+ W* D$ r+ D7 t9 {. m' K
12. 
    
13. #endif /* LED_LED_H_ */

复制代码

; i% W9 M9 _# _        key.c

1. #include "led.h"
   * _1 S+ U7 X6 j" u4 k7 C, n) y
2. 
   + m2 v) F2 f1 R0 A
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   7 }( u: z+ h# R# k
4. {
   
5.         if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
   
6.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
   $ v+ G3 J: \0 _: Y. O/ T8 \
7. }
   $ y3 K2 w% ^, ^. C5 s' Z* X' c
8. void LED_2(uint8_t a)//LED2独立控制函数（0为熄灭，其他值为点亮）
   ) }; e8 S2 u) p# z( o5 P
9. {
   
10.         if(a)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    
11.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
      i( @! M" r" n8 F/ k; @4 ]: R
12. }
    
13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
    5 M" d  z; f0 j9 k" u
14. {
    
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    7 X8 w5 I. r9 {8 m4 \0 K
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    # E9 N! {  t* {$ S
17.         if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    
18.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    : ?! P* N0 F1 t- r. @# ~0 D
19. }
    7 s2 L+ g9 C' W; [7 i" R
20. void LED_1_Contrary(void){
    6 t+ F% Y3 V6 M+ e1 t; B
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    ! j& _- U: H3 Q% x
22. }
    
23. void LED_2_Contrary(void){
    
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    
25. }

复制代码

        【3】创建串口驱动程序，主要是复写串口回调功能
( y' N/ O+ C5 Z2 P        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

( b/ |! {# i5 r1 r9 z        usart.h

1. #ifndef INC_USART_H_
   ; q3 o- i4 B9 k$ n- c
2. #define INC_USART_H_
   6 p  r% S" v* {/ k7 `
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   & x4 o& `+ z6 O: P
5. #include <string.h>//用于字符串处理的库
   * h8 I3 ~+ y+ h6 g$ y# ~
6. #include "../print/print.h"//用于printf函数串口重映射
   
7. 
   
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   5 p3 Z0 s6 q1 B, w: k) G
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   ) ?8 T: ~" [/ A/ `1 L2 ^0 M, v
10. 
    8 t! _3 {7 r  v7 z6 s8 X9 d
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    3 Z  Z( i; M8 r+ {( p+ I# d  t6 c
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    
13. 
    3 [2 n, h) V/ T" @! v; B5 ]
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. 
    # S- g/ d6 \4 M) q/ p, q7 O
18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
19. extern uint16_t USART2_RX_STA;//接收状态标记
    5 z& i) e6 \* ?, T
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    3 P7 c. C4 B2 ^+ ~4 C1 ^
21. 
    
22. 
    
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    
24. 
    8 [" o5 N& `  `& N6 e5 K6 e# `+ c
25. #endif /* INC_USART_H_ */

复制代码

        usart.c
1 b& s) H3 d0 H& X

1. #include "usart.h"
   & C; \  n# r( L) _
2. 
   . u: d' J" j& }% q5 J8 u
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;
   , [# s( P: f  Z, F- A! H3 m! Z( ?
7. * bit13:预留
   1 Q( w# T! Y2 R
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    & E! M  a) N7 `- v9 r3 r0 V: e. l' k
11. uint16_t USART1_RX_STA=0;
    
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    5 t) d, j% H. B5 C) v! K9 G
13. 
    
14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
    
15. uint16_t USART2_RX_STA=0;
    
16. uint8_t USART2_NewData;
    ; _) f1 j& |+ c. ?2 P. F
17. 
    ; A; ~+ v( \; p) ?* I7 l
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    
19. {
    
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    
21.     {
    % M1 v, t' o! t% j7 a" F
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    9 X' G7 B* q& j2 q3 I( F* ^
23.                 if(USART1_NewData==0x0d){//回车标记
    , V$ }( x9 w+ f( P) {
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    & `6 R8 F2 Q9 G/ x2 c
25.                 }else{
    
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    0 ~5 R  ]7 o2 W2 i" Z
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    
28.                                 USART1_RX_STA++;  //数据长度计数加1
    
29.                         }else{
    
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    0 s: S2 G8 U, J* Q7 l; H2 E
31.                         }
    8 S5 C  U( p5 |* l  u; G) Z
32.         }
    
33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
    " J$ P/ y. @! X  U. A
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{
    0 d9 j) A( y) T& h% O
41.                         if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
    4 Z, `4 s% k' P5 }
42.                                 USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组
    + R0 t3 I$ c5 t" B
43.                                 USART2_RX_STA++;  //数据长度计数加1
    * F: n* g5 {8 Y) n6 f6 X6 X6 F
44.                         }else{
    
45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    . Z% {$ v  Q# l+ R7 G
46.                         }
    $ ~  z6 A1 I# X0 Y" o# |0 a/ T$ [
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    
49.         }
    ) K! O4 v9 p' y( q& h' z
50. }

复制代码

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

        bt.h
2 p/ x+ c9 e. c

1. #ifndef BT_BT_H_
   1 \8 f- w( S9 Y6 |6 ~  m6 n
2. #define BT_BT_H_
   ' o, h3 K, K+ I7 C( X: O# e9 [, Y
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h"
   
6. #include "../usart/usart.h"
   
7. #include "../delay/delay.h"
   ' M" y1 T; l2 Y$ T
8. #include <string.h>//用于字符串处理的库
   
9. #include <stdarg.h>
   
10. #include <stdlib.h>
    ' b2 _8 F6 I* {* S8 R/ F( n1 s1 Y
11. #include "stdio.h"
    ' o% b1 [- J' R2 R, n$ }4 U
12. 
    7 d) }6 ?! |# i5 E; O7 W
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"
   7 l4 C3 m) r9 @) w* d0 s( J* B
2. 
   
3. //蓝牙模块唤醒函数
   0 L* H2 t  i* L9 a8 t, {
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   $ |+ G! _5 b' `3 O: O: w8 I
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);
   + t# n7 W1 [  x6 P
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
   3 a1 B' J+ D0 `) \
10. }
    - r9 [, r6 F/ F
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    % `7 ~8 Q" A& F5 M$ T
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    0 R. x! ]; W* {& D6 c2 A
13. void BT_printf (char *fmt, ...)
    
14. {
    
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
16.     uint16_t i=0;
    ' z+ L2 U; |2 O! I, B
17.     va_list arg_ptr;
    4 {5 C8 ]: k) G; m' ]
18.     va_start(arg_ptr, fmt);
    2 G8 Q% @$ g  U- q- i# H! J
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    " ?! G2 x6 U% g" r" U& l) |7 }8 N
20.     i=strlen(buff);//得出数据长度
    ) D: d9 f! ?' N+ u3 a/ k
21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    * X" ?$ j2 M: r
22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    
23.     va_end(arg_ptr);
    
24. }
    
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

五、编译及测试
        【1】功能调用及编译
& N- |) B6 V' B& |+ o. \& _        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：
( r  m7 S$ h* p* A

1. /* USER CODE END Header */
   ) }$ F2 c# U5 O' y$ ]; q
2. /* Includes ------------------------------------------------------------------*/
   ! S3 |# H2 b0 j6 B, r# e
3. #include "main.h"
   ; Y, ^6 L2 X! E$ ]5 o) I. @5 n
4. 
   
5. /* Private includes ----------------------------------------------------------*/
   
6. /* USER CODE BEGIN Includes */
   + O4 D2 b, h2 j2 R0 W9 ~, W
7. #include "../../ICore/led/led.h"
   
8. #include "../../ICore/key/key.h"
   : _6 e, B3 v* `1 I4 T6 n
9. #include "../../ICore/delay/delay.h"
   & y$ |- h) F- w0 M/ z- `
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    5 c5 X2 _: b" l$ w$ G
11. #include "../../ICore/bt/bt.h"
    / M0 [/ B  H2 P$ R
12. /* USER CODE END Includes */
    9 O& G- T6 c- b
13. 
    3 I! |& V$ v6 H( u9 o
14. /* Private typedef -----------------------------------------------------------*/
    ! u1 [5 |# P% P. u1 u. ]
15. /* USER CODE BEGIN PTD */
    ( A, a5 W9 f- q6 g) S  }
16. 
    2 ?1 e; J( c5 V& U% m
17. /* USER CODE END PTD */
    
18. 
    & z  `% [* ~- [( @  }( a; \% o/ k3 N
19. /* Private define ------------------------------------------------------------*/
    2 |' ~4 H& O4 w/ a( L+ S
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    ' g. B% C, Q! _
22. 
    
23. /* Private macro -------------------------------------------------------------*/
    3 a$ [0 c3 o6 u% f3 q( `
24. /* USER CODE BEGIN PM */
    
25. 
    
26. /* USER CODE END PM */
    - h+ G- U+ ~& G1 J* R$ W, X
27. 
    
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    5 P& I2 f, N* \8 a
30. UART_HandleTypeDef huart2;
    
31. 
    
32. /* USER CODE BEGIN PV */
    
33. 
    4 ~+ X/ l, ~) o; I
34. /* USER CODE END PV */
    
35. 
    
36. /* Private function prototypes -----------------------------------------------*/
    7 T1 o2 t  [& w7 q+ E
37. void SystemClock_Config(void);
    
38. static void MX_GPIO_Init(void);
    " l) y) S9 Q  M' U
39. static void MX_USART1_UART_Init(void);
    
40. static void MX_USART2_UART_Init(void);
    . L, o1 y2 `% o- n- a
41. /* USER CODE BEGIN PFP */
    
42. 
    - {) T$ X: g( M# I4 H: t
43. /* USER CODE END PFP */
    
44. 
    
45. /* Private user code ---------------------------------------------------------*/
    5 `7 \8 w! v3 D7 b$ P2 [8 y
46. /* USER CODE BEGIN 0 */
    $ ?% N) o9 J( w) a1 x2 c
47. 
    
48. /* USER CODE END 0 */
    
49. 
    
50. /**
    
51.   * @brief  The application entry point.
    
52.   * @retval int
    
53.   */
    ; u. z. X$ E: B+ D/ h6 x
54. int main(void)
    % N  }: E+ _8 d/ I% G  J3 w' z* j' Y
55. {
    - b; W: v3 v( q
56.   /* USER CODE BEGIN 1 */
    9 i- W" k5 C3 \1 O: j( p9 j" g
57. 
    
58.   /* USER CODE END 1 */
    0 P; k5 o. d( w' f1 p2 {/ C
59. 
    ! M5 G% f7 _3 w+ k7 F/ ]2 [& h% m
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. 
    ) y: v4 h( ^0 R0 f' k% b6 S
69.   /* Configure the system clock */
    . j$ m' o0 M3 h' D3 r, h
70.   SystemClock_Config();
    
71. 
    
72.   /* USER CODE BEGIN SysInit */
    
73. 
    
74.   /* USER CODE END SysInit */
    
75. 
    
76.   /* Initialize all configured peripherals */
    * P0 c  T9 O& P3 J. v4 v
77.   MX_GPIO_Init();
    
78.   MX_USART1_UART_Init();
    ; D0 E$ R- Q; ^9 ?5 r7 F
79.   MX_USART2_UART_Init();
    ' {% p0 ]4 Z% `5 W' |5 p, k
80.   /* USER CODE BEGIN 2 */
    & U- F, A8 q5 i8 J
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    9 _( n: J6 B  g- _- E
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 */
    1 p* G* W1 ?4 v
85. 
    5 i) a+ C; i# H9 E) N8 H: ?% }
86.   /* Infinite loop */
    % Z3 B8 r7 [$ ?: ^
87.   /* USER CODE BEGIN WHILE */
    - e' l% t0 Q! ?( W/ t
88.   while (1)
    # }* Y) g% v, i+ ?9 t- d7 V
89.   {
    0 c( n9 z1 @' ?) }" I) P) ^
90.           //demo 蓝牙02
    * d  D9 z8 u& ]8 H1 r3 _# u! q
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    & A8 z; \$ `' v7 `+ m
92.              BT_printf("%c",USART2_RX_STA);
    ) Z( [( U- k; e/ x1 U) Z
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    
94.              {
    
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    0 a8 P2 z. U5 j. X8 N
97.                                 case 0x41:
    * M" h! n) Y6 Y. @3 L: p. j
98.                                         LED_1(1);//LED1控制
    2 q( c; ?; L/ i% I' w7 S# }' W
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
    
100.                                         break;
     
101.                                 case 0x44:
     
102.                                         LED_1(0);//LED1控制
     ( O4 d# f+ K% m( M( j8 w% x9 n8 L6 E
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     
104.                                         break;
     , L4 \7 G- s1 `5 w
105.                                 case 0x42:
     
106.                                         LED_2(1);//LED1控制
     
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     ( U+ D* ~* l) @1 |
108.                                         break;
     
109.                                 case 0x45:
     
110.                                         LED_2(0);//LED1控制
     
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     & X3 T  r4 g9 z4 T9 n8 [
112.                                         break;
     2 k$ b0 ~; L3 l* u7 O
113.                                 case 0x43:
     , p3 I) d% A( K' i( |
114.                                         LED_1(0);//LED1控制
     - F7 M6 H, n$ V
115.                                         LED_2(0);//LED1控制
     6 A3 ?. o7 b4 F2 u% v) D
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     + K& d$ W( u# u, z  ~$ s  l8 b
117.                                         break;
     ( L3 n& r4 {3 B4 v) y7 g  P' O% D
118.                                 case 0x46:
     2 z* v+ G/ R  W- k& J4 V
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     
120.                                         HAL_Delay(1000);//延时
     
121.                                         NVIC_SystemReset();//系统软件复位函数
     
122.                                         break;
     
123.                                 default:
     
124.                                         //冗余语句
     ' s) h/ S# [$ x1 i: _" Q: O5 `
125.                                         break;
     : V! b- K9 \3 N; w$ ~
126.                           }
     
127.                  }
     ) i. j( r/ Z1 }0 T
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     9 j  @+ j" A9 Q2 R0 ?4 E+ [
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
     
130.       }
     
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     : Q/ {) q/ Q) t/ w/ f4 \8 s7 s
132.       if(USART1_RX_STA&0xC000){//结束标记
     $ L$ n4 B( k; p' o4 e- i& d9 N
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     
134.               USART1_RX_STA=0;//接收重新开始
     $ z/ o. y1 f" P$ Q8 m- F9 D4 k
135.               HAL_Delay(100);//等待
     
136.       }
     
137.           if(KEY_1())//按下KEY1判断
     
138.           {
     . q9 _; I, u1 k: P" e5 o! z0 y9 P
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
140.                   LED_2(0);//LED2控制
     * Y! |/ E) [6 L% a$ m/ t! N
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     
142.           }
     0 U9 D, F' Z; [4 j7 K0 B
143.           if(KEY_2())//按下KEY2判断
     3 r$ ?9 i0 m* L, \0 [" `7 V5 K
144.           {
     8 U. ^/ `! k6 e3 T" o+ x: Q
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     2 [6 h0 u0 P& l1 ~. W% y& o
146.                   LED_2(1);//LED2控制
     ! V$ S8 A) a, _. K% C# R
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     1 x7 p& N$ R! }$ D8 y
148.           }
     * ]" u/ L& K& t' i0 l5 P0 H* c& h
149.     /* USER CODE END WHILE */
     
150. 
     & S' @; G" P1 J  R: R2 u
151.     /* USER CODE BEGIN 3 */
     
152.   }
     
153.   /* USER CODE END 3 */
     % x# ~" Y. E& t* q1 B
154. }

复制代码

       2）设置编译输出支持，右键工程进入项目属性设置页面：
* {! @- R7 H* A. G" Z


          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：
1 r( v* p: A7 D+ a

# z) O9 k- h8 @' Y& @8 N) g. @
        【2】程序测试
6 S  s$ `' j( X7 l        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
  W3 x% ~! w, A: r& m& n6 S        蓝牙调试器工具，本文用的是1.9安卓版本。
) I% |; I" J0 U9 _5 O' e0 h$ C

0 p- x) T8 u$ {: L1 i' ?

        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：
$ `4 f2 x& M2 a) k* i# v& Y
8 k8 U6 \% ~+ q, @  }

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

3 U2 s* i; D# T9 i( m, h
8 O6 e$ |; W; m; k; k
        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：
. ?* j) Y; d, A# `

1. if(KEY_1())//按下KEY1判断
   
2.           {
   
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   + T  |  I5 n. Q( w  S2 x
4.                   LED_2(0);//LED2控制
   
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   0 m5 y* E6 ^6 w9 _4 P2 O
6.           }

复制代码

  I/ `+ k  u. X: F4 Y" N        串口发送数据：
% _# |! n7 C- b, x7 m


' t5 {- p/ V& X7 y/ [2 E
8 _8 R- @2 _. j$ _* I        可以进入按钮控制页面进行指令定制设置
1 j* v' S4 R6 k

; Z2 _5 [& L2 q
/ P, e7 C8 a! K# K% Y$ G         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
) N3 n# Y! I1 l7 o) @————————————————
版权声明：py_free-物联智能
如有侵权请联系删除
  _4 y) ?( b4 N# w3 e. f% A

6 _, O; ~3 K  }8 o' O' z/ o& L
: r9 n7 ?( N" K9 e' S6 F/ T, i1 ]