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

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

  K& C& N5 [3 `$ f二、MCU及蓝牙模块
        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：
8 m; V3 q- o3 }: X3 C0 w( {
. i* R; _' r2 F/ ?% ~  w( y        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。

3 `' Z& M3 c; t% y% ]5 z3 o5 T3 R
' {9 u2 k5 z& t8 @
         蓝牙模块为JDY-08 蓝牙透传模块，基于蓝牙 4.0 协议标准，工作频段为 2.4GHZ 范围，调制 方式为 GFSK，最大发射功率为 0db，最大发射距离 80 米，采用 TICC2541 芯片设计，支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。

# C, p, e( d0 o        TICC2541 芯片 引脚：


5 r; Z: b" _( y7 s1 }0 s: Y5 H
         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：
+ N9 R  Q. I+ M6 X/ |0 g: B


         以及本文用到两个AT指令：
) v5 ~1 }: H4 U( K% V' Z* c  q
' F* z3 ?  _. @7 ]

$ `# x+ @; p  m3 W/ f5 g$ O 三、cubeMX配置MCU及蓝牙接口
3 y3 z# Y) b9 t& l0 X        本工程设计功能如下：
1 }; n# m- x& ]
        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。

        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。
# O+ N; m* i6 o0 {
- @: I4 d6 p  i4 @) z        功能：
7 }7 ^: h$ y2 s( k! ?: v: N        按键功能，用于按键时向蓝牙模块发送AT指令；
. F, ]7 M4 b9 e7 C* u4 g        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
2 @  n$ U5 x# \4 d% y  K  Y0 \# `        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
        【1】创建工程
) k+ g9 R; Q8 F9 x& @        1）新建stm32工程，选择芯片STM32F103C8T6

! n3 N, r: U8 H4 _% K5 `2 v
- |3 Q0 a- m, |5 G
         2）为工程命名完成创建
! V3 u3 \  s! P

! l" w, p$ W* F& C
; G& r1 |( \' _) @& c; X# N         【2】CubeMX配置
9 E' O3 X; E+ b        1）开启sys mode接口


  s2 C; m/ G" L; N7 \" B9 @3 m5 ~
         2）开启RCC

  D: Q7 I; C6 K" `
. E0 R! {) t9 F: H: l  {# t" @
# B' o% k1 `# Q! \! g* g         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。


# p' B8 h3 `9 F" T4 E& k
         4）开启串口USART1、USART2中断功能

# W% g3 @! h4 |) ?6 Q8 }3 k& T+ Q
0 D/ t- B) O0 s+ l
/ A# ?/ O( |' Y; d! h( _         5）串口引脚参数配置
: F% Q0 ?: P, H$ ^* u

* s8 O! ]1 d5 _! O9 J
         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：

, S5 j. m# \8 u0 E
$ c5 e2 t" r! x6 o& ?: E0 r
        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。
, G* E% T" a5 S+ s' \2 v# }+ H


2 h, u& p) D& I( O1 \5 V8 F( m          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。



& p+ X/ Z! S9 U
四、代码设计
        【1】首先创建usart1接口的调试输出支持
        1）禁用syscalls.c，右键选择该文件进入属性页面设置。

& J' f: x: G* S- [6 t1 W

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

        print.h
4 r( y' ^. ?8 k  i9 ]& u2 k

1. #ifndef INC_RETARGET_H_
   / Z% Q6 @" a  S- T' t: \
2. #define INC_RETARGET_H_
   . d- Y3 @9 R7 b1 i. w" p6 p. L7 u
3. 
   
4. #include "stm32f1xx_hal.h"
   7 h1 |3 n# s) x! g. o9 J7 Q/ z
5. #include "stdio.h"//用于printf函数串口重映射
   
6. #include <sys/stat.h>
   
7. 
   
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   " F8 ]- ?4 u: v# h) V: `
9. 
   
10. int _isatty(int fd);
    
11. int _write(int fd, char* ptr, int len);
    
12. int _close(int fd);
    ! y6 B8 [) U" F4 n  Z3 F+ x
13. int _lseek(int fd, int ptr, int dir);
    6 F) T2 ^8 e5 b1 [8 E9 w
14. int _read(int fd, char* ptr, int len);
    7 z( O- V- a$ }* ]
15. int _fstat(int fd, struct stat* st);
    
16. 
    + E0 f5 Y$ b1 u, a$ u
17. #endif /* INC_RETARGET_H_ */

复制代码

        print.c
8 ?, E4 N5 n4 Q+ a

1. #include <_ansi.h>
   * i' {, n7 M. q" V
2. #include <_syslist.h>
   9 ~7 z5 h/ n6 s/ i& _  e4 ?& Z$ @
3. #include <errno.h>
   
4. #include <sys/time.h>
   ) c2 D7 G) p  p
5. #include <sys/times.h>
   0 l/ c! \; E& v; P) _
6. #include <limits.h>
   ' Q6 H6 l5 s. Z
7. #include <signal.h>
   7 f2 }) P$ Y2 u& M$ H
8. #include <stdint.h>
   
9. #include <stdio.h>
   2 F6 v! j/ O, L' T5 E8 P
10. 
    / Q. E/ H  A6 `3 l$ A8 }( {
11. #include "print.h"
    % M  n2 A4 \4 N# Q6 {/ k4 o: L
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    / A) r) C- d& k$ e5 q
16. #define STDERR_FILENO 2
    
17. 
    , m5 O& s2 d2 v, u
18. UART_HandleTypeDef *gHuart;
    
19. 
    3 o' o$ a6 E9 S- H) @
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    ( U; Y% M$ u7 o0 ]
21.   gHuart = huart;
    & K9 |6 Z3 d, Q! K/ {, l1 }) @& y# x
22.   /* Disable I/O buffering for STDOUT  stream, so that
      P2 `9 K+ d5 w, s9 Q
23.    * chars are sent out as soon as they are  printed. */
    
24.   setvbuf(stdout, NULL, _IONBF, 0);
    ; d' N2 x, ?- V' i
25. }
    5 x1 C) Q3 e4 V; q  Y+ b
26. int _isatty(int fd) {
    
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    7 x+ Q0 ]! U( P6 @- E
28.     return 1;
    " Z: o3 u9 C7 V4 Y
29.   errno = EBADF;
    
30.   return 0;
    
31. }
    7 s7 d) P+ R: O( e1 @; t# f, k) J9 Y
32. int _write(int fd, char* ptr, int len) {
    
33.   HAL_StatusTypeDef hstatus;
    
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    $ o3 |, R! u8 {+ C) n8 l" P
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    $ h# P7 l9 W3 b7 H" h8 n
36.     if (hstatus == HAL_OK)
    6 U+ D' l4 J/ P2 S
37.       return len;
    
38.     else
    & H4 ?0 b; i( m" _
39.       return EIO;
    2 T. G- B, w& U) S
40.   }
    ; W$ j6 ?- s& {9 j2 X4 t9 q: [2 {) O
41.   errno = EBADF;
    ( d- d: u( [/ j  V6 P) m
42.   return -1;
    6 g. x3 V; ~' D5 `) H* ]
43. }
    . P# n& J6 x, x1 i5 `' F
44. int _close(int fd) {
    . A; E( F2 ?) |9 {% |3 g4 w
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    $ v! v( I. ?7 F' I/ I. ~
46.     return 0;
    
47.   errno = EBADF;
    % k' U+ _2 \. X. v! p
48.   return -1;
    ) B  e4 U- L0 I, \
49. }
    ; K$ F  v( C8 M
50. int _lseek(int fd, int ptr, int dir) {
    5 @% w1 A2 k7 v0 p
51.   (void) fd;
    4 s: A3 L' t) U0 j, B$ m0 d% ^
52.   (void) ptr;
    
53.   (void) dir;
    
54.   errno = EBADF;
    / X( t3 c0 j$ I. Y/ O+ z
55.   return -1;
    
56. }
    7 {( R$ p8 B0 @- y- _4 W. f
57. int _read(int fd, char* ptr, int len) {
    3 T: y8 C+ g/ s" v- \
58.   HAL_StatusTypeDef hstatus;
    
59.   if (fd == STDIN_FILENO) {
    
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    ( A& G5 \- w9 e( d. T
62.       return 1;
    
63.     else
    & \9 t- a/ b6 c  i' D
64.       return EIO;
    
65.   }
    . N$ ?1 F4 p% C! J# ~* P& P( h
66.   errno = EBADF;
    7 P' c4 U! o; }- p
67.   return -1;
    
68. }
    
69. int _fstat(int fd, struct stat* st) {
    # k5 c9 n$ k" }% I' i/ r: }
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    & y" i& ]1 Q2 \* ]8 @
71.     st->st_mode = S_IFCHR;
    
72.     return 0;
    ' W1 m) g9 Y* I+ Y
73.   }
    
74.   errno = EBADF;
    # l. v! N8 X! b4 f
75.   return 0;
    
76. }
    3 G/ x! W  J/ }( `6 c
77. 
    : N6 O6 V: `$ ]3 ~+ m, ?* F
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

0 v3 _6 I* ^: ~. X5 Y( R        【2】创建按键驱动、LED驱动、延时函数功能的支持
         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
' b4 _7 W( c6 z- B" V        delay.h

1. #ifndef DELAY_DELAY_H_
   
2. #define DELAY_DELAY_H_
   
3. 
   + H% z7 ]5 w# H$ R
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. void delay_us(uint32_t us); //C文件中的函数声明
   + G( I  ]! n* D& J4 q
6. 
   
7. #endif /* DELAY_DELAY_H_ */

复制代码

' y. E, B6 p! b6 e$ R8 H        delay.c

1. #include "delay.h"
   , J7 V1 y% P% q2 x0 C+ V, j
2. 
   4 U8 d6 f- c$ P9 {  w  G
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
   2 i. i! B4 g6 G  w# j/ r7 w
4. {
   & q! \) t. I! d" O! |  `  o
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   , }% ^7 n$ W& o/ |  F5 S
6.     while (delay--); //循环delay次，达到1微秒延时
   
7. }

复制代码

% [7 w/ Y, |) s        2）在ICore添加key目录，并添加key.h/key.c源文件

/ R, X3 o* {) A# g        key.h

1. #ifndef KEY_KEY_H_
   7 M8 ]* e1 A9 X$ U1 i
2. #define KEY_KEY_H_
   6 d* e$ T1 x6 I. ^$ Q0 B
3. 
   ! m) S- k2 O+ E1 t1 K
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   / _0 ?9 j% h3 u+ Q( c1 g
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   $ e0 ?. K2 Z; E7 y+ B! q! z9 n
6. #include "../delay/delay.h"
     ~$ \7 k8 n; T+ [% X
7. 
   # d6 b9 i  w6 \# r
8. uint8_t KEY_1(void);//按键1
   / ]$ H; ?: n& V2 ?+ r; K4 b. q3 M
9. uint8_t KEY_2(void);//按键2
   % {& J! s" @0 ]5 l/ W  J: x
10. 
    + D: }* @: W; K- O, {+ @
11. #endif /* KEY_KEY_H_ */

复制代码

        key.c
4 C. P5 U' P4 u, M: {

1. #include "key.h"
   
2. 
   
3. uint8_t KEY_1(void)
   5 {$ U$ q, }3 k3 B* x; o* p
4. {
   
5.         uint8_t a;
   & ]; ~/ y; i+ N! k( W! s0 h
6.         a=0;//如果未进入按键处理，则返回0
   $ C) t/ t9 t+ B. N* f$ Y
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){ //读按键接口的电平
    # x! F3 l0 Q" l! D) a8 J. R8 v
11.                         a=1;//进入按键处理，返回1
    ) S( @' j+ r  V9 M" K2 G* k
12.                 }
      C8 M: S0 @! ~( ^6 ~  m
13.         }
    
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    8 k0 M/ X5 Q  k) e, y! e4 G5 Y$ @
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    7 O& Q2 d$ w& V; J, H1 e
16.         return a;
    6 v- L- E1 a0 P' v( k" [7 u: I# A' v
17. }
    
18. 
    
19. uint8_t KEY_2(void)
    1 v7 N/ F7 m; x" S8 f' O/ |
20. {
    
21.         uint8_t a;
    
22.         a=0;//如果未进入按键处理，则返回0
    
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    , C" `* @2 V3 v, L5 f
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    1 q" m+ M- o5 L
25.                 delay_us(20000);//延时去抖动
    
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    ( e# f% h- `( b8 M
27.                         a=1;//进入按键处理，返回1
    
28.                 }
    8 q6 T7 a! \2 B& [' G
29.         }
    ( R: s" l% G7 p' e
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
32.         return a;
    8 D# J& }+ s' O+ V3 D) W- B0 L
33. }

复制代码

5 ?9 w" f% M* z6 p5 M+ R# s        3）在ICore添加led目录，并添加led.h/led.c源文件
, t; `; r; }' \! w. P1 S' [
+ v" f0 s6 A4 S9 w        key.h

1. #ifndef LED_LED_H_
   
2. #define LED_LED_H_
   
3. 
   6 t" w: R& O8 w: x9 F' ]
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   ( B9 z8 o+ o' r/ b: d
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   1 s7 z( A, r1 ^4 {, Q% h6 t) V
6. 
   
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   8 y+ q0 x8 F0 a
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   
10. void LED_1_Contrary(void);//LED1状态取反
    7 B; }! b! R  E! {. q
11. void LED_2_Contrary(void);//LED2状态取反
    # E! v$ n( m4 I& m, t+ A# J$ I
12. 
    ) {8 A. p+ @9 l( a0 q
13. #endif /* LED_LED_H_ */

复制代码

        key.c
6 y. U3 y& w/ \+ e: |- E0 b

1. #include "led.h"
   
2. 
   $ Z' A  }, b4 W+ C
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   2 ~3 D7 e; }8 x# h7 v
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);
    
11.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    
12. }
    , X. ?) @+ S5 n! [" q
13. void LED_ALL(uint8_t a)//LED1~2整组操作函数（低2位的1/0状态对应2个LED亮灭，最低位对应LED1）
    
14. {
    
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    & ^7 U: h9 N% U  U1 f
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    
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){
    
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    , r! u" G3 d0 [) i
22. }
    . l$ g- k2 ~1 {: i
23. void LED_2_Contrary(void){
    9 m# [. N1 t) c; z* ^2 S. G
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    3 y1 Q1 w" e/ X) }* W5 Z# L9 X
25. }

复制代码

        【3】创建串口驱动程序，主要是复写串口回调功能
, V0 T- Y  K0 n        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能

        usart.h

1. #ifndef INC_USART_H_
   6 E: b+ @$ e5 b: g2 ]3 ^4 R. ~
2. #define INC_USART_H_
   4 b2 h& b  Y& A4 a3 t" T+ X! X
3. 
   ) Q2 V1 Y* n0 {4 H* a/ y, \
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   1 O8 l6 B; A1 D
5. #include <string.h>//用于字符串处理的库
   # K( \% M7 ]' G, e
6. #include "../print/print.h"//用于printf函数串口重映射
   1 [$ P) P) O# l+ Y
7. 
   
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   $ a0 }4 Q" ?4 z+ S4 C8 {0 }
10. 
    
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    
13. 
    
14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    7 d  e  k) m8 l* a4 ?6 R6 J8 {3 f
15. extern uint16_t USART1_RX_STA;//接收状态标记
    " b6 o: e" h% ?3 D$ T
16. extern uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    ; U3 J# R# j' }$ h/ ]
17. 
    
18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
19. extern uint16_t USART2_RX_STA;//接收状态标记
    7 M5 a* A% I3 @: {, _9 ?- }
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    9 G! q) s4 @" H# ^
21. 
    : ]+ }& a) S6 {0 k- M+ U
22. 
    3 P* F5 Q8 F% k
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    0 i4 k* b% \5 m5 c& h
24. 
    # l8 J8 @+ o2 A; o6 a9 X" [) X
25. #endif /* INC_USART_H_ */

复制代码

7 t$ D. k# ]% F4 I. n        usart.c

1. #include "usart.h"
   0 e# k3 E! b' c4 k# Y) S. l
2. 
   2 I. E4 K/ c5 S1 s! h$ ^$ W4 A
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   . s! i7 O$ C) N: I
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    # U1 _# W6 U1 g0 a
11. uint16_t USART1_RX_STA=0;
    4 d- J$ t- m; ?
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    9 c0 R) F1 s3 e, F- `
13. 
    
14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
    , W) F2 U. A/ e) E" d
15. uint16_t USART2_RX_STA=0;
    
16. uint8_t USART2_NewData;
    ; a4 v+ b! {; B  D, G$ W/ W
17. 
    
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    
19. {
    
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    
21.     {
    * k- y; u0 l; R! w& k8 \; l
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    
23.                 if(USART1_NewData==0x0d){//回车标记
    $ I5 q' g6 V8 G* R
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    + Z" o2 n. p* e* j+ J8 @
25.                 }else{
    + l6 h" |0 g# r1 M# @2 h- T  t' Q7 j
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    8 Q, }2 K- h: M5 \
28.                                 USART1_RX_STA++;  //数据长度计数加1
    
29.                         }else{
    7 g/ _' Y3 [! i; D1 Q. L
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    1 f! d& T3 I" k( ~* P+ ?: }
31.                         }
    3 o' G5 G6 t# M+ T! r6 ?
32.         }
    
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为结束符）
    / }3 }( U. w. a* m2 `( w9 |
39.                         USART2_RX_STA|=0x8000;//标记接到回车
    
40.                 }else{
    % e' b3 t# P1 G9 L' x& [' ~
41.                         if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
    ( p# J6 Q& G! Y/ A- u
42.                                 USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组
    5 I- J2 v+ K$ G  c5 u7 }# ?
43.                                 USART2_RX_STA++;  //数据长度计数加1
    ( S4 N3 X7 R: o" @
44.                         }else{
    3 L- c' _# }+ U8 G1 N* @- f. j& [; G
45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
46.                         }
    ( J( _% f  \: s" D8 D3 l6 N# ~
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    
49.         }
    . r5 }; e4 i/ I
50. }

复制代码

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

        bt.h
% H, r+ H0 L1 ^( z7 d: g

1. #ifndef BT_BT_H_
   
2. #define BT_BT_H_
   
3. 
   5 ?, N2 k4 E! I' k% W! f
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   / n- e$ u& p, C) B7 @  i1 q
5. #include "main.h"
   2 g! I6 R$ `! K2 \
6. #include "../usart/usart.h"
   8 D& k: B$ g; Z( r* [
7. #include "../delay/delay.h"
   , ^% I. l8 g, c9 M& t- Q
8. #include <string.h>//用于字符串处理的库
   
9. #include <stdarg.h>
   & X# u% B. k- w: C3 J
10. #include <stdlib.h>
    
11. #include "stdio.h"
    & D* m5 [' ~9 R0 q0 i
12. 
    5 g# c3 H! D& i3 a( c4 c
13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
    + T/ Z* ~# g% L- R  c: l" b2 Q* z
14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
    
15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    % m+ h5 [  g$ F) I* S0 B3 z
16. 
    / s$ y, L6 r/ S+ i( x/ {5 J
17. #endif /* BT_BT_H_ */

复制代码

( _+ @# T: ~" J2 _        bt.c

1. #include "bt.h"
   - i) _( @+ i! }) P2 E  l
2. 
   - o; z! a2 j2 z4 @
3. //蓝牙模块唤醒函数
   + k* j! U8 W% e$ l$ |5 u
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   : T4 i1 O. W% L% _  ^0 r* t
5. void BT_WEEKUP (void)
   
6. {
   ; _6 P! h( d! e4 r( q1 ^/ B4 ?
7.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
   
8.         delay_us(100);
   
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
   
10. }
    
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    : b% ~( f) B% t6 q$ W: Y
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    
13. void BT_printf (char *fmt, ...)
    $ ^) o( ~! b" K7 ~3 n1 V
14. {
    - e5 a- \- {$ ?! P' V5 J
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    5 w0 d! D2 C' [+ o# C
16.     uint16_t i=0;
    ' [) s( _' \6 h! J6 F. o
17.     va_list arg_ptr;
    5 G4 T; }" {/ n  {. X% E" w5 s+ X
18.     va_start(arg_ptr, fmt);
    9 {8 P' y5 W, P( Z
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    
20.     i=strlen(buff);//得出数据长度
    % |7 D$ z6 D. U1 Z" n. _2 E
21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    8 S* D7 \7 C: z/ K
22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    * g2 |3 ~$ O* @: t2 c
23.     va_end(arg_ptr);
    # W. s$ i6 P- q0 @
24. }
    
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

$ r( V6 ]% p. Y+ w# ^% Q) G; f五、编译及测试
        【1】功能调用及编译
        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：
7 a- o( z& }  k4 P

1. /* USER CODE END Header */
   
2. /* Includes ------------------------------------------------------------------*/
   
3. #include "main.h"
     e0 I! x+ p8 h: }
4. 
   
5. /* Private includes ----------------------------------------------------------*/
   5 ^. g1 v% I- }. Z& Y" ~& t8 a
6. /* USER CODE BEGIN Includes */
   3 P" x" d; V1 _: ?" o* s- r5 Q
7. #include "../../ICore/led/led.h"
   1 D. Z1 D) `8 m1 Q
8. #include "../../ICore/key/key.h"
   . o/ [6 {; B! N/ T0 q: L  A
9. #include "../../ICore/delay/delay.h"
   
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    
11. #include "../../ICore/bt/bt.h"
    
12. /* USER CODE END Includes */
    ) }# O1 O) M$ S$ a/ j/ Z) n
13. 
    
14. /* Private typedef -----------------------------------------------------------*/
    
15. /* USER CODE BEGIN PTD */
    
16. 
    
17. /* USER CODE END PTD */
    
18. 
    & K& O; E% \% N
19. /* Private define ------------------------------------------------------------*/
    * y4 _4 m' _, e
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    
22. 
    
23. /* Private macro -------------------------------------------------------------*/
    
24. /* USER CODE BEGIN PM */
    9 p4 F* g8 m& {# _9 @0 F
25. 
    - D) k' X. }7 A% d% M
26. /* USER CODE END PM */
    3 x3 u8 F- d( s
27. 
    0 K* E# @% f& \# T9 r
28. /* Private variables ---------------------------------------------------------*/
    & l% P! ^- ?' V! s6 a
29. UART_HandleTypeDef huart1;
    
30. UART_HandleTypeDef huart2;
    1 o) u: w. i1 \5 f/ C
31. 
    ; R& X4 s3 n1 S9 z& x8 s2 N
32. /* USER CODE BEGIN PV */
    3 Z* q  ^+ ~3 d
33. 
    0 W6 v1 m: B8 |( |( [! C
34. /* USER CODE END PV */
    " A! O3 g( x; O, \$ C* M) N
35. 
    % u" Y" q8 o1 o! I0 Y
36. /* Private function prototypes -----------------------------------------------*/
    4 J6 w) j0 z- q# k
37. void SystemClock_Config(void);
    
38. static void MX_GPIO_Init(void);
    2 u2 e! C1 W1 {: ]. A/ w
39. static void MX_USART1_UART_Init(void);
    
40. static void MX_USART2_UART_Init(void);
    7 ]& k2 A3 d9 ]; Z3 I
41. /* USER CODE BEGIN PFP */
    , X, ?7 f% o. B' E4 P' @) [
42. 
    
43. /* USER CODE END PFP */
    
44. 
    3 p) F; C- G6 n1 e
45. /* Private user code ---------------------------------------------------------*/
    $ H; O" A% G9 I+ S! E7 G, N
46. /* USER CODE BEGIN 0 */
    
47. 
    3 V* }) W* C- i5 z* R5 C/ m
48. /* USER CODE END 0 */
    5 g2 h" C8 p5 y( w
49. 
    
50. /**
    
51.   * @brief  The application entry point.
    0 \2 y! g# V/ T& |  N" I' ~
52.   * @retval int
    
53.   */
    6 {4 Z6 E3 C% c
54. int main(void)
    
55. {
      t$ x4 \: h- X6 e. |! f
56.   /* USER CODE BEGIN 1 */
    9 G1 m3 X, {& Q6 x' X9 b2 V
57. 
    
58.   /* USER CODE END 1 */
    
59. 
    
60.   /* MCU Configuration--------------------------------------------------------*/
    
61. 
    
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
63.   HAL_Init();
    # j6 N# p" q5 M" w  S
64. 
    
65.   /* USER CODE BEGIN Init */
    
66. 
      c5 B: R  j, Q/ L; b
67.   /* USER CODE END Init */
    , Q; @8 J& t/ M. U' O5 _/ B" }% H
68. 
    : |) x. E8 X: S# r* z
69.   /* Configure the system clock */
    9 C5 Z. Y5 j2 n  g; e; i( n
70.   SystemClock_Config();
    
71. 
    6 ^6 ]$ N4 [* X% c5 K- q3 l5 h
72.   /* USER CODE BEGIN SysInit */
    
73. 
    
74.   /* USER CODE END SysInit */
    ; q& C. E" @  B; Q- h- R9 |6 i
75. 
    ( o; U! \" K) d% L
76.   /* Initialize all configured peripherals */
    ) [4 ~  E0 R7 f; `- X! g2 ?
77.   MX_GPIO_Init();
    . F  Y. w0 \; E9 e
78.   MX_USART1_UART_Init();
    - u/ }1 N0 x; a# D  j
79.   MX_USART2_UART_Init();
    
80.   /* USER CODE BEGIN 2 */
    
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    + Q8 ]- G4 G- c  y* R' [- z& e3 Z
82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
    ( ~& B5 k; ~4 t- {; U
83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
    
84.   /* USER CODE END 2 */
    
85. 
    
86.   /* Infinite loop */
    
87.   /* USER CODE BEGIN WHILE */
    
88.   while (1)
    
89.   {
    ( ?9 x: \1 l) x- [0 f, p
90.           //demo 蓝牙02
    $ r/ ~# y; y7 s* G
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    
92.              BT_printf("%c",USART2_RX_STA);
    
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    % U2 G" U/ c! u5 A9 b3 }  o
94.              {
    
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    
97.                                 case 0x41:
    
98.                                         LED_1(1);//LED1控制
    8 P% M/ V) D" F
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
    
100.                                         break;
     : V' I. Y9 q4 C( ]% i' J
101.                                 case 0x44:
     4 m0 i3 l! q! L! l7 n  L
102.                                         LED_1(0);//LED1控制
     
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     
104.                                         break;
     
105.                                 case 0x42:
     ' t7 V$ a8 `: u5 `- L$ d9 z. J
106.                                         LED_2(1);//LED1控制
     
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     6 D) ^: M2 {7 |1 A( g
108.                                         break;
     1 G  ^! ?$ c1 o3 M3 q
109.                                 case 0x45:
     
110.                                         LED_2(0);//LED1控制
     
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     
112.                                         break;
     $ O3 N9 T9 m' }, S2 `! u
113.                                 case 0x43:
     
114.                                         LED_1(0);//LED1控制
     
115.                                         LED_2(0);//LED1控制
     ! x1 K; K) @) _2 E- V
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     
117.                                         break;
     
118.                                 case 0x46:
     & j. x6 D' y) K. z: A& u2 q9 J
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     , H3 H+ z: R4 L+ y! \# H
120.                                         HAL_Delay(1000);//延时
     3 {; a1 ^+ J0 ~+ d4 s$ {. u
121.                                         NVIC_SystemReset();//系统软件复位函数
     ( t9 I' f1 w: j0 Z, ?* Z
122.                                         break;
     
123.                                 default:
     
124.                                         //冗余语句
     5 Y  {  t( y2 c& o
125.                                         break;
     ) z3 }+ [# ~' t
126.                           }
     , Q2 p. @. O; t
127.                  }
     
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     7 s) s! i7 q$ @. H; t
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
     2 f* m) V# C$ h  b
130.       }
     9 k8 ~# C( u/ a$ i4 i
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     . f6 }& q: c7 j- z) c: h2 h
132.       if(USART1_RX_STA&0xC000){//结束标记
     
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     % B, [' q- E! @6 y5 k
134.               USART1_RX_STA=0;//接收重新开始
     : |" z/ S' H: @4 [6 K
135.               HAL_Delay(100);//等待
     5 F: m, y* E, L7 A( O
136.       }
     
137.           if(KEY_1())//按下KEY1判断
     
138.           {
     7 h3 _) ~* O) ^: i2 i: r1 }* I
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
140.                   LED_2(0);//LED2控制
     & }+ f( t) X, Q% p. u% V( M  ^2 d
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     : k- R3 e; m( }' i( D+ |
142.           }
     
143.           if(KEY_2())//按下KEY2判断
     # F+ n+ _: b' p8 X* o: n2 T4 V) ^
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     1 U  [8 G9 ]; y6 ^+ g4 H3 D
146.                   LED_2(1);//LED2控制
     3 n7 Q% K4 A) D5 S4 w
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     7 T2 a* H& A& y, p. i
148.           }
     
149.     /* USER CODE END WHILE */
     
150. 
     # {% R3 m/ T3 ?" B+ J6 ]$ I* p
151.     /* USER CODE BEGIN 3 */
     
152.   }
     
153.   /* USER CODE END 3 */
     # ~8 j) T9 [- a  z  C
154. }

复制代码

# W7 ~- G+ c( ?9 _2 g. R       2）设置编译输出支持，右键工程进入项目属性设置页面：


, u# v2 w% A8 w* G4 x' y) w8 ~
          3）点击编译按钮，完成编译（整个工程需要源码修改或添加的源文件如下）：
& r/ v1 N0 t) a6 s
5 U, @  ^5 ?3 E) p% k9 o* ~
, d- \2 P9 @1 ~. Z) h( l. @; L7 W- H
        【2】程序测试
$ \2 U+ j, X' n0 E6 V        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
& y% `, W' p" V/ z        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
( T7 e8 c  S+ {. d* Q        蓝牙调试器工具，本文用的是1.9安卓版本。




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

; {* I& |6 ~3 d. N" }+ H

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

" ?+ T! P% d4 `) q3 N# }0 n
- v3 y: \7 E+ y$ d2 `/ |
+ ^! c5 v. @9 B5 H+ q        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：
6 t( {) T$ w3 D1 t& l+ ~

1. if(KEY_1())//按下KEY1判断
   
2.           {
   ( K9 A% `/ w9 V5 @8 G1 c- g
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   
4.                   LED_2(0);//LED2控制
   
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   : V& o# `% Z6 I) E
6.           }

复制代码

0 Y& r4 e( i3 U1 D  N/ V6 f        串口发送数据：



& [& O. l, P+ d- w! |7 a
        可以进入按钮控制页面进行指令定制设置

& F/ X3 B1 C$ ^% V) A
$ B: }5 o& f0 j) U0 b7 j/ b% E
         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
: ?1 ^* x% {9 B2 d3 S: }————————————————
( S% ~  d( I% N- f6 ?版权声明：py_free-物联智能
$ }% A+ |5 ^9 X7 o& H# W. ~如有侵权请联系删除
: h' U) V- K, N& a
. E& ?: M4 {6 F
. G7 R5 D2 v0 s5 W9 i