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

* H, F) p, V2 z8 z
7 ^9 U/ Q) D, [* T9 Q/ O二、MCU及蓝牙模块
+ ^. G# s/ r: M) ^/ j        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：

$ [( x  |2 q1 c1 Z0 @: g+ h        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。
4 S; L* }& m8 P
  y+ m, A0 Y3 g2 a& c& C) V

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

. D  M: \# c5 y: P) y& h        TICC2541 芯片 引脚：
) \: d$ O. w! ?! ]

: r3 f0 r1 Z3 ~  N# d& S7 _
$ Y! A% Z# b8 g2 f6 g         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：
+ [) i; v/ O! k6 h& A
9 l* O7 V: m( o! R' ~

0 D: d/ Q# ?& v' {- _0 v         以及本文用到两个AT指令：
# \& A, a; ]! _( `, h: O
' J* S' G. [  m+ P  s# P
& E9 K8 o+ l# a/ ~9 Y7 P
+ y/ u* R7 u% z' w/ ~8 j 三、cubeMX配置MCU及蓝牙接口
        本工程设计功能如下：
. F8 V. N" @, t2 j4 E# F
        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。
0 E( j- \( ]+ y# D
        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。
+ x, [2 g6 W3 p" M# K0 O# ?
        功能：
( Q3 a/ T) T" N  O5 h        按键功能，用于按键时向蓝牙模块发送AT指令；
* t" w- z+ k, X# Z$ B; O0 L, q        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
- u9 y3 j) n8 e' R5 W" n        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
        1）新建stm32工程，选择芯片STM32F103C8T6
& l7 w: v, @- g
% `% x3 [: \& j- m' M# z
$ ?/ {& w7 u$ {
         2）为工程命名完成创建

) `" B8 q, G, H9 Q5 M# M

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



         2）开启RCC
0 R$ o+ e) ~# [$ I- F8 d


( S! H7 @- G! w) K' @+ I         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。

7 ?* Q& u: n  n: _5 P
* y5 b) z4 Z2 t3 I
) _; W" A0 v; o7 [         4）开启串口USART1、USART2中断功能



         5）串口引脚参数配置
9 p: s! D; U5 \$ H

, l9 J0 `8 N& a
         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：
( b! i" i1 S" A2 g0 p

7 p: j4 [6 J$ n8 @/ U
        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。
+ z% K& x) G! Y


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

; z* s% R4 U" U+ s  W


四、代码设计
& c1 z+ t+ d: x: E$ p" {3 B! T        【1】首先创建usart1接口的调试输出支持
' m3 ~9 w  V( I2 @% O& t0 H        1）禁用syscalls.c，右键选择该文件进入属性页面设置。
: n7 L9 j+ g, r" `3 T5 W- `
2 P1 z4 \! O2 Q% F# w

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

9 m) Y2 G4 K- p! w        print.h

1. #ifndef INC_RETARGET_H_
   
2. #define INC_RETARGET_H_
   # I+ ~$ i4 s: N  `: V/ z" U# V
3. 
   & x) F, u8 P( b& C1 J
4. #include "stm32f1xx_hal.h"
   
5. #include "stdio.h"//用于printf函数串口重映射
   + ?$ n2 @1 n2 y# O  k
6. #include <sys/stat.h>
   9 m; A, u* S, x4 n
7. 
   
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   
9. 
   5 ]9 _& m8 m' R  i8 v
10. int _isatty(int fd);
    , o1 {3 C2 R! w1 O  D
11. int _write(int fd, char* ptr, int len);
    ! u$ u0 f: l$ e0 Y! l# r# b
12. int _close(int fd);
    
13. int _lseek(int fd, int ptr, int dir);
    
14. int _read(int fd, char* ptr, int len);
    . n* `( f1 |2 `1 l" q  E
15. int _fstat(int fd, struct stat* st);
    ) F: I; S. S) `* ?( ?
16. 
    
17. #endif /* INC_RETARGET_H_ */

复制代码

0 c! H5 f3 P$ I1 _# n" [* ?        print.c

1. #include <_ansi.h>
   ( l; a: S) D0 E) W
2. #include <_syslist.h>
   
3. #include <errno.h>
   # r2 d# b( Z  o1 H% N" F* a
4. #include <sys/time.h>
   8 B% r8 C* \. w5 Y  o$ E% p
5. #include <sys/times.h>
   $ h3 N" V/ }/ D7 J! {
6. #include <limits.h>
   
7. #include <signal.h>
   " Q1 P+ F7 h5 Z7 Y
8. #include <stdint.h>
   7 ^3 O! h/ d: m; L, Z$ \( C
9. #include <stdio.h>
   8 @; \0 I) }3 e- H5 Y
10. 
    & ^2 s9 b" w. W9 B3 L$ Y# ~
11. #include "print.h"
    
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    * }7 f7 t$ D" j  F
14. #define STDIN_FILENO  0
    # H9 C; u0 P) Z& n' h
15. #define STDOUT_FILENO 1
    ; a( j; |* B) E1 Q4 ~1 |$ n
16. #define STDERR_FILENO 2
    7 q" l& e2 i' ?
17. 
    / p2 O) v! f7 s5 B% B3 y1 ?1 c
18. UART_HandleTypeDef *gHuart;
    
19. 
    - F8 W$ q, B  Y7 i" ^) w0 h- e. y, R
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    
21.   gHuart = huart;
    
22.   /* Disable I/O buffering for STDOUT  stream, so that
    
23.    * chars are sent out as soon as they are  printed. */
    : T- B8 y! U5 c! T2 T3 m+ W
24.   setvbuf(stdout, NULL, _IONBF, 0);
    ) C5 D! I7 r: T6 j. m; G+ D& [) r
25. }
    
26. int _isatty(int fd) {
    + p& r4 o6 ?7 E" o8 X
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    
29.   errno = EBADF;
    
30.   return 0;
    0 j* d0 t5 n; f! c
31. }
    9 L& A( y6 r9 Q/ k4 e4 S1 L
32. int _write(int fd, char* ptr, int len) {
    & P% f6 y$ G  G" z/ D: [
33.   HAL_StatusTypeDef hstatus;
    9 E3 }5 q- ^. G- ^: M( n
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    $ U" E, p9 b) `6 M7 ~+ Y
36.     if (hstatus == HAL_OK)
    3 D; ]: v) S6 A6 c) w% l7 y% R
37.       return len;
    
38.     else
    / c. i- ], v# U& t
39.       return EIO;
    
40.   }
    0 m8 m' [# @' J& H6 X" n( O6 n1 s: J
41.   errno = EBADF;
    
42.   return -1;
    $ }  F- [* C- S
43. }
    
44. int _close(int fd) {
    4 Y4 G$ a" a% t
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
46.     return 0;
    
47.   errno = EBADF;
    
48.   return -1;
    6 L0 D& ~* y! m- c. Z
49. }
    ! {* K4 k. p& c  X
50. int _lseek(int fd, int ptr, int dir) {
    6 Z2 S3 x8 q* }7 o
51.   (void) fd;
    4 Z- |+ S$ v8 N( m' D# h( E7 P$ J
52.   (void) ptr;
    9 V/ [6 }) C# H* p
53.   (void) dir;
    2 s$ x# C& n1 u: ?
54.   errno = EBADF;
    
55.   return -1;
    8 V' w) D9 a7 `4 S% u. I3 F; Z
56. }
    
57. int _read(int fd, char* ptr, int len) {
    
58.   HAL_StatusTypeDef hstatus;
    0 r' t% b5 f$ D' s8 }
59.   if (fd == STDIN_FILENO) {
    % m! L) O6 i& [1 T5 C# [" k
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
      m0 Y  m- i4 E, ]& V0 V1 N4 H
62.       return 1;
    
63.     else
    
64.       return EIO;
    
65.   }
    5 {( S0 H5 U5 H
66.   errno = EBADF;
    * V+ G$ S" r; x* S  Q
67.   return -1;
    4 H4 ~# ~$ Z; E8 n- A$ f
68. }
    5 n' p8 E( `  W! E
69. int _fstat(int fd, struct stat* st) {
    
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    & b* d) ^: Y7 t% H: O( F
71.     st->st_mode = S_IFCHR;
    # P3 n% {$ @& W& {9 b0 M
72.     return 0;
    + Q, D" R4 g( b: l
73.   }
    4 C- U/ y# ~* r! A! t, @6 t( d1 r
74.   errno = EBADF;
    
75.   return 0;
    6 u3 h9 q) L$ b! n
76. }
    + L1 O% v; O6 K. s
77. 
    9 R# V( s* {$ {% @
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

5 L- n" a- C& \) E; R0 \        【2】创建按键驱动、LED驱动、延时函数功能的支持
2 B+ M( D* O3 Z! K* W5 o         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
        delay.h

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

复制代码

# V, M* U& c( O% `) i1 w        delay.c
9 J7 Y" Q5 t7 H# l+ z

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

复制代码

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

$ }0 U# u; P7 N5 ~4 I) {, J        key.h
6 E5 P5 i8 w# }4 [

1. #ifndef KEY_KEY_H_
   7 M; V0 l  a% x; O! q- m  I6 U
2. #define KEY_KEY_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   4 c2 Z2 x2 J: t( w4 z' Z4 i
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   
6. #include "../delay/delay.h"
   ! |! k8 H4 R1 [4 ^) [- f7 k
7. 
   
8. uint8_t KEY_1(void);//按键1
   
9. uint8_t KEY_2(void);//按键2
   5 M7 J" j, t* N* P* t$ e& ~# {) ~
10. 
    
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c
8 z: k4 R" J* z' B1 L8 h

1. #include "key.h"
   8 s4 L  ?; L5 _9 I% c5 E
2. 
   ) B1 b/ w' `/ m6 n& J4 @% e  Q
3. uint8_t KEY_1(void)
   4 L1 W6 J$ A: V( K! R2 u# h- A% p
4. {
   ' z1 n! @, ?6 m; X  w
5.         uint8_t a;
   , |/ m, w* p! s0 K3 ^
6.         a=0;//如果未进入按键处理，则返回0
   , {6 J. I4 |& `) h: n, D
7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
   , `6 ]( B! a4 I
8. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
   
9.                 delay_us(20000);//延时去抖动
   
10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    7 I" ?/ t' k, p
11.                         a=1;//进入按键处理，返回1
    
12.                 }
    5 T4 l. _0 ^, Y+ V0 K# @
13.         }
    
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
16.         return a;
    # l6 i& e( v( x; a' I
17. }
    
18. 
    
19. uint8_t KEY_2(void)
    : r2 |9 _/ m. u- Q! o
20. {
    $ n0 g( [# X7 c( M2 e" u- i- B
21.         uint8_t a;
    " i& {! M9 q9 h7 @) ~
22.         a=0;//如果未进入按键处理，则返回0
    , h; n0 E  h' M
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    ' L- T, `* @6 G+ Y: N: u% b5 g9 ~
25.                 delay_us(20000);//延时去抖动
    5 {! i. Y" r7 a5 o
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
27.                         a=1;//进入按键处理，返回1
    
28.                 }
    
29.         }
    
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    ) J$ x9 z, r9 [6 q
32.         return a;
      y4 P$ I9 a1 G
33. }

复制代码

- Q: P) d6 x; d        3）在ICore添加led目录，并添加led.h/led.c源文件

) J' n8 Q, R% F2 B! B: F        key.h
+ f! Q( h! d# x# f

1. #ifndef LED_LED_H_
   0 H- @2 t  b! s8 ?+ @
2. #define LED_LED_H_
   
3. 
   . j# P+ {. e1 u5 n4 S- f( @1 |, Y6 J
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   1 O) D' x8 ~) m( V
6. 
   
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   $ J1 ^' r, {' X& D( m( j8 w5 {
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   $ W3 e, q0 [6 Q0 o# q" E
10. void LED_1_Contrary(void);//LED1状态取反
    
11. void LED_2_Contrary(void);//LED2状态取反
    ( X- o( a& j  @$ s- C7 p6 i0 x
12. 
    
13. #endif /* LED_LED_H_ */

复制代码

# n) \  d8 N. j2 _' o- g        key.c

1. #include "led.h"
   / r+ @3 I' B; X; d9 N- x+ M
2. 
   ( t. K& a+ k6 K8 G4 U3 G
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   6 L( u6 k0 u3 l# D* q0 y& @
4. {
   
5.         if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
   ) D; C. e, ?5 p* E
6.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
   7 C% Z: G: G" A' f
7. }
   ; \) w$ {7 C, `/ u( O2 ~
8. void LED_2(uint8_t a)//LED2独立控制函数（0为熄灭，其他值为点亮）
   
9. {
   + [0 r0 x+ f: ?) A. g5 S
10.         if(a)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    
11.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    
12. }
    
13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
    " g$ B7 _; R! B: |, x9 O' `
14. {
    - R, `1 O6 l) I  K* l
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    
17.         if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    : w) ]5 C( @$ v; o/ d* S2 [0 |
18.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    , H( z$ {+ e$ P' m
19. }
    
20. void LED_1_Contrary(void){
    
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    
22. }
    : l5 i, ?9 h% G9 N3 G
23. void LED_2_Contrary(void){
      Q% S! i1 I4 [2 E5 i
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    % z2 G" ~( X# P: Z
25. }

复制代码

/ T" a8 U& E$ C" K        【3】创建串口驱动程序，主要是复写串口回调功能
& Z8 d/ g0 y* S& n; x        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

( ^4 \/ \2 x3 ^( F' Z        usart.h
" B# j( k/ \# u+ J

1. #ifndef INC_USART_H_
   - A: W: j% E1 w% ~( a
2. #define INC_USART_H_
   
3. 
   2 O* d4 Q( x7 m1 r7 e
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   1 D# v$ X8 w7 i5 X9 J. j
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   
7. 
     a" s6 t% L2 Z6 v8 k
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   5 {* i! N8 w4 ]5 Z( V2 z9 N
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   
10. 
    
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    + M* @$ ^$ n+ @) `3 C
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    
13. 
    
14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
15. extern uint16_t USART1_RX_STA;//接收状态标记
    + W0 h, q& c3 e
16. extern uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    
17. 
    
18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    : @: a# S( W( {. U, D/ O/ K
19. extern uint16_t USART2_RX_STA;//接收状态标记
    ( |# v  H* m* R$ F* Y5 O) T& i4 e
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    ; `1 P9 g7 ^8 u" G6 l
21. 
    + z+ m% X7 b. Y/ t
22. 
    5 c) @) t! t8 K9 J" @
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    5 u" B- f, O9 a. _, t
24. 
      ]# N0 I. B$ Q
25. #endif /* INC_USART_H_ */

复制代码

        usart.c

1. #include "usart.h"
   ! S( |% U( n+ A% ^8 D
2. 
   6 n& E" R/ [4 J  b
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   2 h7 ~5 ^1 [. Q6 b' {: K6 T& Q
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   8 w7 l0 |% x( M" C
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   % j( c' \, K5 `6 O- F  w* K4 o
7. * bit13:预留
   / B1 R7 ?6 z1 X  S
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   * @- U6 v& I* l
10. */
    : ~: W3 `4 R3 {1 F) A0 F
11. uint16_t USART1_RX_STA=0;
    9 f* }4 a6 |5 ?  O7 C  N
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    ( v' }$ F( I& }* l2 x& X' B
14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
    
15. uint16_t USART2_RX_STA=0;
    
16. uint8_t USART2_NewData;
    0 S9 L/ w. C* Y$ e% t+ A: f
17. 
    1 Y; u' s6 [! L& Y
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    
19. {
    
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    : }# y& B- h1 G3 r; _7 A% q4 N
21.     {
    
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    ! c# S2 ~% J8 |
23.                 if(USART1_NewData==0x0d){//回车标记
    ' a4 J3 a+ e2 ^8 V! {
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    
25.                 }else{
    
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    7 O) u" d1 M8 E; @9 G4 _. a( c
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    1 J# g7 q' P$ V- x
28.                                 USART1_RX_STA++;  //数据长度计数加1
    
29.                         }else{
    8 |. F4 k( d+ T% H7 c: E/ O( V- d- i
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
31.                         }
    , x; s+ A) l  w; H
32.         }
    : C  x0 y+ V4 a1 A# I6 E2 c5 o
33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
    & m  G1 o% ]: o0 h
34.     }
    " R4 k$ T& ?; Y( \2 s& a4 V* U
35.         if(huart ==&huart2)//判断中断来源（串口2：BT模块）
    
36.         {
    ! u) H6 K, k) `% g1 T1 F1 i
37. //                printf("%c",USART2_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    5 @8 ]  G% d5 a7 z& j' U
38.                 if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,（手机APP“蓝牙调试器”回复数据以0x5A为结束符）
    
39.                         USART2_RX_STA|=0x8000;//标记接到回车
    ; a9 l3 M# m* L
40.                 }else{
    , }: _4 m+ s4 [+ D7 ^
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;//数据超出缓存长度,标记溢出
    7 w! x& N: J3 k3 @7 j, T3 j
46.                         }
    8 g2 c- z( z, A$ U! s1 v6 ^& {2 m: U
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    5 h3 U& n# x9 W5 a6 {0 E
49.         }
    6 r  f7 w& Z" d5 I2 V# v6 W
50. }

复制代码

        【4】创建蓝牙驱动
1 g0 Q6 O0 Z3 |1 G6 W        该驱动主要实现通过usart2向蓝牙模块写入数据，（读取数据主要通过串口usart2回调，在usart.c中实现）。在ICore添加bt目录，并添加bt.h/bt.c源文件，实现蓝牙驱动功能
- z: F1 J4 c3 b. q0 K' Q
        bt.h
& P: w  O$ D6 D8 `% h: E

1. #ifndef BT_BT_H_
   : W6 c9 ^) D. T5 G' a1 f' g* E( m
2. #define BT_BT_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h"
   / Y% W  n6 u7 t( E
6. #include "../usart/usart.h"
     U) C* [# z" m$ v4 \* P/ m4 A
7. #include "../delay/delay.h"
   
8. #include <string.h>//用于字符串处理的库
   . |3 {/ ?) `" L6 H  @8 M% x
9. #include <stdarg.h>
   7 I% }4 d( r2 t, }8 Z6 }  a
10. #include <stdlib.h>
    
11. #include "stdio.h"
    
12. 
    
13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
    
14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
    
15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    + P. z# G; }6 I6 E
16. 
    # n# d1 k3 P- l- u  J; `, E
17. #endif /* BT_BT_H_ */

复制代码

/ S3 C% ?' [8 l% I* n: O& c        bt.c

1. #include "bt.h"
   % H! o# k9 j+ l7 R4 ~
2. 
   
3. //蓝牙模块唤醒函数
   0 ]& x: W2 \0 w& Q3 w" F2 ?( j
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   3 g; p" S5 O$ K) M( ~; y
5. void BT_WEEKUP (void)
   
6. {
   
7.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
   2 f- ?& `4 _" b5 l: Z: a# Y' i9 m
8.         delay_us(100);
   
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
   ; ^% X% \; N4 A
10. }
    
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    5 y/ o- w! o/ {, Q  A
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    
13. void BT_printf (char *fmt, ...)
    
14. {
    5 r' p* ?, M- Z4 Z  A9 ~, q+ A% s
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
16.     uint16_t i=0;
    
17.     va_list arg_ptr;
    ( U: V& O. ~# S5 O5 @
18.     va_start(arg_ptr, fmt);
    
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    
20.     i=strlen(buff);//得出数据长度
    ! R$ z% G  m; V9 R8 ]
21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    
22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    9 g1 L. c. C2 L( E4 L+ ^4 P
23.     va_end(arg_ptr);
    
24. }
    
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

# I- Z$ B9 _8 h, w- u0 |1 y# ?/ c五、编译及测试
0 N7 w$ Y3 Z6 p* k: J        【1】功能调用及编译
        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：

1. /* USER CODE END Header */
   ; `7 a- \# k- A1 I! }1 }
2. /* Includes ------------------------------------------------------------------*/
   7 t0 i: \2 h3 x' E3 M
3. #include "main.h"
   . y) B% V# C7 W6 @
4. 
   0 t  [- d6 S8 y
5. /* Private includes ----------------------------------------------------------*/
   
6. /* USER CODE BEGIN Includes */
   
7. #include "../../ICore/led/led.h"
   6 H. o" r3 O  Y$ d9 ~8 |
8. #include "../../ICore/key/key.h"
   
9. #include "../../ICore/delay/delay.h"
   " }& i, Z0 y% R6 i& D+ z
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    
11. #include "../../ICore/bt/bt.h"
    
12. /* USER CODE END Includes */
    2 ?2 }6 r" c  z2 {7 h3 l* ?- c
13. 
    
14. /* Private typedef -----------------------------------------------------------*/
    * J+ R9 b' b/ K# Z5 _2 D
15. /* USER CODE BEGIN PTD */
    
16. 
    
17. /* USER CODE END PTD */
    ) D) z4 T$ D0 H/ r6 C
18. 
    . i8 [' @: D* n7 r0 c$ Z
19. /* Private define ------------------------------------------------------------*/
    & e8 T! u) ~1 W( f' B! G% M
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    
22. 
    
23. /* Private macro -------------------------------------------------------------*/
    
24. /* USER CODE BEGIN PM */
    
25. 
    
26. /* USER CODE END PM */
    8 r7 }8 }3 X5 H# o% j
27. 
    
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    
30. UART_HandleTypeDef huart2;
    
31. 
    # d# c5 Z4 H7 b, F' D0 V. G
32. /* USER CODE BEGIN PV */
    0 ~. p) k6 q1 Q: e  L7 o# A9 P+ k  S
33. 
    1 Q, F, |, Y! Z
34. /* USER CODE END PV */
    
35. 
    
36. /* Private function prototypes -----------------------------------------------*/
    3 p+ `  h2 L' D0 }: I& m9 O! h/ l: B# ]
37. void SystemClock_Config(void);
    
38. static void MX_GPIO_Init(void);
    , H* I+ o8 |. w1 C0 z  \5 X1 H0 x
39. static void MX_USART1_UART_Init(void);
    
40. static void MX_USART2_UART_Init(void);
    5 [0 K' n4 `% T7 K, X' A! A& g0 L
41. /* USER CODE BEGIN PFP */
    
42. 
    5 {- k3 P! M; e2 B. A7 R: a
43. /* USER CODE END PFP */
    ' {, y( ^; T" _
44. 
    
45. /* Private user code ---------------------------------------------------------*/
    * n3 P" `  y3 T
46. /* USER CODE BEGIN 0 */
    
47. 
    2 m5 L, |- f- W9 O1 [
48. /* USER CODE END 0 */
    
49. 
    - M+ O% H: [4 K, O- ^6 v7 W
50. /**
    
51.   * @brief  The application entry point.
    " ?/ k; A% V5 N$ T& U8 C2 ]+ q1 \
52.   * @retval int
    
53.   */
    
54. int main(void)
    
55. {
    5 |7 u! X2 ?& y  O& G& l3 G+ x
56.   /* USER CODE BEGIN 1 */
    ! [! x  i- `, x& g5 Z" o9 c
57. 
      F! t2 F; ?- d- T
58.   /* USER CODE END 1 */
    
59. 
      T+ Q6 B& _; O& l0 J/ M! [
60.   /* MCU Configuration--------------------------------------------------------*/
    5 R" n" o* V+ U% s& @
61. 
    & I; Q& \; N1 ?+ |+ J+ p
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
63.   HAL_Init();
    
64. 
    $ Y2 ^/ v5 z$ t  N
65.   /* USER CODE BEGIN Init */
    
66. 
    
67.   /* USER CODE END Init */
    
68. 
    
69.   /* Configure the system clock */
    
70.   SystemClock_Config();
    
71. 
    ' e5 s5 A! j) K6 w
72.   /* USER CODE BEGIN SysInit */
    
73. 
    0 k& M5 P  l' G! u3 N( o3 [! g# |* E
74.   /* USER CODE END SysInit */
    . k2 H( p2 A( E+ k
75. 
    
76.   /* Initialize all configured peripherals */
    4 U' i2 g; ~) M0 g4 R5 D+ G
77.   MX_GPIO_Init();
    
78.   MX_USART1_UART_Init();
    2 l9 L) x& T' U8 y
79.   MX_USART2_UART_Init();
    ! Z- w' c+ T+ A- @6 D
80.   /* USER CODE BEGIN 2 */
    - O9 d1 X' d( Q5 g. v4 \
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    
82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
    
83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
    " u/ H. a. f5 |- X! a2 w1 w
84.   /* USER CODE END 2 */
    
85. 
    ' K4 [1 D; c& T. I! D, F
86.   /* Infinite loop */
    
87.   /* USER CODE BEGIN WHILE */
    
88.   while (1)
    , p: a5 \7 p2 f( ?6 p9 }2 ^
89.   {
    
90.           //demo 蓝牙02
    " _: N3 ~* {( A; j
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    
92.              BT_printf("%c",USART2_RX_STA);
    3 m8 g2 W2 c  v; f$ L
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    2 s( o7 W0 R: g* `5 N
94.              {
    - Z* d* u1 y8 e0 R
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    
97.                                 case 0x41:
    
98.                                         LED_1(1);//LED1控制
    - l: p" x; N6 C+ v3 o
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
      s, W# {; I1 u0 n7 {, c$ u
100.                                         break;
     
101.                                 case 0x44:
     / D5 I4 U8 ~; d6 f: j% b% ~
102.                                         LED_1(0);//LED1控制
     
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     4 }$ h( \9 V  B. d& v
104.                                         break;
     
105.                                 case 0x42:
     6 ?# m$ _! Z9 }8 w" U
106.                                         LED_2(1);//LED1控制
     
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     
108.                                         break;
     
109.                                 case 0x45:
     . {5 l' o' O7 D
110.                                         LED_2(0);//LED1控制
     
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     
112.                                         break;
     . v4 m/ ^) w& ?2 Z$ X9 G
113.                                 case 0x43:
     
114.                                         LED_1(0);//LED1控制
     
115.                                         LED_2(0);//LED1控制
     . G5 z7 R# n+ S0 a6 y2 C7 v
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     
117.                                         break;
     ' A, j( h1 Z. J* l; j
118.                                 case 0x46:
     
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     
120.                                         HAL_Delay(1000);//延时
     
121.                                         NVIC_SystemReset();//系统软件复位函数
     
122.                                         break;
     , X% L8 \2 j6 W% m0 \& P
123.                                 default:
     
124.                                         //冗余语句
     
125.                                         break;
     . v4 V# z% e1 w3 m
126.                           }
     ) \  m( M7 W/ Q
127.                  }
     
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
     
130.       }
     
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     8 @; C  o) J9 u5 l
132.       if(USART1_RX_STA&0xC000){//结束标记
     ; o7 c# ^6 @- }5 d6 d- h
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     $ e9 \1 J, Y* j# O$ [% J# `
134.               USART1_RX_STA=0;//接收重新开始
     3 C! g2 D! \3 c6 i6 R  {) _
135.               HAL_Delay(100);//等待
     
136.       }
     0 ]' X, l( ?( Z
137.           if(KEY_1())//按下KEY1判断
     
138.           {
     ' ^; A& T7 H* U/ w: B: g
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     8 t" [: `# Q# `( i9 l, G
140.                   LED_2(0);//LED2控制
     
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     
142.           }
     
143.           if(KEY_2())//按下KEY2判断
     
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
146.                   LED_2(1);//LED2控制
     
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     " @" Z% H/ k. r. [; n: i: ~2 V
148.           }
     
149.     /* USER CODE END WHILE */
     
150. 
     ; z% q+ {6 Z/ [
151.     /* USER CODE BEGIN 3 */
     $ t: w* a& y$ K, ^1 |' c8 u
152.   }
     ' {* y4 t* l( @1 Q' u% V( X
153.   /* USER CODE END 3 */
     
154. }

复制代码

1 Q' y% n3 d2 [8 t. o       2）设置编译输出支持，右键工程进入项目属性设置页面：
% Q" {# u- b" d! k, K/ d7 n
& ?2 [' \$ b3 U- w
7 i5 Y. o- Q* Q' n6 f, x! l5 t
          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：
/ H. D/ k# N( z9 U) c
1 @. j+ a1 @/ @) K

9 Y4 C; W4 ~9 _: n. H        【2】程序测试
4 V- G4 ~( q) N2 e' o" w        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
8 a) J: a. U% r6 e1 F        蓝牙调试器工具，本文用的是1.9安卓版本。
' y2 r* z# P6 H
* K- Q0 N) E. A4 S$ r4 f
4 M: g- k4 b8 R/ b2 \9 B4 F

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

8 ?  ?$ Q- k. M8 a
( n: w1 w' ^, ~6 C, S
         3）手机打开蓝牙调试器（别忘了开启手机蓝牙功能），进入界面，搜索蓝牙，点击蓝牙边上“+”按钮连接蓝牙模块，采用SSCOM串口工具连接到usart1上，就可以通过蓝牙通信实现手机（蓝牙调试器）与电脑（串口工具）的通信了，在蓝牙调试器发送数据时，十六进制时需要加上“0A”作为结尾，如果十进制发送时，注意加上换行再发送：
& _8 s! e, o) p" X% Z


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

1. if(KEY_1())//按下KEY1判断
   9 z) @4 k1 T0 S: O# P6 j
2.           {
   
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   # t7 w' X3 x% J5 J" D$ {
4.                   LED_2(0);//LED2控制
   
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   * l6 R6 Z( M8 ]- u
6.           }

复制代码

2 p5 y5 A, G0 E2 q5 V        串口发送数据：
8 S- t. W# P- K/ ~2 G7 W. J. h

- U8 v9 C9 h# X
% W) ~! ?0 ?+ U, d
# x0 r: O( A1 ~2 k* l+ q* `/ _9 j8 D        可以进入按钮控制页面进行指令定制设置

. R5 W: ~% h, j* @
; o: U' J9 N+ H! m* n
6 K, w/ M. \+ l) k5 T  Q         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
————————————————
0 V. ]9 W7 q2 X! n/ x* W) T; p版权声明：py_free-物联智能
如有侵权请联系删除


- ~' G8 g. {8 l, n9 S2 D* F- f