一、蓝牙通信技术
, u2 ~2 M% m. ]* C$ _( H' Y  O; \4 h        蓝牙技术是一种点对点点对面的网络构架，他可以在限制的范围内以很快的速度传输网络数据，在物联网应用中，支持网状网络的物联网短距离无线通信。目前它还被广泛用于智能可穿戴设备、智能门锁、智能医疗设备、智能照明设备、智能家电等消费电子、工业采集、汽车电子、智能建筑等所有的物联网智能产品中。
8 V4 Y1 }7 i7 {' O3 ~+ X4 |$ f
. A+ g% m( N2 g7 J, d        蓝牙是无线个人局域网，最初由爱立信制作，后来由蓝牙技术联盟制定了技术标准。蓝牙产品包括小型蓝牙模块，以及支持连接的蓝牙无线电和软件。 如果两台蓝牙设备想相互交流，则需要进行配对，一台设备将成为主设备，所有其他设备都将成为从设备。 通信时，主站侧需要进行检索并开始配对，如果构建链成功，则双方需要能够发送接收数据。在通信状态下，主侧和从侧的设备都开始切断，可以切断蓝牙链接。蓝牙通信本质上就是无线电传输技术，蓝牙的工作波段为2400–2483.5MHz（包括防护频带）。这是全球范围内无需取得执照（但并非无管制的）的工业、科学和医疗用（ISM）波段的 2.4 GHz 短距离无线电频段。

2 @4 v* T$ G+ X1 s- {( O
9 R9 B( E4 k) o" O/ J# `/ `二、MCU及蓝牙模块
        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块，相关引脚如下：

# f5 l* G1 ?) R. }% x/ o" u! i        MCU引脚设定：PA9、PA10作为USART1引脚，用于下载程序、调试显示，PA2、PA3作为USART2引脚，并与蓝牙模块进行通信，PA8作为GPIO_OUTPUT模式，用来控制蓝牙模块上的PWRC。
/ P, t# r1 P/ m1 B$ m
% h4 n' M8 a7 \3 z

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

        TICC2541 芯片 引脚：
" _- B1 F5 ^0 I; c: M+ k
* Q% o: d" W! k

$ ^1 ]: C( v* n) k         引脚功能定义，在使用串口发送命令时，请将模块的 PWRC 引脚接地，并接上模块的电源（VCC、GND），电源电压为3~ 3.3V：
3 x, q' v5 @+ U5 Y
- N) t; n! v) o7 G' r5 i

         以及本文用到两个AT指令：



三、cubeMX配置MCU及蓝牙接口
( `+ t8 h0 ~: e9 I: z        本工程设计功能如下：
- e' D' T/ I9 s
        MCU（STM32F103C8T6）的引脚PA2、PA3的与蓝牙模块（TICC2541 ）的11、12引脚连接，实现数据通信；MCU的PA8引脚与蓝牙模块的22引脚连接实现，实现蓝牙模块唤醒。
( M$ t8 ]8 Z0 b
) U5 j; L) O; N        通信逻辑：电脑（com4）<->(Usart1)MCU(Usart2)<->蓝牙模块->手机（蓝牙调试器，需要开启手机蓝牙功能）。

        功能：
        按键功能，用于按键时向蓝牙模块发送AT指令；
        LED功能，用于接收蓝牙模块数据时做出闪灯响应；
: O4 g9 d  G) s# s        蓝牙功能，接收来自MCU端的串口通信，接收手机端的无线传输（即蓝牙通信）；
- y( T" k) {2 i: E( g& t        串口调试功能，MCU执行程序可以向Usart1发送信息到电脑端，既可实现日志输出，也可以实现指令转发到蓝牙模块。
) c0 F" n" B7 X+ O        【1】创建工程
        1）新建stm32工程，选择芯片STM32F103C8T6

/ Y: s5 V1 R+ B* p1 a
5 {" J! Q$ B' I
         2）为工程命名完成创建

' z; j, l7 T2 [! N) D( n7 w, I

8 l. d2 U) i  ?2 t* V3 c. w/ F         【2】CubeMX配置
/ {/ W+ t3 [7 E- U* _$ r        1）开启sys mode接口
4 ]7 z- j. D% s- X
7 a" N9 _' p; z& R; u$ L) f0 ^+ Z
( I2 e# V) X; V5 u
         2）开启RCC
, f4 v: }) ?7 @9 h4 |7 f
. Q, U( J" S' ~$ I! |

% z: v: Z( q7 c         3）开启USART1（下载、调试）、USART2（连接蓝牙模块）。



         4）开启串口USART1、USART2中断功能
4 G+ i+ T( ~* a


         5）串口引脚参数配置

+ U- }, D$ u5 ^! N

         6）蓝牙测试辅助接口及按键、LED灯GPIO引脚添加：



        7）系统 时钟配置，直接拉满STM32F103C8T6能支持到的72MHz。
: m* P$ c" d$ N3 o5 q
5 p6 `/ m, c& `. W% I8 k8 S

' M$ g7 [! z2 S          8）本工程配置页面保持默认，没有为每个外围设备驱动创建独立源文件，点击保持或生成代码按钮输出代码。



$ I8 B- [6 U$ G9 j3 N+ R* i
3 V  B. v/ e, U: h/ s) y4 Y% s 四、代码设计
7 e/ g1 U+ u# [/ I. a; a        【1】首先创建usart1接口的调试输出支持
        1）禁用syscalls.c，右键选择该文件进入属性页面设置。
. N% {" C) Z1 t5 J5 k
7 w9 I9 z8 y8 ]/ G( |

* D* Z7 w" I$ m- {1 D, K" y         2）在工程目录下创建源码目录ICore，添加文件夹print及print.h/print.c，实现对系统printf函数的映射到usart1输出显示功能。
& j3 j( R  @0 R" j% H9 F+ N  D9 `! |
        print.h

1. #ifndef INC_RETARGET_H_
   
2. #define INC_RETARGET_H_
   
3. 
   
4. #include "stm32f1xx_hal.h"
   : ]( E4 v' G3 m: L7 I8 b: J- y
5. #include "stdio.h"//用于printf函数串口重映射
   
6. #include <sys/stat.h>
   
7. 
   - ?( W. P4 M9 [" {2 A$ N* k# l- e
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   
9. 
   , w5 _% }$ k, m8 z  \  R5 P
10. int _isatty(int fd);
    , I, K* D& B8 h! }* T
11. int _write(int fd, char* ptr, int len);
    
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. 
    
17. #endif /* INC_RETARGET_H_ */

复制代码

        print.c
9 A0 o# o* h7 k8 g1 t

1. #include <_ansi.h>
   
2. #include <_syslist.h>
   
3. #include <errno.h>
   / L& ~$ D9 [3 f5 z, o! o% M. S/ y
4. #include <sys/time.h>
   ( K9 x% J2 O, S
5. #include <sys/times.h>
   
6. #include <limits.h>
   & S5 O6 z* H  i! ?% D3 W
7. #include <signal.h>
   
8. #include <stdint.h>
   
9. #include <stdio.h>
   & V, _/ d: q, S" Y! ?0 a
10. 
    
11. #include "print.h"
    5 ?7 k5 Q1 h" A/ J$ P: ?
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    - N( d  [9 {; x! s
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    7 b4 N( g6 t2 L( f  H* ?$ U
16. #define STDERR_FILENO 2
    
17. 
    
18. UART_HandleTypeDef *gHuart;
    * p. {; t+ }6 ~* P0 |2 j2 v& ^
19. 
    
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    - `4 _- Y; G; @, F$ r, I
21.   gHuart = huart;
    
22.   /* Disable I/O buffering for STDOUT  stream, so that
    1 D& Y% Z  ]- o
23.    * chars are sent out as soon as they are  printed. */
    
24.   setvbuf(stdout, NULL, _IONBF, 0);
    
25. }
    6 N; R7 U- ]4 v" ?; B7 R1 K: V
26. int _isatty(int fd) {
    
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    
29.   errno = EBADF;
    
30.   return 0;
    
31. }
    - m1 E$ |, o! k# n5 w6 z( T
32. int _write(int fd, char* ptr, int len) {
    % I& V0 P0 D" W/ O" z  G/ y% n
33.   HAL_StatusTypeDef hstatus;
    
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    6 s% M& o" o5 w+ I' a) Y. r
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    
36.     if (hstatus == HAL_OK)
    ( o0 ?* T" k1 }5 J0 @9 k' h5 M9 L5 ^
37.       return len;
      F( l) a/ x. y
38.     else
    . K9 `& K5 u0 Y6 D; l/ |6 Z) E5 \8 f
39.       return EIO;
    
40.   }
    7 i, A3 S" k+ V" n( G3 I) i
41.   errno = EBADF;
    2 j) t, U8 j% m5 J: c  v* t! t4 B
42.   return -1;
    
43. }
    & l7 {  ^- ~) w( N8 U
44. int _close(int fd) {
    
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
46.     return 0;
    
47.   errno = EBADF;
    
48.   return -1;
    % w5 j7 r3 M  u* l7 K4 F( E  l
49. }
    
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    & i5 T2 @' z; H$ a2 S8 B5 M& t; K
52.   (void) ptr;
    . r. J! R" ]" w' z0 S+ j/ W+ [
53.   (void) dir;
    ( U% k3 S8 M. L3 j
54.   errno = EBADF;
    8 `+ Y$ r5 l" Y: M8 c. I" E+ |" O5 [
55.   return -1;
    3 o$ ^/ z1 M, G4 g6 l0 }2 p+ u
56. }
    6 X; h6 T6 x5 [
57. int _read(int fd, char* ptr, int len) {
    
58.   HAL_StatusTypeDef hstatus;
    2 y) x5 R7 O% `' R4 U$ {
59.   if (fd == STDIN_FILENO) {
    8 |. t8 R, |1 U. Z0 i" j
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    
62.       return 1;
    1 W9 N  Z' }3 ~/ Y+ k9 P# [% h$ [
63.     else
    
64.       return EIO;
    6 l5 B; P: k4 L
65.   }
    / a, B7 D  I2 k8 t4 h
66.   errno = EBADF;
    
67.   return -1;
    # W+ p& p$ X  h/ |4 z
68. }
    2 u0 v: y- R! Y  z5 R* r
69. int _fstat(int fd, struct stat* st) {
    3 r7 \9 i4 V, K$ x4 d5 w
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    - N/ Y/ l0 K( [% [: r# X
71.     st->st_mode = S_IFCHR;
    + {6 r/ Z" i' m+ L4 {
72.     return 0;
    ; w+ \8 D& G6 B5 V9 O
73.   }
    . Y8 Q+ x/ B- D
74.   errno = EBADF;
    ( Y" H) H& k, p9 m
75.   return 0;
    " H" U7 f/ R" I  I9 X  D/ Q
76. }
    : l4 k4 ]' v0 s# O
77. 
    
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

; d( V+ q& e' Y  C' ^9 M+ a# `  o        【2】创建按键驱动、LED驱动、延时函数功能的支持
         1）在ICore添加delay目录，并添加delay.h/delay.c源文件
/ K) N% H# H: A        delay.h
6 o3 h8 y# M; D- D0 k6 N5 }

1. #ifndef DELAY_DELAY_H_
   
2. #define DELAY_DELAY_H_
   
3. 
   , U& z4 p1 k; c2 L/ s, a+ @# [
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   # y/ a% Q, [' u
5. void delay_us(uint32_t us); //C文件中的函数声明
   7 i3 {$ T, D0 {: i" h. Z: v
6. 
   
7. #endif /* DELAY_DELAY_H_ */

复制代码

1 O$ e5 F( f8 f1 n! N        delay.c

1. #include "delay.h"
   
2. 
   
3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
   
4. {
   
5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
   
6.     while (delay--); //循环delay次，达到1微秒延时
   9 S& D6 o$ s( e: A- O
7. }

复制代码

0 L% n$ s& e# u& g' q0 ~        2）在ICore添加key目录，并添加key.h/key.c源文件

' V* O4 a/ E9 B1 S6 f- N3 D        key.h
8 l( }% Q/ A3 n+ _* b& [6 Q

1. #ifndef KEY_KEY_H_
   
2. #define KEY_KEY_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   7 b9 V0 E& N6 D. z
6. #include "../delay/delay.h"
   0 ]& G$ q* C- [# _' b8 P
7. 
   
8. uint8_t KEY_1(void);//按键1
   
9. uint8_t KEY_2(void);//按键2
   
10. 
    2 ^. x) G' g5 J+ _9 T. g
11. #endif /* KEY_KEY_H_ */

复制代码

, o' K: H$ w& W6 w        key.c
: y. g. a8 ^$ X3 V, Z

1. #include "key.h"
   1 s4 e4 i' |/ U% T# g
2. 
   9 S. H' X( r  |7 \4 i7 j
3. uint8_t KEY_1(void)
   
4. {
   % I4 A1 ]/ F. C8 s) a( F4 A
5.         uint8_t a;
   5 _0 E- S5 Z0 E' z+ e
6.         a=0;//如果未进入按键处理，则返回0
   , k0 K. y$ A0 Y% l& I) i4 m
7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
   + m2 V5 j$ `& g  U8 c* l
8. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
   
9.                 delay_us(20000);//延时去抖动
   ! ]- N6 k0 L* O
10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    , [: k9 W% L  e1 m4 p" k
11.                         a=1;//进入按键处理，返回1
    
12.                 }
    
13.         }
    
14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    2 _$ R& k& v% e- C  O
15.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    
16.         return a;
    
17. }
    0 q+ z9 Z9 L2 @1 Y8 ^9 ^- N. n
18. 
    
19. uint8_t KEY_2(void)
    3 l& z( H) d3 {& |
20. {
    5 b4 f  S6 `! v- I
21.         uint8_t a;
    
22.         a=0;//如果未进入按键处理，则返回0
    
23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
24. //                HAL_Delay(20);//延时去抖动（外部中断回调函数调用时不能使用系统自带的延时函数）
    * p/ q/ }7 T! `' Z' h' I& a6 }
25.                 delay_us(20000);//延时去抖动
    % T# V- C& ?1 U" `7 ]
26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    & E; c1 e! z6 Q% ~0 j, H
27.                         a=1;//进入按键处理，返回1
    
28.                 }
    0 Y1 b, P3 D; R. W% T! v
29.         }
    2 ?: E6 |% t* U- `
30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    9 l" ]' O& H9 i% r& Q$ L; N
31.         delay_us(20000);//延时去抖动（避开按键放开时的抖动）
    4 @4 R! ?4 e5 e% P4 U
32.         return a;
    
33. }

复制代码

        3）在ICore添加led目录，并添加led.h/led.c源文件
( R) @( u- g. X' i. D7 W& G0 T! m
) h3 o' @& R7 Y% F! t        key.h

1. #ifndef LED_LED_H_
   / h: W5 K9 L3 j; F  F+ M, M7 ?
2. #define LED_LED_H_
   
3. 
   
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   ) f) t; {# q& L  h1 P3 ~( N& w
5. #include "main.h" //IO定义与初始化函数在main.c文件中，必须引用
   / D4 f' y( O) y4 o7 H3 P, s# v
6. 
   
7. void LED_1(uint8_t a);//LED1独立控制函数（0为熄灭，其他值为点亮）
   " l- u) w; d0 i# C
8. void LED_2(uint8_t a);//LED2独立控制函数（0为熄灭，其他值为点亮）
   # q" Q% H) y' @. l5 ?( |
9. void LED_ALL(uint8_t a);//LED1~4整组操作函数（低4位的1/0状态对应4个LED亮灭，最低位对应LED1）
   4 s; V6 O1 `" e2 F' b8 _# O
10. void LED_1_Contrary(void);//LED1状态取反
    8 N3 O. s. |3 g0 o' i  z! ~" g5 a& t
11. void LED_2_Contrary(void);//LED2状态取反
    
12. 
    ) d1 U$ [0 [8 k8 P; n* J0 o
13. #endif /* LED_LED_H_ */

复制代码

        key.c

1. #include "led.h"
   ( M4 g2 U: F( y; F- f1 \8 m
2. 
   : E( \$ ^9 K$ ?9 A9 K, y+ O% d
3. void LED_1(uint8_t a)//LED1独立控制函数（0为熄灭，其他值为点亮）
   
4. {
   ' S, }5 q7 |7 I9 X3 Q. ]: B
5.         if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
   
6.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
   / ]0 h- s. }6 P/ @; x  ~
7. }
   ' e; ~& K+ ~% |  s" ~# Y
8. void LED_2(uint8_t a)//LED2独立控制函数（0为熄灭，其他值为点亮）
   # x( r2 |2 |: r" g/ I
9. {
   # |- g, S5 q3 L! d: _3 |- \
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）
    . e+ z3 n$ A# f4 Y
14. {
    
15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    
16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    + W4 Z+ L; ^, E2 J9 Y$ {
17.         if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    : D' J# D, U+ N6 W3 y# u6 F- u: L
18.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
      q3 S3 @& U2 [/ \$ Y$ w, I/ {; ?
19. }
    . I: {3 D( P/ W* w  f
20. void LED_1_Contrary(void){
    
21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));
    ! Y0 _/ T8 c: R
22. }
    
23. void LED_2_Contrary(void){
    % j* R7 V. X: _; p
24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));
    
25. }

复制代码

; V1 [0 i$ U% w8 J' `        【3】创建串口驱动程序，主要是复写串口回调功能
        1）在ICore添加usart目录，并添加usart.h/usart.c源文件，实现串口驱动功能
1 i  m1 z( t$ B# T6 @
        usart.h
& t1 |. u6 D. p) T- X. H: @

1. #ifndef INC_USART_H_
   + S& E3 k$ Z, s, X) q
2. #define INC_USART_H_
   
3. 
   ; k" C6 d! z5 ^5 _4 n* \. \
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   / s' k' J* I3 j' L2 X7 _/ @
7. 
   
8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
   
9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体
   
10. 
    * q' I' W- _. z
11. #define USART1_REC_LEN  200//定义USART1最大接收字节数
    
12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    # a! o) i9 k$ U+ A
13. 
    ) r- g' F1 S, {4 A' Y1 x' ?6 Y
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个字节数据的缓存
    8 e- Y3 F  k; \- o& G
17. 
    / w/ c. B- N- Z- A; {5 N
18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    ( T! e+ k' f' a" D. V6 P8 P
19. extern uint16_t USART2_RX_STA;//接收状态标记
    # H2 D* a. `) ]4 y; w0 x. t4 B' n2 ]
20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存
    
21. 
    9 M5 M/ D4 q# Q: X
22. 
    
23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    6 \; A9 P: E* |& n6 K9 ?' m
24. 
    
25. #endif /* INC_USART_H_ */

复制代码

        usart.c

1. #include "usart.h"
   . G* G1 A2 E2 p4 F: a: m
2. 
   
3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
   
4. /*
   % g, O+ Y3 c) m4 c  f: L5 ?. M
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   / D, u8 s; B3 c$ B0 t
10. */
    ( w, L8 x4 r  ^) O- _* `" E4 S
11. uint16_t USART1_RX_STA=0;
    4 U/ _9 }" B6 F! {0 |3 m# i' g
12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    - G: m% K0 F: Z# z( P; ^
14. uint8_t USART2_RX_BUF[USART2_REC_LEN];
    
15. uint16_t USART2_RX_STA=0;
    
16. uint8_t USART2_NewData;
    " e$ W9 t' s3 W
17. 
    
18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    ; {( g# J2 m( l  e! p0 \3 k2 s! v
19. {
    
20.         if(huart ==&huart1)//判断中断来源（串口1：USB转串口）
    
21.     {
    . B5 A1 z" j% }. U; @8 R$ o$ O
22. //                printf("%c",USART1_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    
23.                 if(USART1_NewData==0x0d){//回车标记
    
24.                         USART1_RX_STA|=0x8000;//标记接到回车
    
25.                 }else{
    
26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    
27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
    ! q( Z( G+ G6 V" `0 l3 i0 h8 h" U5 j
28.                                 USART1_RX_STA++;  //数据长度计数加1
    
29.                         }else{
    
30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    9 T8 O& }3 A+ B8 P( w) |
31.                         }
    # c3 M1 A: F% k, X! ]+ t% z/ H
32.         }
    : B; R! f- U' p/ `, q
33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断
    
34.     }
    ! C: L+ l; E8 O/ M  n
35.         if(huart ==&huart2)//判断中断来源（串口2：BT模块）
    2 g( }/ G4 ?! ^' {( q! u0 s
36.         {
    1 A4 F/ t  v# Z. c0 z6 f6 d7 S! }
37. //                printf("%c",USART2_NewData); //测试用，把收到的数据以 a符号变量 发送回电脑
    ( A# k' X2 F- w( o: O, [. T
38.                 if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,（手机APP“蓝牙调试器”回复数据以0x5A为结束符）
    ' Z5 J4 a, d& m2 b+ R
39.                         USART2_RX_STA|=0x8000;//标记接到回车
    / d  U3 Z% R: Z1 j3 p( q' v
40.                 }else{
    
41.                         if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
    * `- |6 R7 f7 i( s& r' ^' H4 }) L5 Z" J
42.                                 USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组
    
43.                                 USART2_RX_STA++;  //数据长度计数加1
    7 R2 U# @8 W% f, p  z( s6 D* a6 P9 `
44.                         }else{
    $ l" t7 B' {& z& e$ s. \: J/ @
45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
46.                         }
    
47.         }
    
48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断
    0 m  Q+ o$ b# R7 ?
49.         }
    
50. }

复制代码

        【4】创建蓝牙驱动
4 T* g: s8 s5 @+ p+ B/ N$ P# a2 i        该驱动主要实现通过usart2向蓝牙模块写入数据，（读取数据主要通过串口usart2回调，在usart.c中实现）。在ICore添加bt目录，并添加bt.h/bt.c源文件，实现蓝牙驱动功能
% y# g, h# b+ D% R3 T
" N7 o" W+ d3 N% N3 C4 n        bt.h

1. #ifndef BT_BT_H_
   
2. #define BT_BT_H_
   
3. 
   . a/ S7 e: ?  C6 p: y, i
4. #include "stm32f1xx_hal.h" //HAL库文件声明
   * B2 h2 j' a9 [' i% r' j
5. #include "main.h"
   
6. #include "../usart/usart.h"
   5 s2 L" l3 W( p1 l+ b5 h4 R. t' f
7. #include "../delay/delay.h"
   ; t+ L6 j9 ?1 g/ k6 y9 E8 L
8. #include <string.h>//用于字符串处理的库
   
9. #include <stdarg.h>
   
10. #include <stdlib.h>
    
11. #include "stdio.h"
    4 m, A) R6 p4 Q7 K* T0 G$ ]
12. 
    , m% J3 A/ j- N- j1 L
13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
    ( H6 S" w9 z" M/ a5 P% o  N
14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
    
15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    
16. 
    5 J' ~. d$ F7 j# p" [
17. #endif /* BT_BT_H_ */

复制代码

        bt.c
1 G* y" F; ?; J: e3 j

1. #include "bt.h"
   & b$ ]. B# I% R) @5 Z: W
2. 
   
3. //蓝牙模块唤醒函数
   
4. //对蓝牙模块上的PWRC（P00）接口一个低电平脉冲，如不使用睡眠模式可忽略此函数
   0 U+ J  e4 {- C8 I  C
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);
   
9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
   & s, d4 [( s5 g. K; m  P5 H
10. }
    9 _) [6 w' b$ k! Y1 ]2 t3 A" {
11. //蓝牙模块通信，使用UART2，这是BT蓝牙的printf函数
    6 C" t5 Z) D9 A
12. //调用方法：BT_printf("123"); //向UART2发送字符123
    9 k9 U% z8 o2 J0 \9 Z0 [
13. void BT_printf (char *fmt, ...)
    
14. {
    
15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
16.     uint16_t i=0;
    9 d+ L; @! Z5 a7 ^+ z
17.     va_list arg_ptr;
    % X; {$ Y7 E% b( Y. ~; d; Z' ^! b
18.     va_start(arg_ptr, fmt);
    " m$ u. l$ d$ g& G9 ?
19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    
20.     i=strlen(buff);//得出数据长度
    
21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
      o; |  v1 t( @
22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    
23.     va_end(arg_ptr);
    
24. }
    
25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在USART.C文件中。

复制代码

8 ^0 h' C+ z8 ^五、编译及测试
        【1】功能调用及编译
        1）在main.c文件中进行蓝牙功能调用实现，部分源码如下：

1. /* USER CODE END Header */
   * s, K1 C8 Q3 j; A4 H! l
2. /* Includes ------------------------------------------------------------------*/
   
3. #include "main.h"
   
4. 
   5 n$ d3 H0 q9 e, a' c* R  n. T
5. /* Private includes ----------------------------------------------------------*/
   2 E7 k- z6 z: E  J7 k. F2 J
6. /* USER CODE BEGIN Includes */
   
7. #include "../../ICore/led/led.h"
   3 v) i( m" H2 W: |' h7 ?$ l
8. #include "../../ICore/key/key.h"
   $ m% f9 |8 v: y# a* H. B
9. #include "../../ICore/delay/delay.h"
   
10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    ! S4 j; a( v+ N- p& }
11. #include "../../ICore/bt/bt.h"
    
12. /* USER CODE END Includes */
    
13. 
    : N5 d3 f. |% n  r1 O
14. /* Private typedef -----------------------------------------------------------*/
    
15. /* USER CODE BEGIN PTD */
    , Y$ [3 i7 R* G4 b' Q9 T" w
16. 
    
17. /* USER CODE END PTD */
    " C# h6 X7 C, u! F# a
18. 
    
19. /* Private define ------------------------------------------------------------*/
    
20. /* USER CODE BEGIN PD */
    
21. /* USER CODE END PD */
    ; y) i6 I, r+ E( L9 A4 Z. ?
22. 
    ! g3 Y9 \! c* x/ ]% U+ y7 _
23. /* Private macro -------------------------------------------------------------*/
    
24. /* USER CODE BEGIN PM */
    
25. 
    % {* p6 _: {( J" ~
26. /* USER CODE END PM */
    ' t: y6 n- b. j5 v* c
27. 
      j5 W5 |4 n; D( Z" {! h! [
28. /* Private variables ---------------------------------------------------------*/
    
29. UART_HandleTypeDef huart1;
    
30. UART_HandleTypeDef huart2;
    
31. 
    
32. /* USER CODE BEGIN PV */
    
33. 
    ( c+ D. b  G. c2 x9 Q! o' J8 |
34. /* USER CODE END PV */
    
35. 
    : t- i+ K& v! U9 \1 N. O
36. /* Private function prototypes -----------------------------------------------*/
    
37. void SystemClock_Config(void);
    , k+ p# B" X4 d) J
38. static void MX_GPIO_Init(void);
    
39. static void MX_USART1_UART_Init(void);
    0 }' r& M+ I( a6 }" i2 J
40. static void MX_USART2_UART_Init(void);
    ' B" w  P) Q3 y. T/ m$ ]
41. /* USER CODE BEGIN PFP */
    , B; w) }; L- X" P
42. 
    5 s1 m3 _3 ^* Q
43. /* USER CODE END PFP */
    
44. 
    ) g: @3 h( ]3 C* G- I
45. /* Private user code ---------------------------------------------------------*/
    
46. /* USER CODE BEGIN 0 */
    - ~" W4 Z- s3 \0 e
47. 
    
48. /* USER CODE END 0 */
    
49. 
    
50. /**
    
51.   * @brief  The application entry point.
    3 P" [# s. h& ^  ^
52.   * @retval int
    / o2 ~9 h& U# x0 F9 I+ s- x# n5 |) o, c
53.   */
    
54. int main(void)
    + p) W. U- R7 o2 y( B
55. {
    ( U$ R8 T+ R7 O$ _6 i8 p5 h0 \
56.   /* USER CODE BEGIN 1 */
    ; M/ U  |% W4 U
57. 
    
58.   /* USER CODE END 1 */
    & W# A& V- r) u1 V- Y
59. 
    $ `; u/ r. K+ O8 o# M
60.   /* MCU Configuration--------------------------------------------------------*/
    
61. 
    6 A: H5 s5 P% V- j) {" m
62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    ' @* i4 p' m9 t/ F# p) H( O
63.   HAL_Init();
    
64. 
    . P/ p9 g6 {3 P. t4 ]' b# `
65.   /* USER CODE BEGIN Init */
    
66. 
    
67.   /* USER CODE END Init */
    ; T) h( s8 Y+ m: D. w* K) W
68. 
    
69.   /* Configure the system clock */
    
70.   SystemClock_Config();
    6 S9 i1 U  {8 p1 K) L) Q. w
71. 
    ! e7 o) U$ q1 z9 p! ^
72.   /* USER CODE BEGIN SysInit */
    0 ]1 V- N. P- T) n# {4 C2 p- S5 \
73. 
    
74.   /* USER CODE END SysInit */
    6 s# f) R: J1 o, U3 `
75. 
    : T6 G; r9 P: S2 H4 H
76.   /* Initialize all configured peripherals */
    
77.   MX_GPIO_Init();
    
78.   MX_USART1_UART_Init();
    ( o3 c$ h6 L( {# C$ i* |, @2 _
79.   MX_USART2_UART_Init();
    + h1 q$ n9 u, e5 R  D5 b- e
80.   /* USER CODE BEGIN 2 */
    
81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    ! u* s  x9 }* {# ]/ h& Z
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 */
    5 }0 U- Z2 [* ?5 e7 ^
85. 
    * U4 ~, e$ X: X5 @( v: |
86.   /* Infinite loop */
    : W7 l) j) ]0 X4 {/ z, m
87.   /* USER CODE BEGIN WHILE */
    
88.   while (1)
    
89.   {
    " p# a# f% C* L3 H0 j
90.           //demo 蓝牙02
    
91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位（蓝牙模块BT，使用USART2）
    
92.              BT_printf("%c",USART2_RX_STA);
    6 x2 w6 l$ p2 P$ |
93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个（手机控制程序）
    
94.              {
    
95.                      BT_printf("%c",USART2_RX_BUF[0]);
    
96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    
97.                                 case 0x41:
    
98.                                         LED_1(1);//LED1控制
    4 U# G0 s0 c8 D
99.                                         BT_printf("Relay ON");//返回数据内容，在手机APP上显示
    ) M" _) Q# K8 N- q
100.                                         break;
     ) q$ ]1 r  a; V% N' U7 @
101.                                 case 0x44:
     
102.                                         LED_1(0);//LED1控制
     
103.                                         BT_printf("Relay OFF");//返回数据内容，在手机APP上显示
     
104.                                         break;
     
105.                                 case 0x42:
     4 ?& \. @9 Q/ E2 |* i" k
106.                                         LED_2(1);//LED1控制
     ( o. k) A3 H7 o/ l
107.                                         BT_printf("LED1 ON");//返回数据内容，在手机APP上显示
     
108.                                         break;
     
109.                                 case 0x45:
     
110.                                         LED_2(0);//LED1控制
     
111.                                         BT_printf("LED1 OFF");//返回数据内容，在手机APP上显示
     8 W- c: m/ ^( r3 w
112.                                         break;
     % J# u$ H' ]' ]* ?
113.                                 case 0x43:
     0 Q0 \2 G4 ?/ G, i
114.                                         LED_1(0);//LED1控制
     1 g7 f6 ~( C! q+ w4 ^5 C
115.                                         LED_2(0);//LED1控制
     4 ]9 k- D5 t; x2 h* W$ i& m+ u6 A
116.                                         BT_printf("BEEP");//返回数据内容，在手机APP上显示
     
117.                                         break;
     
118.                                 case 0x46:
     
119.                                         BT_printf("CPU Reset");//返回数据内容，在手机APP上显示
     9 r7 h- F9 K% ?# a- q, I# p! w
120.                                         HAL_Delay(1000);//延时
     
121.                                         NVIC_SystemReset();//系统软件复位函数
     
122.                                         break;
     
123.                                 default:
     
124.                                         //冗余语句
     
125.                                         break;
     * T  l1 {* Q! J7 J9 Z4 u6 Q$ L
126.                           }
     5 X7 w' U4 g! x! e! P) z
127.                  }
     1 v7 q) K0 z4 v* `- a6 c9 S
128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart1
     
129.          USART2_RX_STA=0;//标志位清0，准备下次接收
       Z9 D2 t. p- j
130.       }
     
131.       //接收到电脑发送给(usart1)数据，转身将其发送到给usart2，进而实现送数据给BT模块
     
132.       if(USART1_RX_STA&0xC000){//结束标记
     
133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
     ) V, V& S0 `: U$ l, f# B  z
134.               USART1_RX_STA=0;//接收重新开始
     $ E0 R* _: V# T- e% d, h9 Y
135.               HAL_Delay(100);//等待
     
136.       }
     . `+ M1 ^7 S  W, O) P: v3 d& I
137.           if(KEY_1())//按下KEY1判断
     0 b$ l/ D$ N8 S; `
138.           {
     
139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     : H, X3 S( P1 \5 Q: N; w
140.                   LED_2(0);//LED2控制
     
141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
     
142.           }
     
143.           if(KEY_2())//按下KEY2判断
     * u' a% @& ]! h. x* h- B, a  B
144.           {
     
145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
     
146.                   LED_2(1);//LED2控制
     / d3 T3 E* l3 u& W0 d& i1 |
147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令（断开与手机的连接）
     . P& }1 e( k% C0 m
148.           }
     
149.     /* USER CODE END WHILE */
     + f1 B& m5 t4 F7 p' M! G- d: S6 |
150. 
     
151.     /* USER CODE BEGIN 3 */
     : K0 W! T6 t7 [$ _) }% Z/ r" }
152.   }
     ' R# k/ @% L: ]3 P9 R3 K* p3 ]
153.   /* USER CODE END 3 */
     8 `8 G) Z3 `& |
154. }

复制代码

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



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

! {+ S% e* w5 m3 Z/ C* g/ y; d
% b5 a) r# \, k; K
! |/ u5 I0 m3 d$ `7 \6 I        【2】程序测试
2 |" ^8 a8 c: }# e+ M; x) `, x- H        1）测试过程需要三个工具文件支持，读者可以自网上搜索最新版本或采用其他同功能工具替代测试：
0 L' L* N  |) `0 y. o) J3 s  T        FlyMCU加载工具，将生成的.hex程序文件加载到板子上
        SSCOM5串口工具，连接MCU的USART1，实现调试信息显示及下行指令输入
6 X* X4 y3 f) R( V        蓝牙调试器工具，本文用的是1.9安卓版本。

  E1 A; a9 B, j5 V3 M& C4 i

# i8 u) d+ T3 `
        2）加载程序，选择串口，选择程序(.hex)，点击开始编程按钮：
/ S- T0 e  L* t7 B


9 Q) j4 b$ _* @( f         3）手机打开蓝牙调试器（别忘了开启手机蓝牙功能），进入界面，搜索蓝牙，点击蓝牙边上“+”按钮连接蓝牙模块，采用SSCOM串口工具连接到usart1上，就可以通过蓝牙通信实现手机（蓝牙调试器）与电脑（串口工具）的通信了，在蓝牙调试器发送数据时，十六进制时需要加上“0A”作为结尾，如果十进制发送时，注意加上换行再发送：
0 o1 X. j$ w8 y' v- P: ^/ _1 ~7 f
: J* b. a, `) i( G9 X" D  M/ |( O

7 T! R: ^( U9 A# Q6 y4 J  i* ~8 J        注：本文连接前，点击开发板的按键1更改了蓝牙名称PYFREEBT：
" S7 }: x' S5 x1 b/ P9 Q

1. if(KEY_1())//按下KEY1判断
   
2.           {
   
3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
   
4.                   LED_2(0);//LED2控制
   
5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令（修改模块的广播名为PYFREEBT）
   
6.           }

复制代码

  {4 p2 y. g* d8 ]" B* H; g' }* K0 r        串口发送数据：

9 d, F$ l, i9 S" B2 Q: ?1 K+ \
- l2 N* I7 N" d6 @* \( t$ q
5 k6 {; u* o# r. V
        可以进入按钮控制页面进行指令定制设置
0 G7 b$ f& H5 E/ L& k
. M* b2 M2 k4 I+ v* n! k

, B! |4 F- a4 Z$ O  u4 I* s         至此实现了MCU（STM32F103C8T6）通过蓝牙模块与外界设备进行通信，另外通过AT指令也可以控制蓝牙模块。
8 @- }# J# b+ l+ z( `; f; D" N————————————————
版权声明：py_free-物联智能
如有侵权请联系删除



; Z( i8 j# d6 j7 A# p