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

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

+ A4 ^) _2 c4 p  S3 w
( Q2 `& {$ O1 {; [5 U/ O9 V二、MCU及蓝牙模块
        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：
& F: B4 `0 E6 }% t& ~
) J+ ?  W* ~- Y* `5 t  A        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。
% L4 W+ l- v, Y
0 ~6 u. `# t0 n% b! l; r; h2 H& i2 ?

5 o: T! D8 C6 P0 |* m4 r; T2 B         蓝牙模块为JDY-08 蓝牙透传模块，基于蓝牙 4.0 协议标准，工作频段为 2.4GHZ 范围，调制 方式为 GFSK，最大发射功率为 0db，最大发射距离 80 米，采用 TICC2541 芯片设计，支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。
3 G4 D7 ^- j' i  u. ]4 C) n
- }! ~3 H4 S/ \1 Z2 }        TICC2541 芯片 引脚：
% h) {; ^4 \2 W7 w+ J

) l1 R9 ^; I6 \$ R$ H
; U% g- ^$ u! ^/ A. m: I         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：


& H& O+ K% p4 u2 {6 n2 n8 W
         以及本文用到两个AT指令：


) a; k, P: h2 T% `( l
三、cubeMX配置MCU及蓝牙接口
" K6 X: I1 H9 n        本工程设计功能如下：

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

2 Y- p+ T# E3 V4 J8 `        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。
' A/ s) Z: {2 W) c5 T" X' G' u
% z8 g/ t0 \  l& l. U        功能：
        按键功能，用于按键时向蓝牙模块发送AT指令；
        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
0 U- f% q* S3 q        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
* j; v( V5 \: l& H        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
6 W; u& Z$ a$ `6 U        1）新建stm32工程，选择芯片STM32F103C8T6

4 a1 j+ G5 y6 q4 w7 s8 }8 x* _- Y  C. N
) l, t; }( L" P5 F3 K/ E$ J7 t
         2）为工程命名完成创建
5 n/ v! H$ ?  A
! Q( z* S0 H" e! d
6 g. f8 V5 f$ x8 e/ ]
' R7 p; c6 g4 J         【2】CubeMX配置
$ x; x9 ]" ^7 e1 x        1）开启sys mode接口
$ T  x; O9 o/ N- q7 l


         2）开启RCC
- e3 M. {4 W+ M8 v/ S8 _- _
' f/ E8 x+ W( N9 l0 {- |

         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。
9 C6 r9 ?" r# u3 V  e

! f9 X8 p: f7 q% z; r* ^7 A2 V
         4）开启串口USART1、USART2中断功能
" f0 H, f- {2 O$ m' {" `- N

: p2 s, G& y2 O. v* M2 m) m9 n
. S/ y9 P. n$ c9 O* q, l8 M         5）串口引脚参数配置

/ I. f- h9 \: ?% ]6 R1 _: k
- V7 s" r9 ]8 u" a9 h0 o
         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：

* R, O* Q$ h# q. ?5 L1 V) t

9 H* o, ^3 Y2 T" ~% Y        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。
! F* ]" A' k5 n9 R9 _0 D0 ^
  p& A% \/ C4 @) j2 m
) W. z( x0 g4 w; u
          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。
  Y. E! q/ W7 V, f! d) y
, u' `0 p9 S  ?

# }  ?8 f% `- }4 K: v
3 _" X8 T2 {" ~8 p! F, }# V 四、代码设计
! R7 q0 j$ R6 B7 A+ @4 x3 w+ E3 {        【1】首先创建usart1接口的调试输出支持
; |7 s6 J' V4 Q        1）禁用syscalls.c，右键选择该文件进入属性页面设置。
+ K9 L0 x+ \) `( B- L, g
+ L& z' F8 V' s, T
3 T; B* k" J' e' @2 s0 k
         2）在工程目录下创建源码目录ICore，添加文件夹print及print.h/print.c，实现对系统printf函数的映射到usart1输出显示功能。
; ?9 b( N8 y, c! O& i5 \9 s7 Z
: H7 h6 R3 e) i6 A4 \" [1 E& N        print.h
8 @1 y7 ?- {6 K8 {! ^% B

1. #ifndef INC_RETARGET_H_
   
2. #define INC_RETARGET_H_
   
3. 
   % {( w: i1 h9 A6 r- q7 V# o% e' x
4. #include "stm32f1xx_hal.h"
   1 N0 [7 y' }2 R7 y6 m
5. #include "stdio.h"//用于printf函数串口重映射
   
6. #include <sys/stat.h>
   
7. 
   
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   
9. 
   . q6 A: }* ^, m/ l- u: \1 j
10. int _isatty(int fd);
    
11. int _write(int fd, char* ptr, int len);
    
12. int _close(int fd);
    4 F6 R+ t) Y  M6 N* l
13. int _lseek(int fd, int ptr, int dir);
    3 L0 Y# J+ _$ {
14. int _read(int fd, char* ptr, int len);
    ' U& E" o" M, Q* [/ \, J, N
15. int _fstat(int fd, struct stat* st);
    / g. a" y9 ?6 Z! H
16. 
    
17. #endif /* INC_RETARGET_H_ */

复制代码

        print.c
, {, V( u! r. T; h* v

1. #include <_ansi.h>
   . V9 q- [; H) b4 A, e. [
2. #include <_syslist.h>
   + Y1 Q$ k; [" |
3. #include <errno.h>
   
4. #include <sys/time.h>
   4 ]- ?* H9 _4 T0 V: [4 q" d
5. #include <sys/times.h>
   1 _1 W6 `/ {4 ]
6. #include <limits.h>
   0 k% Y% a! ?8 {% [! \* r
7. #include <signal.h>
   9 b' y) p9 j: A1 S/ x# \+ p
8. #include <stdint.h>
   ' @7 A# k) s% f3 ?# l
9. #include <stdio.h>
   
10. 
    
11. #include "print.h"
    4 L+ P6 ?5 M2 [7 o# h
12. 
    / N! N* R2 ~8 _+ R# A: a
13. #if !defined(OS_USE_SEMIHOSTING)
    - Z) s* g0 e, n
14. #define STDIN_FILENO  0
    ( L0 ~" q! x4 k' V
15. #define STDOUT_FILENO 1
    
16. #define STDERR_FILENO 2
    
17. 
    
18. UART_HandleTypeDef *gHuart;
    
19. 
    0 g* {( E+ B2 z3 @$ j( x6 j, g
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    
21.   gHuart = huart;
    " n  m  I6 p" r% ^8 v0 t1 k
22.   /* Disable I/O buffering for STDOUT  stream, so that
    . ~2 d# q9 f6 L" Y0 x3 J
23.    * chars are sent out as soon as they are  printed. */
    + N7 R" I9 @$ m6 W$ h' p2 o
24.   setvbuf(stdout, NULL, _IONBF, 0);
    
25. }
    ! x( ~7 S& z6 Y/ [$ Z0 d& R
26. int _isatty(int fd) {
    
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    
29.   errno = EBADF;
    : R+ h6 U( J& ]* \8 t" J
30.   return 0;
      g9 j; u% Y. P5 F2 g
31. }
    
32. int _write(int fd, char* ptr, int len) {
    ) ^1 u+ p5 i5 c! `
33.   HAL_StatusTypeDef hstatus;
    4 j. D3 @2 r, _3 A+ G6 q
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    * Y0 G& t. c0 t
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    1 Q$ f  d/ q2 W. f) a5 G
36.     if (hstatus == HAL_OK)
    . l/ I% j9 n3 H% V. {" W
37.       return len;
    . Z& Z( K( _% n, P% @/ a  S" {
38.     else
    / C# f5 a* q/ _- ?. Q
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;
    , y  [) j7 U9 o
47.   errno = EBADF;
    
48.   return -1;
    
49. }
    ; [: _7 Q% i1 V7 S7 E, h( F
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    / W) R- p# {; C# v% H
52.   (void) ptr;
    & F) D1 D. G% x, d
53.   (void) dir;
    
54.   errno = EBADF;
    3 b3 c  {7 j+ ?' x/ C
55.   return -1;
    " r: p  M7 d$ B( \% b! K
56. }
    
57. int _read(int fd, char* ptr, int len) {
    ) c8 l7 L- F* q; V4 c
58.   HAL_StatusTypeDef hstatus;
    ! Q. ?1 L2 ]0 q# A3 m) U$ p: g3 D
59.   if (fd == STDIN_FILENO) {
    : K2 j4 p% Q* e* P+ F8 I* J
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    : w2 E9 C. W4 y; G# t3 b
61.     if (hstatus == HAL_OK)
    
62.       return 1;
    
63.     else
    
64.       return EIO;
    # y, l1 X8 E, W9 d' v! b7 _  n6 m
65.   }
    ( @( n9 R6 f3 n, j3 ?5 P: F
66.   errno = EBADF;
    $ ]/ f5 m7 [! u( n, g$ h
67.   return -1;
    9 k/ F& A* K' i& g9 P  b. q( |+ r
68. }
    1 s# l+ G1 S9 k) Y5 W3 O
69. int _fstat(int fd, struct stat* st) {
    : T$ L* q, H' q! y0 t) _& K9 L5 q* x& N
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    
71.     st->st_mode = S_IFCHR;
    
72.     return 0;
      e$ X1 o/ Y6 ^! N8 f( K: H
73.   }
    
74.   errno = EBADF;
    
75.   return 0;
    3 i* Y: E/ x' x! \2 ?
76. }
    
77. 
    " A3 o) ]7 c3 C
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

5 W; \. C. }; S: X% O        【2】创建按键驱动、LED驱动、延时函数功能的支持
. \; v' f4 r8 u5 z) }% O7 K         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
7 a' r! u5 s1 ~9 ~$ a* Y( V        delay.h

1. #ifndef DELAY_DELAY_H_
   " o6 T2 _  Q6 b/ _' q' b) R
2. #define DELAY_DELAY_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   ; D  d$ A- E9 ^8 j/ S! ~, j
5. void delay_us(uint32_t us); //C文件中的函数声明
   . j1 ~" X8 G% O) Q8 N6 e
6. 
   
7. #endif /* DELAY_DELAY_H_ */

复制代码

        delay.c

1. #include "delay.h"
   6 k! D5 t, O( h5 _( T" f
2. 
   4 V1 a/ Q3 {6 y! q7 f
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
   
4. {
   ; s/ x4 d, U  e
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   6 ~. A! z7 X% C  j. M/ s2 q
6.     while (delay--); //循环delay次，达到1微秒延时
   
7. }

复制代码

        2）在ICore添加key目录，并添加key.h/key.c源文件
1 i7 u4 F! L8 ], t0 P8 D
9 K2 A8 t. U  ?$ q7 x        key.h
5 v% k8 B7 l" W

1. #ifndef KEY_KEY_H_
   6 i( l6 i! V& M/ a5 s9 e+ c1 [
2. #define KEY_KEY_H_
   3 S* V" q. r5 f( m+ P
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
   2 e" ^# P0 C" {: V- F4 `6 }
9. uint8_t KEY_2(void);//按键2
   
10. 
    
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c
7 n* o3 p  ?7 F3 z& R/ K9 c" J9 ^

1. #include "key.h"
   2 Y7 V9 ^  K( `
2. 
   
3. uint8_t KEY_1(void)
   
4. {
   : f5 v) n) m) R+ c) X" m2 D) _$ d
5.         uint8_t a;
   / M, [% E' C: p
6.         a=0;//如果未进入按键处理，则返回0
   
7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
   8 p' j3 l& u+ ?* S' I
8. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
   
9.                 delay_us(20000);//延时去抖动
   , @1 u; Q* f1 M
10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    2 z6 q1 X1 F9 c4 F; P; L; e
11.                         a=1;//进入按键处理，返回1
    
12.                 }
    / ?( t2 N1 L6 a: n- R
13.         }
    - I) T  o0 N' h
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
16.         return a;
    ; ?2 H3 w% ], t  o2 [8 S$ P% a
17. }
    $ j8 d, o5 r3 d) t9 p' d
18. 
    
19. uint8_t KEY_2(void)
    
20. {
    7 _+ ]: S& `+ d  A
21.         uint8_t a;
    
22.         a=0;//如果未进入按键处理，则返回0
    $ Y0 B; `) X  D! S
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    5 o8 x2 Y$ k( t0 e, q" G
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    
25.                 delay_us(20000);//延时去抖动
    
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    9 U* D) L. m, G- D# \1 u% d
27.                         a=1;//进入按键处理，返回1
    1 G8 Z  ?. J# B, o$ Y0 N8 p
28.                 }
    + u$ _. @5 R2 M5 y3 r5 s1 H. ~
29.         }
    2 O- _) e* ]6 [8 h
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
32.         return a;
    , p- i( B/ s+ }: J/ B
33. }

复制代码

2 q1 }, T' u9 z# K. e7 R- V! b7 ~9 A+ s        3）在ICore添加led目录，并添加led.h/led.c源文件

! Q7 ^8 p# F; F6 _1 s        key.h
: c% H$ x6 N) [( P8 L

1. #ifndef LED_LED_H_
   
2. #define LED_LED_H_
   # ~: d, ]" H) T# K  k4 a
3. 
   8 \& s9 a9 z+ _( L4 M6 e: k
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   2 D5 C" d. j# o; ~
6. 
   - `' c+ H$ _; b2 K
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   % I2 p5 `7 Z2 l8 l2 e) I
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   , L1 Q; h2 x1 ~' d) t+ k. p& ~
10. void LED_1_Contrary(void);//LED1状态取反
    
11. void LED_2_Contrary(void);//LED2状态取反
    ( I% k' l) H3 c; A
12. 
    
13. #endif /* LED_LED_H_ */

复制代码

2 `1 @7 e8 Z" g+ G$ r, a        key.c
9 o! h5 Y  ^2 N; o

1. #include "led.h"
   
2. 
   ; O8 ]+ U1 f, b0 ]6 }
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   
4. {
   
5.         if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
   8 l% K( P% c# W8 c
6.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
   
7. }
     m6 y' ?5 l$ z0 ]
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);
    2 r. s, ^; v  o! k5 f
12. }
    ' v+ ]: F! V- a, s4 G  X( Y' [
13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
    / x, b8 \) y2 X8 }; Z
14. {
    2 K3 J$ A2 Y/ Y% s' x
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    4 H4 v/ [' B1 I3 v$ J0 o. H
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){
    ) K* ]/ T% S* n" A4 O0 r
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    , O9 V% i( t. \2 [( W' B
22. }
    
23. void LED_2_Contrary(void){
    9 k2 T; j. ^, N/ E1 ^! }( C# D
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    7 W! c' d  E% P6 u; M& u
25. }

复制代码

5 h2 ?" J7 W0 q' Z5 x        【3】创建串口驱动程序，主要是复写串口回调功能
        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

        usart.h
: \* ~8 |5 q5 y7 `9 N

1. #ifndef INC_USART_H_
   $ n, V( g6 G% _( C& `
2. #define INC_USART_H_
   8 |& o4 h/ |- M* [$ @4 E5 Z
3. 
   2 A& x) U$ H* F: J6 U6 H' L
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   1 R5 X, i( S9 }( `
5. #include <string.h>//用于字符串处理的库
   8 [# I+ Z" n! O' L  i1 r4 J* B
6. #include "../print/print.h"//用于printf函数串口重映射
   ' Q# W% }( Y/ i/ ~6 d
7. 
   
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   4 ~1 T0 b2 I; q1 _# b
10. 
    $ b6 W3 V2 j0 x0 w7 z$ f( a! B
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    ( ~1 E4 D: c! \9 R  N+ ?4 Q
13. 
    , O- L6 m! t0 I0 `. V: @" P. V% w# H
14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    ) ?' n3 h+ g7 f& k% `0 U
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个字节.末字节为换行符
    6 i5 t8 d6 |6 H- ?6 o
19. extern uint16_t USART2_RX_STA;//接收状态标记
    
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    
21. 
    6 Z- V' u, `3 d* ]
22. 
    
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    ' @; g; O" I% e5 d
24. 
    
25. #endif /* INC_USART_H_ */

复制代码

        usart.c

1. #include "usart.h"
   
2. 
   ; u" @  [: X! }
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   5 T( j1 o) j0 r) I
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   8 l5 }# F! F+ o/ U5 S
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];
    & H/ a% D9 O. g6 K! b
15. uint16_t USART2_RX_STA=0;
    
16. uint8_t USART2_NewData;
    
17. 
    
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    $ i1 ?3 ^) Y: {' ?
19. {
    , Q) }5 U. l9 c3 e: Z" E' @
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    & C5 _# G& v2 E" w
21.     {
    
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    . i+ Q+ u1 @5 t' T* q( Z
23.                 if(USART1_NewData==0x0d){//回车标记
    
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    : k+ ]* F- h3 `$ s6 C. s
25.                 }else{
      T1 m2 K0 \+ I4 ^
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    
28.                                 USART1_RX_STA++;  //数据长度计数加1
    2 `% f5 o, }8 }' U
29.                         }else{
    
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
31.                         }
    : n) Z2 H$ g8 L! |  x
32.         }
    : h6 a6 c0 o8 d/ \: v. d
33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
    
34.     }
    
35.         if(huart ==&huart2)//判断中断来源（串口2：BT模块）
    8 F+ P- B( c. m9 x* P9 [8 t, z
36.         {
    
37. //                printf("%c",USART2_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    . s  c5 d; C1 f9 B
38.                 if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,（手机APP“蓝牙调试器”回复数据以0x5A为结束符）
    
39.                         USART2_RX_STA|=0x8000;//标记接到回车
    7 n5 T! q. C2 z
40.                 }else{
    . N" G8 e# F1 }8 D1 W0 u
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{
    6 [; @+ N7 M( `7 i  u
45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    $ b* ~: m6 l- H% L  T# {: z* ?
46.                         }
    
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    6 Y# `& J! Q" z4 g
49.         }
    4 Y& y/ i8 N5 ~- v" ?& F
50. }

复制代码

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

        bt.h
6 m' J( I" T9 \! J) l8 |. B

1. #ifndef BT_BT_H_
   
2. #define BT_BT_H_
   " W: f: H+ R* b3 |# g! W
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);//蓝牙模块唤醒函数
    ' m. b8 A. U7 S5 j5 n8 b) u" I# R
15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    " ]5 L* b1 {$ L, L( ?2 A
16. 
    
17. #endif /* BT_BT_H_ */

复制代码

0 q6 I! r- C. f7 ?        bt.c

1. #include "bt.h"
   # r& U) J; d2 x: a* D" v
2. 
   
3. //蓝牙模块唤醒函数
   " C# {: ~7 c7 _: n  g7 k$ J- k
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   
5. void BT_WEEKUP (void)
   8 Q! `" P  M9 d6 o) b) t
6. {
   
7.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
   
8.         delay_us(100);
   . O4 V+ p+ v+ g; k$ D/ m
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];  //用于存放转换后的数据 [长度]
    # t8 W1 i+ S& w1 k2 U* S* J
16.     uint16_t i=0;
    3 f' P. W* x8 n) r3 k7 S9 Y# H
17.     va_list arg_ptr;
    
18.     va_start(arg_ptr, fmt);
    % F2 j" w! A# e( V4 E0 @
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    ! s7 `1 o, X/ ~6 K" l: }# Z
20.     i=strlen(buff);//得出数据长度
    ! w  m+ v, x9 f6 M( t$ j
21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    " {+ ^( {9 p2 i) v! m% q/ K
22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    
23.     va_end(arg_ptr);
    , z0 m6 I0 d# Z% e$ z) f
24. }
    
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

五、编译及测试
3 z- n8 F- F  b5 X        【1】功能调用及编译
+ Y* _" @/ y3 `8 `* t: o        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：
5 v& D+ i  ?0 H& z

1. /* USER CODE END Header */
   9 N. w# L5 O7 D- ~9 R
2. /* Includes ------------------------------------------------------------------*/
   6 b- u& X* O3 u# \3 A" D! S; E9 B
3. #include "main.h"
   ' a! k) y4 |0 V0 @
4. 
   ' l- L' b9 t2 I" i7 @
5. /* Private includes ----------------------------------------------------------*/
   5 J# [- o, @% j1 j
6. /* USER CODE BEGIN Includes */
   3 j+ I# D$ H4 [: B) `2 L
7. #include "../../ICore/led/led.h"
   8 B1 g! z# f8 B& _5 @
8. #include "../../ICore/key/key.h"
   5 `) I, h( N* ~& w8 H2 u
9. #include "../../ICore/delay/delay.h"
   0 ]( l* M. P3 q- ]/ a0 z7 z
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    4 u! n/ D" c8 h; o2 Y
11. #include "../../ICore/bt/bt.h"
    4 O3 a. Q, Y( C
12. /* USER CODE END Includes */
    
13. 
    
14. /* Private typedef -----------------------------------------------------------*/
    , \2 \3 D+ {7 b6 \, b
15. /* USER CODE BEGIN PTD */
    
16. 
    
17. /* USER CODE END PTD */
    6 z2 A' f  }3 W, g5 K" Z, G
18. 
    - N0 j3 E3 `1 \
19. /* Private define ------------------------------------------------------------*/
    # ?- N8 ]3 ~; Z% i  M4 C7 S) V
20. /* USER CODE BEGIN PD */
    . l8 U: _; r& L7 ~; l/ ?
21. /* USER CODE END PD */
    
22. 
    2 T3 \% b; B1 I" W+ B- R
23. /* Private macro -------------------------------------------------------------*/
    8 N, j% V; g2 t1 [) E
24. /* USER CODE BEGIN PM */
    
25. 
    
26. /* USER CODE END PM */
    
27. 
    + i6 d! W9 a; _1 {3 y, c
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    # \+ q+ V  ^3 h: B/ U9 q+ D
30. UART_HandleTypeDef huart2;
    ( k$ t7 K& o' i. t& h
31. 
    
32. /* USER CODE BEGIN PV */
    9 t5 S0 g  K; c7 \. ]
33. 
    7 x( |: x/ ~- L& ^( h/ G, S
34. /* USER CODE END PV */
    
35. 
    
36. /* Private function prototypes -----------------------------------------------*/
    
37. void SystemClock_Config(void);
    & G' e! F  Q" L
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 ---------------------------------------------------------*/
    0 n7 q8 F3 c0 Z' [. F
46. /* USER CODE BEGIN 0 */
    
47. 
    ; d6 z6 T; c0 _, [, }$ P1 F9 ~$ z
48. /* USER CODE END 0 */
    $ w% E+ u) _* c
49. 
    
50. /**
    9 X* g- d, O; N. m1 q! x! y. e- N
51.   * @brief  The application entry point.
    
52.   * @retval int
    
53.   */
    
54. int main(void)
    
55. {
    : K! X3 n% s1 ^7 l/ b
56.   /* USER CODE BEGIN 1 */
    0 W: ]! I: M& N6 f; ?8 I- V5 A1 ^
57. 
    + h% j4 [( u. O% _3 K
58.   /* USER CODE END 1 */
    . u) [) J/ Z4 U, s- L3 P, H/ t0 u
59. 
    
60.   /* MCU Configuration--------------------------------------------------------*/
    6 h9 L& c; {& \  D2 A+ r7 ~
61. 
    
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
63.   HAL_Init();
    
64. 
    
65.   /* USER CODE BEGIN Init */
    8 {) O" I. t2 h' _) V
66. 
    9 m  L4 ?/ P" g' `
67.   /* USER CODE END Init */
    9 }- c5 n* c" L% \
68. 
    8 y9 @( U4 q& B: V) U! G4 ]; f
69.   /* Configure the system clock */
    5 y; a" @- [- e7 C# K
70.   SystemClock_Config();
    % p3 d3 b0 u" R- k1 z0 i  K9 x
71. 
    5 |; _# H8 s; |) r* Q; P
72.   /* USER CODE BEGIN SysInit */
    $ G! q9 i/ e5 V$ \" I1 k
73. 
    
74.   /* USER CODE END SysInit */
    ( g" q( a- H6 d; G6 b6 i' o2 S
75. 
    7 [2 ]: A. `; T& w$ b6 o
76.   /* Initialize all configured peripherals */
    0 y  j& H2 ]$ d* N# v
77.   MX_GPIO_Init();
    8 ^; \5 R: N" S) ~
78.   MX_USART1_UART_Init();
    ) t5 W0 O+ m8 u
79.   MX_USART2_UART_Init();
    
80.   /* USER CODE BEGIN 2 */
    
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    2 j; N* I( e1 t" k% {: i8 S
82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
    0 x8 ^3 B3 E2 F
83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
    
84.   /* USER CODE END 2 */
    , n" N) h6 ~, B$ _0 l3 A
85. 
    2 |! O4 I/ M/ g5 Z2 @
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.              {
    % H) ]. ^6 }/ a% I+ T  a
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    " \( q2 l8 m. J3 S) I  _0 \
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    * }  [. O- o  Y4 Z& \7 y% b0 _8 K
97.                                 case 0x41:
    
98.                                         LED_1(1);//LED1控制
    4 r7 x  n1 Q; d1 G
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
    3 X6 _& X+ ?  L7 B. M2 {4 x
100.                                         break;
     
101.                                 case 0x44:
     4 f. }' b" d& h4 K, X# i
102.                                         LED_1(0);//LED1控制
     
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     
104.                                         break;
     
105.                                 case 0x42:
     / b& \7 j' r) Q1 Q1 A* p
106.                                         LED_2(1);//LED1控制
     
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     
108.                                         break;
     0 y* ~6 T/ }. b/ l- f: c# D6 d' ^
109.                                 case 0x45:
     ' {9 w2 I& m+ [
110.                                         LED_2(0);//LED1控制
     
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     
112.                                         break;
     ' F# z$ J% \5 @* I
113.                                 case 0x43:
     
114.                                         LED_1(0);//LED1控制
     8 N6 X; d- ]4 ~/ }
115.                                         LED_2(0);//LED1控制
     
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     
117.                                         break;
     ! W" Q* T) n, b9 P7 v  R
118.                                 case 0x46:
     & z- u- C$ i! A7 _2 d
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     3 c# }. F6 [2 _1 w7 u- z6 o0 p
120.                                         HAL_Delay(1000);//延时
     6 g, g5 {5 }# K1 x9 N
121.                                         NVIC_SystemReset();//系统软件复位函数
     ! _+ ~7 u" @8 X9 C
122.                                         break;
     6 W# V1 l; g9 s$ w6 F5 ^7 W7 O, B: _
123.                                 default:
     ( f% E. q5 [- S) n+ w0 A5 ^
124.                                         //冗余语句
     
125.                                         break;
     
126.                           }
     + n2 r) w" K  x8 F
127.                  }
     
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     % s) T& C4 N" e% g6 f8 s
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
     ; s: A( X* Q# X. m4 D
130.       }
     9 C5 r- U' i0 G
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     
132.       if(USART1_RX_STA&0xC000){//结束标记
     
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     ' {0 g* g) |, P% E
134.               USART1_RX_STA=0;//接收重新开始
     
135.               HAL_Delay(100);//等待
     9 \) x6 e7 h3 o/ {8 ]# b
136.       }
     
137.           if(KEY_1())//按下KEY1判断
     
138.           {
     . a; u7 |6 W, w$ G& G$ A
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
140.                   LED_2(0);//LED2控制
     ! D8 t2 e9 z/ V* n
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     
142.           }
     : w6 D% D& |* L* a
143.           if(KEY_2())//按下KEY2判断
     ) A+ C( x( a  U! H! f
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
146.                   LED_2(1);//LED2控制
     2 G: P. @' Q: ^$ a5 m% m" f
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     1 W- r3 c/ x9 r# y3 I& S
148.           }
     ' y* r/ `/ l( v7 n5 Z! \+ N
149.     /* USER CODE END WHILE */
     
150. 
     $ Q7 l- s2 G5 ^+ {
151.     /* USER CODE BEGIN 3 */
     1 K' ^  R( t* Q- p
152.   }
     0 ]1 S) H' V' p; X
153.   /* USER CODE END 3 */
     
154. }

复制代码

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



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

7 h! E; f6 _5 b) o$ ~- L6 N

        【2】程序测试
4 X4 q& A4 g* G( v        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
8 H) Q) S! r/ T2 m4 D        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
1 r& K3 X. K6 P4 b+ t5 C        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
5 `; U' `& T/ u9 L  `, f1 l        蓝牙调试器工具，本文用的是1.9安卓版本。
$ H* H5 y$ C" _' A. L8 [

0 R4 U! h, _* [' ^
% K6 F4 z: b5 }4 z) }. {& p
6 ]5 E- M8 S* k" q: k        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：



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


: A/ x* v% l2 T/ ~& z  U& C  h/ n, J        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：

1. if(KEY_1())//按下KEY1判断
   
2.           {
   
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   5 `; c1 S, o+ Q0 X  @5 m8 n
4.                   LED_2(0);//LED2控制
   * s% V7 _1 ?# p2 ^: ^  x% F& |
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   
6.           }

复制代码

        串口发送数据：

% z+ Q/ f$ f6 C
% T' P& Z6 o, ?! C- E3 J
+ G: b' Z6 Y1 t4 O' U. P: N
        可以进入按钮控制页面进行指令定制设置
* w$ v$ @& ^  N. p; `


6 Y1 b  h$ g; e& k; f3 p6 O3 {6 s         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
+ {! ?+ o4 _7 |; A: x! t————————————————
版权声明：py_free-物联智能
如有侵权请联系删除