你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32CubeIDE物联网应用之蓝牙通信经验分享

[复制链接]
攻城狮Melo 发布时间:2023-4-7 15:54
一、蓝牙通信技术! p$ t! {/ i2 H1 O6 B
        蓝牙技术是一种点对点点对面的网络构架,他可以在限制的范围内以很快的速度传输网络数据,在物联网应用中,支持网状网络的物联网短距离无线通信。目前它还被广泛用于智能可穿戴设备、智能门锁、智能医疗设备、智能照明设备、智能家电等消费电子、工业采集、汽车电子、智能建筑等所有的物联网智能产品中。
% ]( X0 X6 E+ y. d. w5 ^& A8 p
5 J/ j. C  j  Y' ]- e% S( k
        蓝牙是无线个人局域网,最初由爱立信制作,后来由蓝牙技术联盟制定了技术标准。蓝牙产品包括小型蓝牙模块,以及支持连接的蓝牙无线电和软件。 如果两台蓝牙设备想相互交流,则需要进行配对,一台设备将成为主设备,所有其他设备都将成为从设备。 通信时,主站侧需要进行检索并开始配对,如果构建链成功,则双方需要能够发送接收数据。在通信状态下,主侧和从侧的设备都开始切断,可以切断蓝牙链接。蓝牙通信本质上就是无线电传输技术,蓝牙的工作波段为2400–2483.5MHz(包括防护频带)。这是全球范围内无需取得执照(但并非无管制的)的工业、科学和医疗用(ISM)波段的 2.4 GHz 短距离无线电频段。# k+ V6 X- a: \  ?
* x( c" O; d# B4 D$ ?8 g0 D" {

& f. G) g4 S0 o2 n' h9 v二、MCU及蓝牙模块' s8 Q4 j8 r/ G) J! W9 ?# \
        本文采用STM32F103C8T6的芯片及JDY-08 蓝牙透传模块,相关引脚如下:/ r5 @8 l+ |; m' m5 E& i0 G
4 o# r1 E. u2 l4 d$ j# t
        MCU引脚设定:PA9、PA10作为USART1引脚,用于下载程序、调试显示,PA2、PA3作为USART2引脚,并与蓝牙模块进行通信,PA8作为GPIO_OUTPUT模式,用来控制蓝牙模块上的PWRC。
, A" J8 {' `; l- z# B3 v9 c3 I) o9 H$ }& y, N
2d927f8850734dd683cfc95f270f3604.png
/ G1 j9 ^% F4 e/ l
8 |& q% F; H( `, k  }         蓝牙模块为JDY-08 蓝牙透传模块,基于蓝牙 4.0 协议标准,工作频段为 2.4GHZ 范围,调制 方式为 GFSK,最大发射功率为 0db,最大发射距离 80 米,采用 TICC2541 芯片设计,支持用户通过 AT 命令修改设备名、服务 UUID、发射功率、配对密码等指令。
3 x; l4 H" R; ]$ j) I0 A0 {* l: T8 V% S* q! }
        TICC2541 芯片 引脚:, H5 ]8 s7 {( A; x7 [# n5 M
: [( [" W# N* @. }
87b66d3312cc4c23b64182bd2c2496c9.png
! t4 I8 F: m: S( P/ c  A" B
4 ~4 A+ t6 A! C) n6 s) y         引脚功能定义,在使用串口发送命令时,请将模块的 PWRC 引脚接地,并接上模块的电源(VCC、GND),电源电压为3~ 3.3V:
2 \4 c/ ]2 C* g. Y6 W
: `- M* b  n" O! \- T
50c5510d3d8b4234879cc66e8e1a6988.png % d( x7 w5 l& O( I" `7 j! v

% u5 T" `; K' q  M+ @         以及本文用到两个AT指令:
$ T% T! J4 i* M
1 f0 i* x/ B/ u( ^
d5bc46612e09498c922ad506da5679f4.png 8 G6 k. [: c& s/ S$ p

) Z% e1 G5 f* T$ F* m2 e" j$ j 三、cubeMX配置MCU及蓝牙接口
8 p/ i) ?/ h# l" K# M0 l5 n        本工程设计功能如下:- {' j0 e+ w1 L' n
, _* {/ ?& c& C9 H+ n, i8 b" P
        MCU(STM32F103C8T6)的引脚PA2、PA3的与蓝牙模块(TICC2541 )的11、12引脚连接,实现数据通信;MCU的PA8引脚与蓝牙模块的22引脚连接实现,实现蓝牙模块唤醒。. r* L( X2 P4 C# L' f9 q+ B2 ?
6 ~8 K- O4 Z7 H9 a( s+ f
        通信逻辑:电脑(com4)<->(Usart1)MCU(Usart2)<->蓝牙模块->手机(蓝牙调试器,需要开启手机蓝牙功能)。0 {; t" |) K$ [# p$ `! `, s; _
. B" N: q  I' n" F* i+ d: [' x: w
        功能:
8 f* {7 S+ z- v        按键功能,用于按键时向蓝牙模块发送AT指令;& z8 A3 s& R4 {* v* I
        LED功能,用于接收蓝牙模块数据时做出闪灯响应;% b$ d( j0 g. w! b
        蓝牙功能,接收来自MCU端的串口通信,接收手机端的无线传输(即蓝牙通信);! ^9 k" g0 o; a5 i
        串口调试功能,MCU执行程序可以向Usart1发送信息到电脑端,既可实现日志输出,也可以实现指令转发到蓝牙模块。
. b1 m0 Q% u$ H* V2 [
        【1】创建工程, G9 _' f/ G: s
        1)新建stm32工程,选择芯片STM32F103C8T6
9 u& ~( k3 J, w$ b2 m+ H: d
# Q. j/ m+ Y' I' x1 `
a4d9946142d542f3a8ade81b66e0a552.png
! n* a" N( U5 @& Z3 u, R1 A

' s2 \6 C0 L9 K, D9 a4 o7 N  Y         2)为工程命名完成创建+ d- Z$ I) s: S

# k5 \- @0 L" W7 T
8177bd2fea6b478e8c172a4b4604aa43.png 5 D$ s: M  I7 F. L4 ^
$ B8 w9 |3 z) i/ N
         【2】CubeMX配置
0 M' y' O) z! `; U5 y8 b0 P# _        1)开启sys mode接口
- {7 t6 \" b) [5 B1 h2 R1 k! X$ ^" y2 E( V5 V6 x' N
6945e8635a7a466b83c22611ad53d9c5.png # q7 ^& t% m9 E. s: N7 e
2 ~6 F/ L9 ?/ e9 c' ?
         2)开启RCC
# S" h: U( Q% a. U' C! V
  f+ s1 p& y7 W8 I' e! W7 h1 z
eb9677e954f14340b91608f89a899e85.png 9 `, W! \1 b2 X3 f1 q, u: o# B( u

8 e0 t' l3 d' @  s. F         3)开启USART1(下载、调试)、USART2(连接蓝牙模块)。$ Y$ }; o& B) b* l5 R, i5 }0 j

' |" [( _  l6 k" _
8a56a450ae704a66afcd75f588cd2e64.png $ s% z4 d6 V; u0 x8 C0 `+ D& D' f
" k) X1 W  \$ i. H
         4)开启串口USART1、USART2中断功能
8 O4 }9 q" A+ C8 c
) c; J- _4 O4 U9 `! e
1a51fe61e16c48fd95cd3c1841c6cf9f.png
4 @$ B0 ~2 \; ~- ^6 V7 _! c8 V8 G& V( c  y6 I( H2 U
         5)串口引脚参数配置& F9 }# F- B" T# g% v* `
: Y. |7 O4 T; l
3c5015317b1643e1b7e9a55510e02cfc.png 7 b% m0 d" I4 e$ h2 z, B8 j9 t
5 ^* @+ ]$ y4 g; r+ Z0 I
         6)蓝牙测试辅助接口及按键、LED灯GPIO引脚添加:
: }; B+ T: E) }" Q4 G; b# ~- J
6 l- k' o7 r. H6 U7 N0 C* `0 @
70a978fd9ca34aa18d434351ceb7bb5b.png
, Y1 c2 Z8 o6 f) B4 y! ~! O
7 @# V4 v- |/ b9 A+ `1 G7 C        7)系统 时钟配置,直接拉满STM32F103C8T6能支持到的72MHz。
2 g4 c* C4 ^# J6 v6 Z% u
8 [+ N  h+ S1 o4 ^. [, w
cd5e618b97e54ef1886818cc2b4c1956.png
/ ?! L- c; t! B0 }/ C

5 K; u: u4 j! a2 K+ a; f" P          8)本工程配置页面保持默认,没有为每个外围设备驱动创建独立源文件,点击保持或生成代码按钮输出代码。
) b  I! D  X1 z
, c1 p7 S; g9 i  w/ R9 K( {
31870054f08c4b95bfb5f485f13480d6.png 7 }% l' D9 l) b' s
- L5 j2 ?1 x) {  Z. g
& _# I9 Z' ^" L4 P  p* j
四、代码设计' Z4 m1 [0 I: U. u& |; B
        【1】首先创建usart1接口的调试输出支持" u! s8 Y) H7 L$ L7 o; I  o
        1)禁用syscalls.c,右键选择该文件进入属性页面设置。5 m. `" U9 n$ @* |( k0 a

- E, i* ^9 B; |" D! k
aec3533e953447e39024f449845c2564.png 5 R$ G6 \0 T  r. c6 ~5 n- g
# F2 L5 T9 c4 s! i. M
         2)在工程目录下创建源码目录ICore,添加文件夹print及print.h/print.c,实现对系统printf函数的映射到usart1输出显示功能。
) T& B- C/ m3 }& Y# T+ m! T3 E
" N$ p) g2 ?4 L1 D1 i: x4 U        print.h
9 m2 z4 n  v$ V2 K* A4 E' Z
  1. #ifndef INC_RETARGET_H_- O8 t1 L1 Z' A3 v2 m3 ^+ V  O# I
  2. #define INC_RETARGET_H_$ J/ a3 s+ Q# T, g; T: d3 `
  3.   f0 }3 I" q6 X
  4. #include "stm32f1xx_hal.h"$ C$ J/ b# `  A; y
  5. #include "stdio.h"//用于printf函数串口重映射1 F) `4 x4 d$ s! h6 [$ l
  6. #include <sys/stat.h>2 m2 F, h( C! D4 Z

  7. 1 d. i0 I3 U0 E
  8. void ResetPrintInit(UART_HandleTypeDef  *huart);  g, ]' e9 b" H# v1 n
  9. + X$ s6 T3 Z/ p- H
  10. int _isatty(int fd);
    6 c0 i2 A' ?" ?9 ]9 p2 l
  11. int _write(int fd, char* ptr, int len);8 n5 {1 P( L4 C% o
  12. int _close(int fd);
    % }4 g9 ~4 Z; f0 k/ y$ B' `
  13. int _lseek(int fd, int ptr, int dir);
    + C8 s5 E) J' p& g+ J9 |  K
  14. int _read(int fd, char* ptr, int len);. m3 o/ ~2 \9 @" {
  15. int _fstat(int fd, struct stat* st);, _5 {; A" J# n
  16. : o' K6 R& v! w) }' b$ L! r# u% k
  17. #endif /* INC_RETARGET_H_ */
复制代码

- Q- L6 M3 F6 F, Z6 ?. _        print.c, J3 B4 n8 G$ p, t  Q+ o  [2 p
  1. #include <_ansi.h>
    + n  q5 |% `6 m6 ?6 O* Q( o: Y
  2. #include <_syslist.h>. s: r# A4 T# \. M. ?$ v% _
  3. #include <errno.h>0 |) v3 l7 [; n, Q0 L. q
  4. #include <sys/time.h>. r# I+ T. r4 U- E
  5. #include <sys/times.h>, R# N: P7 ~5 M! ]+ }3 s
  6. #include <limits.h>
      R) ~3 Z6 o1 C& G# C4 F+ \7 h: v
  7. #include <signal.h>3 j5 L. }$ x( X3 V2 O
  8. #include <stdint.h>
    * \% @2 P/ o1 T
  9. #include <stdio.h>- M. ]4 h# \4 {) x1 i2 C
  10. : y0 X5 n0 }) p' j9 C' d6 a
  11. #include "print.h"
    / }, P5 X2 f, Y' p

  12. & H  M9 h7 o% n% m% U; `
  13. #if !defined(OS_USE_SEMIHOSTING)% m' e1 V$ i1 J3 ^1 a
  14. #define STDIN_FILENO  00 s; Y. ^) l9 W7 Z
  15. #define STDOUT_FILENO 1# u; _$ x2 o; F6 Z6 {! @
  16. #define STDERR_FILENO 28 W2 Y. p& b* c/ T
  17. ( L% }' k/ q" R( W: c
  18. UART_HandleTypeDef *gHuart;
    5 `" K9 ]& W% y* F9 c1 K: z0 g

  19. % S# e  \$ k( k9 s1 \7 \
  20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    ; H& |% U: k  W( D
  21.   gHuart = huart;! J7 z; u' ], R9 T2 Y' N4 C: z( n$ {7 u
  22.   /* Disable I/O buffering for STDOUT  stream, so that
    2 B: W' e) }+ U9 V1 X
  23.    * chars are sent out as soon as they are  printed. */
    " d  q. N! o9 n/ Y4 `+ m" F. C
  24.   setvbuf(stdout, NULL, _IONBF, 0);6 M7 r$ i, H2 d% r3 Z1 Y
  25. }# f8 z0 i: I, J; U6 L
  26. int _isatty(int fd) {
    5 [' j" N3 u" `8 C, d
  27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    . z$ [5 o, D( o" Z, o2 @; L
  28.     return 1;
    , V& Z( _7 Q% A% ^9 B( L+ H
  29.   errno = EBADF;+ ]+ C! ^4 C$ \' g! K
  30.   return 0;7 B9 K3 P9 D- ?- W
  31. }
    4 j$ h) ?  a, r7 Q5 c6 y* W' D0 V
  32. int _write(int fd, char* ptr, int len) {6 e5 q- w5 J8 L& N
  33.   HAL_StatusTypeDef hstatus;7 f7 m8 |' o6 w# s; `
  34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {, [' O0 h; q9 U7 [! R$ j8 l$ u, }, G
  35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);9 o9 n! f" P) q7 Z) l# {
  36.     if (hstatus == HAL_OK)
    . F  A8 P2 a) A" j: D% ?5 G; N5 \
  37.       return len;! c% P  e% m- A, Q
  38.     else+ a2 c% Y# ?+ y8 Q& v
  39.       return EIO;( i7 \1 f  U2 o" `
  40.   }
    : K0 m9 C0 G% h  z$ l9 J# _5 z! R
  41.   errno = EBADF;
    6 B  Q( G! t3 `4 u) m
  42.   return -1;
    % G' w& J' }2 v7 V  Y9 K. Q
  43. }6 d. N6 M+ j9 V7 i$ W! g
  44. int _close(int fd) {
    , j/ @$ ^0 D; ~
  45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    2 G3 K0 w/ u$ z) M
  46.     return 0;" ^" m8 Z: u6 ]4 I+ m" z2 }
  47.   errno = EBADF;0 b- c, B) g/ f% b9 [* [
  48.   return -1;
    ) m. x+ X7 x' b4 Z. F. h
  49. }
    2 b& \2 s+ U" P+ ?: @/ O
  50. int _lseek(int fd, int ptr, int dir) {
    2 g( P: ^8 I, r% A) I& F8 F/ p
  51.   (void) fd;
    ! L! }% y) C$ k; v  B4 H
  52.   (void) ptr;1 A" R0 q* v$ P3 j- ?, @
  53.   (void) dir;
    : G8 A3 O+ ]7 v3 P' w, S0 \
  54.   errno = EBADF;
    3 t( ]/ O4 o1 U7 H  S+ ^
  55.   return -1;" f- \0 o2 d; [1 k9 A" N& C7 G
  56. }: Q5 K" L, @+ ]/ y% o
  57. int _read(int fd, char* ptr, int len) {
    % d" \: ]( S9 C' R& w
  58.   HAL_StatusTypeDef hstatus;5 Q- F- x. o7 B4 o6 |
  59.   if (fd == STDIN_FILENO) {/ C8 R2 p- A; C& y; A
  60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    , W; \* M' M) A; k0 H2 P( K
  61.     if (hstatus == HAL_OK)
    8 D. j5 R' v- d( r. U
  62.       return 1;' Y) V" W% W/ r  b& [
  63.     else
    ' ]3 X6 O7 T. o1 h% H4 t, v8 p! V
  64.       return EIO;6 Q$ U9 T4 H" L! Z& r5 n
  65.   }9 V7 `. w9 x/ d' |  D
  66.   errno = EBADF;
    : k7 j4 x* @( @  {
  67.   return -1;
    , Y& F5 {& A7 s' z; {
  68. }
    * l5 L5 M8 Y& h8 @7 ~. Z
  69. int _fstat(int fd, struct stat* st) {5 z  J3 c! S' P  y, P( r7 e
  70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {# ]) V( L# X( o0 \( h2 w9 w  S
  71.     st->st_mode = S_IFCHR;2 H+ s2 O0 W" k* h5 a
  72.     return 0;
    * _: W4 v7 i4 D5 T7 f7 n
  73.   }
      f) t$ Z& R, _( i' U$ d9 U
  74.   errno = EBADF;' d& T) a: k, s
  75.   return 0;
    4 \) l* P5 |& a2 I' x
  76. }( t- t7 e. ?8 V  h* G$ a- a

  77. . V/ r8 d; w; T& [; o
  78. #endif //#if !defined(OS_USE_SEMIHOSTING)
复制代码

5 W+ h/ G7 T# G# V        【2】创建按键驱动、LED驱动、延时函数功能的支持
0 H8 S* `9 K  h2 k( K1 h: D- s         1)在ICore添加delay目录,并添加delay.h/delay.c源文件
. ?# l+ p. j6 C8 _( d        delay.h& m7 c6 G# o9 g3 o+ d6 }7 f
  1. #ifndef DELAY_DELAY_H_! x7 M$ c" T- ]4 [! ]  t# p( Y2 `8 I+ T4 e
  2. #define DELAY_DELAY_H_
    . ^% m" a/ I5 |$ o/ R+ K  l
  3. ) I; R3 O6 u1 c
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
    $ g+ e# K6 s3 ?1 A8 y6 B3 o
  5. void delay_us(uint32_t us); //C文件中的函数声明
    % ^3 A5 b! r2 M: u; P

  6. & I8 B8 M: ^; m0 K; e- \) f- z
  7. #endif /* DELAY_DELAY_H_ */
复制代码

  B+ V" n  [* p& ]0 _: ~, K        delay.c: H0 e; |  I- a9 N1 K0 T! E
  1. #include "delay.h"
      w* R% ^  \) T( _. s- U

  2. % N3 P4 v, k& X1 G7 q+ ^% D/ {
  3. void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数+ Y* d; O6 _1 Q: |
  4. {
      |& ?" U6 U4 Y" A
  5.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值,经算法得到1微秒的循环次数
    : [" ~+ k. a) E: n# C  q
  6.     while (delay--); //循环delay次,达到1微秒延时) N* U$ C$ w6 R# ]% R/ h% c3 e' g
  7. }
复制代码
) `1 U, R" P  ^( N. g) @# k, G- j
        2)在ICore添加key目录,并添加key.h/key.c源文件6 o! a7 i% a( m5 F
0 C7 T2 \6 z5 o$ i8 f- }. Y
        key.h
* S# [2 @. n# f4 D) b
  1. #ifndef KEY_KEY_H_2 D8 B% A1 [6 _" O. \
  2. #define KEY_KEY_H_
    & T9 L7 m5 y" @) {$ h

  3. / _* Q0 v- j! M* ~" o
  4. #include "stm32f1xx_hal.h" //HAL库文件声明" D7 [/ l& E! t# y
  5. #include "main.h" //IO定义与初始化函数在main.c文件中,必须引用2 e  V0 F6 i2 h# v- U% q( P5 [
  6. #include "../delay/delay.h"- q& S$ ?$ V$ b7 A2 H

  7.   J; C0 s8 f" u3 c# O) n* f' l
  8. uint8_t KEY_1(void);//按键1
    1 `  H; ]( L/ U6 s# w5 \4 f
  9. uint8_t KEY_2(void);//按键2) ~, [) v) U1 I

  10. ' S; ^; c0 k+ @$ W
  11. #endif /* KEY_KEY_H_ */
复制代码

; U8 ?) Z' Y1 C4 s1 N        key.c
" V- Y! ?9 v2 s' c
  1. #include "key.h"
    8 o6 E4 ^0 Q) x' C6 a5 n, [- \
  2. 1 e! V( y" i3 U7 b; K6 d
  3. uint8_t KEY_1(void)7 Z1 h2 B4 O& f: P1 B: Q( K( `4 S# y
  4. {
    ; ^" ^. p3 W0 S
  5.         uint8_t a;
    ' ?# Y& o5 |- P  c& K7 ^7 j
  6.         a=0;//如果未进入按键处理,则返回0
      C; z  J4 f# V/ w" I, {
  7.         if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    " {- ~  b/ \4 f
  8. //                HAL_Delay(20);//延时去抖动(外部中断回调函数调用时不能使用系统自带的延时函数)
    9 a8 c9 O) C' j0 x
  9.                 delay_us(20000);//延时去抖动+ T0 f0 t6 \& V4 N2 \
  10.                 if(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平! j8 N  k# `$ A; p5 ?; D
  11.                         a=1;//进入按键处理,返回18 O2 r9 t+ g% i0 D& M
  12.                 }
    # P# x0 G1 c% I- z7 I- I2 H8 Z& S
  13.         }
    1 a/ w0 I  Z/ U) T; t
  14.         while(HAL_GPIO_ReadPin(GPIOA,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开9 ^2 d7 K& A7 @# \! L+ c7 U8 L9 g2 [7 ^
  15.         delay_us(20000);//延时去抖动(避开按键放开时的抖动)
    % G1 _6 R! T" i4 D6 ?' e) w
  16.         return a;! z( Z" a9 j1 D% E# H  w. S
  17. }. x/ B- `& N5 ?8 S  d

  18. + v( t+ K0 z. p$ q
  19. uint8_t KEY_2(void)
    6 L6 P% Z: k9 X# r: [* Y1 y
  20. {, A' t, c; x2 R4 z( r
  21.         uint8_t a;
    1 n2 _, e+ H. [" ]/ p  Z# ^
  22.         a=0;//如果未进入按键处理,则返回0( U0 d& q: S2 A% V  s# \
  23.         if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平7 I' h2 \0 f( h6 x& f& j
  24. //                HAL_Delay(20);//延时去抖动(外部中断回调函数调用时不能使用系统自带的延时函数)
    + \' t* f) k! T; S
  25.                 delay_us(20000);//延时去抖动' e; k5 s$ b6 S1 `
  26.                 if(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平2 p; j+ I5 }  l6 i
  27.                         a=1;//进入按键处理,返回1
    ' W) j$ A  M) U
  28.                 }' w: ?; }. C$ ]0 A  T
  29.         }2 w6 C" r' `0 V, M+ v4 k9 h6 h
  30.         while(HAL_GPIO_ReadPin(GPIOA,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开- g; b8 `) i3 c% G( b! g+ j
  31.         delay_us(20000);//延时去抖动(避开按键放开时的抖动)
    3 R4 ?) x4 x+ [: n! h+ ?
  32.         return a;2 B2 k6 _( S$ r/ ^" D
  33. }
复制代码

; G0 o( Y7 E9 A7 v) X: E; O: j" \        3)在ICore添加led目录,并添加led.h/led.c源文件$ y# q: ^& B- F
/ Z: n4 n+ `# L$ \+ A
        key.h
' N  J1 w$ b9 M1 j! N4 V" B- q3 o9 W
  1. #ifndef LED_LED_H_# V; p& U& ?! S* Q' k
  2. #define LED_LED_H_  V; r) c$ B) U( M( X
  3. 5 k; k' n  a/ ]
  4. #include "stm32f1xx_hal.h" //HAL库文件声明1 p, }: q# i( x' X0 @( ^: N1 H
  5. #include "main.h" //IO定义与初始化函数在main.c文件中,必须引用
    $ Q: f6 f2 l9 d! p1 Z0 O
  6.   e/ N. v. b8 A" ?; V
  7. void LED_1(uint8_t a);//LED1独立控制函数(0为熄灭,其他值为点亮)4 ?9 P$ l! s/ y. R) H, j' O
  8. void LED_2(uint8_t a);//LED2独立控制函数(0为熄灭,其他值为点亮)# c5 w9 v$ Z9 Z+ h; o6 B
  9. void LED_ALL(uint8_t a);//LED1~4整组操作函数(低4位的1/0状态对应4个LED亮灭,最低位对应LED1)7 U2 S1 y' f6 C% Q
  10. void LED_1_Contrary(void);//LED1状态取反2 `6 C$ }" V  _- [
  11. void LED_2_Contrary(void);//LED2状态取反1 e/ _* M8 J, x

  12. # _  y$ p0 T2 \+ j- F
  13. #endif /* LED_LED_H_ */
复制代码

" ~' ~$ t# S) u8 ?3 G        key.c
. }9 F% N5 h( b; s3 a8 {( Y
  1. #include "led.h"+ `$ s7 C/ k3 p" ]2 c
  2. 1 x% v) k" _  Q/ Z8 u, C
  3. void LED_1(uint8_t a)//LED1独立控制函数(0为熄灭,其他值为点亮); x- L5 e: Q8 U4 X- s
  4. {
    * E  G; w3 p, k  D7 t
  5.         if(a)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    7 @. ]8 q8 a! T- S; Q0 v! [
  6.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);2 C! r/ a7 ?5 p( n6 {: Z" u, B
  7. }) i4 M- v' n' V1 n" \. Z& k+ f5 w
  8. void LED_2(uint8_t a)//LED2独立控制函数(0为熄灭,其他值为点亮)
    9 n* p2 U7 L1 O3 t! \
  9. {4 p+ r, n) C& `  C% T( b
  10.         if(a)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);
    0 p8 X  X6 S. a: T# L
  11.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    ; u% ~* d' _7 g+ ^
  12. }
    , m$ a# ^- b) z6 K/ ]# ~) U, R! t
  13. void LED_ALL(uint8_t a)//LED1~2整组操作函数(低2位的1/0状态对应2个LED亮灭,最低位对应LED1). T8 X, J1 S/ Z8 P/ @. Q9 w& t
  14. {; X4 Z6 t/ L* S' }& L$ @
  15.         if(a&0x01)HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_SET);
    ( |) o+ J- U% A# u/ J
  16.         else HAL_GPIO_WritePin(GPIOB,LED1_Pin,GPIO_PIN_RESET);
    8 |4 J7 v( O9 N5 F' u3 v4 V
  17.         if(a&0x02)HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_SET);% Q( y) S' ~1 K
  18.         else HAL_GPIO_WritePin(GPIOB,LED2_Pin,GPIO_PIN_RESET);
    5 z9 D: \5 Z* j2 T
  19. }
    2 I, C# ?( T8 g+ B4 A
  20. void LED_1_Contrary(void){
    6 U( ]+ _8 Q# ~: k5 F' A
  21.         HAL_GPIO_WritePin(GPIOB,LED1_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED1_Pin));+ o  M/ b8 a7 `! l$ Q* L, b
  22. }' o# T: c; m4 ^
  23. void LED_2_Contrary(void){) H( t& `+ R, L  _. c5 q' Z# I  Y
  24.         HAL_GPIO_WritePin(GPIOB,LED2_Pin,1-HAL_GPIO_ReadPin(GPIOB,LED2_Pin));7 z' ]  c2 J0 Y0 _5 k
  25. }
复制代码

% a/ L3 R7 {* W        【3】创建串口驱动程序,主要是复写串口回调功能
7 C- @+ c$ S; z$ }        1)在ICore添加usart目录,并添加usart.h/usart.c源文件,实现串口驱动功能% X3 K1 ]! c; C4 d5 ~* U' O; e

$ f0 Q7 c+ U8 N) E' l        usart.h5 L8 N) F) a  F
  1. #ifndef INC_USART_H_8 @9 ?* f: r$ y) E
  2. #define INC_USART_H_) X: G% |. l: f5 ]/ _/ Y- z* V

  3. ! K% b3 ~  o. s& R& R
  4. #include "stm32f1xx_hal.h" //HAL库文件声明. K( `. P5 p) c6 P" r6 [& u2 K! a
  5. #include <string.h>//用于字符串处理的库
    / s4 @2 J& p% b0 y$ I' O
  6. #include "../print/print.h"//用于printf函数串口重映射
    7 T" V% M6 |3 ]4 I
  7. % K5 |7 O3 w0 R$ h7 B+ p$ m6 m/ `
  8. extern UART_HandleTypeDef huart1;//声明USART1的HAL库结构体
    # b9 P7 Z& `9 v; k$ y! P5 b
  9. extern UART_HandleTypeDef huart2;//声明USART2的HAL库结构体4 _( p0 l/ O2 i7 l
  10. ' z" {  Y# R! \. ]( V' [' Z
  11. #define USART1_REC_LEN  200//定义USART1最大接收字节数  m2 _* ^. Y0 m" `& p1 X
  12. #define USART2_REC_LEN  200//定义USART1最大接收字节数
    ! g# a/ H- K! X; L7 n
  13. 1 n, S# I9 B# ]- e0 N9 c+ h5 Z
  14. extern uint8_t  USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符+ `- q+ @" j" d3 s: B' N% D# u* a
  15. extern uint16_t USART1_RX_STA;//接收状态标记) F) e: U  y3 A9 N) ?8 g/ D% q
  16. extern uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
    . Q' N8 l+ U, D3 s( N
  17. # Q. l3 V6 n* h. B1 V2 H
  18. extern uint8_t  USART2_RX_BUF[USART2_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    " |6 X  \- P( T/ I' r
  19. extern uint16_t USART2_RX_STA;//接收状态标记
    6 I9 ?7 w9 P1 }& Q5 `
  20. extern uint8_t USART2_NewData;//当前串口中断接收的1个字节数据的缓存0 @; c8 m6 S' I$ Z& @
  21. " L" K4 e. ?  {- C

  22. $ x- M% r) T7 j: j9 ~
  23. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明- l1 E2 g6 `" R' Q( X! J

  24. ! ~* H2 u5 R- i
  25. #endif /* INC_USART_H_ */
复制代码
% S/ _- j5 P4 ?" L
        usart.c
( P( n! b, X; `3 c: T* M
  1. #include "usart.h"5 s' o, C# g, k: ^: U6 @8 W2 T* L1 u+ k) J
  2. - ^7 c* _  I7 I% a# n6 w
  3. uint8_t USART1_RX_BUF[USART1_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
    8 j* f7 o$ V/ g. N; g( c# |
  4. /*
    * u! S2 o5 a% x; p! F" o6 }
  5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
    4 G! ]7 G$ H! O$ r, m6 O8 Q
  6. * bit14:接收溢出标志,数据超出缓存长度时,设置HLPUSART_RX_STA|=0x4000;
    , H. w3 c9 i9 ^7 m. @
  7. * bit13:预留
      Y" Z0 J, z: J1 ~8 e% w
  8. * bit12:预留- B8 y; \& \3 y9 ?- Y& }. u1 G6 G
  9. * bit11~0:接收到的有效字节数目(0~4095)
    2 b4 |( `  t0 B0 |: w/ R! W- S3 G
  10. */
    6 c  Y" h) |9 s' O' }1 X; z
  11. uint16_t USART1_RX_STA=0;) T& F9 l+ l- M  G& H* a$ s
  12. uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存
      P* w! m3 r; J" U- Q

  13. 8 d; S) V6 r3 b* [
  14. uint8_t USART2_RX_BUF[USART2_REC_LEN];5 K* T0 I4 D+ Z" O4 z! A& \. x6 A
  15. uint16_t USART2_RX_STA=0;$ }& k" x+ o1 X7 C) n
  16. uint8_t USART2_NewData;4 I$ x* V& q  Q+ ?6 w+ K6 q! f. h
  17. 1 \( r  Y5 o6 q7 ^; s
  18. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    ! g8 n3 f* V& Z7 X: R
  19. {
    & F& L8 m1 y  o/ a* w
  20.         if(huart ==&huart1)//判断中断来源(串口1:USB转串口)) i- q7 V" R1 N- ]/ L6 \
  21.     {* S. t- `* L6 a; A+ D$ R
  22. //                printf("%c",USART1_NewData); //测试用,把收到的数据以 a符号变量 发送回电脑# o  ?# {6 x$ d2 m2 ^
  23.                 if(USART1_NewData==0x0d){//回车标记
    . v; I  E0 M. Q2 p
  24.                         USART1_RX_STA|=0x8000;//标记接到回车
    9 `1 \3 s% T1 U9 p. |
  25.                 }else{
    6 \+ K1 w# A4 R6 ^- g  K
  26.                         if((USART1_RX_STA&0X0FFF)<USART1_REC_LEN){
    0 q/ R/ C% W# x1 C5 _1 w
  27.                                 USART1_RX_BUF[USART1_RX_STA&0X0FFF]=USART1_NewData; //将收到的数据放入数组
      x* ?) n1 d0 n7 B
  28.                                 USART1_RX_STA++;  //数据长度计数加1
    ! p! ]: {$ |4 a1 V6 ?
  29.                         }else{8 l3 f' \+ [& E: r9 L  X
  30.                                 USART1_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    " y7 |2 C0 \+ ^, l5 i  R+ g
  31.                         }
    . A" k& r! V5 ^
  32.         }
    ! n! t  O8 J( V; j
  33.        HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1); //再开启接收中断1 l% b, a" s; F  d  X
  34.     }
    1 W$ [8 I: {7 b/ m
  35.         if(huart ==&huart2)//判断中断来源(串口2:BT模块)
    & \; |0 m$ S3 x) I
  36.         {
    , D, z* B* O/ C: f
  37. //                printf("%c",USART2_NewData); //测试用,把收到的数据以 a符号变量 发送回电脑
    ; x# I9 V/ _' q$ _' ]- U
  38.                 if(USART2_NewData==0x0d||USART2_NewData==0x0A){//回车标记,(手机APP“蓝牙调试器”回复数据以0x5A为结束符)4 }1 }" u8 W$ d7 v2 o
  39.                         USART2_RX_STA|=0x8000;//标记接到回车
    0 C% @  U. [6 J
  40.                 }else{
    3 Q( O! [$ k, P5 d( O
  41.                         if((USART2_RX_STA&0X0FFF)<USART2_REC_LEN){
    9 f+ E8 U) \; s8 O
  42.                                 USART2_RX_BUF[USART2_RX_STA&0X0FFF]=USART2_NewData; //将收到的数据放入数组$ r% ^/ G1 s3 Q& b: Y$ x
  43.                                 USART2_RX_STA++;  //数据长度计数加14 W" l# t" R7 ]+ i' q
  44.                         }else{
    $ A2 Q, p7 j! s
  45.                                 USART2_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    ! c( l+ v" h  @5 c  O  U3 T7 j
  46.                         }
    / `, X0 l. c! m
  47.         }# J5 A! F, C  \. u
  48.                 HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启接收中断8 y/ ]. c' y. u" e3 b
  49.         }5 k: E$ g* W9 z% r9 H3 G) M! A
  50. }
复制代码

7 J0 Z" a+ t9 L0 ~, p1 @        【4】创建蓝牙驱动3 K) V& S7 L$ d$ X
        该驱动主要实现通过usart2向蓝牙模块写入数据,(读取数据主要通过串口usart2回调,在usart.c中实现)。在ICore添加bt目录,并添加bt.h/bt.c源文件,实现蓝牙驱动功能/ W, q& }# H7 `$ M7 K
- C+ L4 c9 A4 E1 w% `6 Z
        bt.h
% u3 R& L# W& ]
  1. #ifndef BT_BT_H_
    # D1 ?- R  @9 Z% @0 l9 X8 T
  2. #define BT_BT_H_3 Z. V8 e' A0 q3 ], ]6 J9 w

  3. # J" K* ?' p1 F- D0 ]; \$ ]0 n1 l- p
  4. #include "stm32f1xx_hal.h" //HAL库文件声明
    3 S: G4 }5 d4 z; `  J; E
  5. #include "main.h"$ R3 {$ B# [! W1 x1 Z- g3 y; W
  6. #include "../usart/usart.h". R/ }9 U7 k: H" X8 z$ Z  F
  7. #include "../delay/delay.h"3 Z3 L- X# _& z6 @; P, v9 `
  8. #include <string.h>//用于字符串处理的库
    - D4 s; t; d8 k. \- ?* J
  9. #include <stdarg.h>
    & O) D5 \+ c7 \: H6 C2 g
  10. #include <stdlib.h>
    & t5 p( r  P4 C2 C9 r
  11. #include "stdio.h"
      X: r7 E- q( u7 T# L8 X4 o

  12. 4 h% N4 r+ N6 T- _/ U! r* s$ J
  13. extern UART_HandleTypeDef huart2;//声明UART2的HAL库结构体
    , j6 b1 c6 M. R1 C: C
  14. void BT_WEEKUP (void);//蓝牙模块唤醒函数
    $ P, |! t$ h% O2 X+ f
  15. void BT_printf (char *fmt, ...); //BT蓝牙模块发送
    3 _+ U% \0 G6 ]. v7 P, T

  16. ( X/ a. J2 {0 X# u1 o6 K( m
  17. #endif /* BT_BT_H_ */
复制代码
9 L# u$ ]! ^$ Q) G* S5 N
        bt.c
! w! @1 b2 j! n8 r+ j0 U- s+ b
  1. #include "bt.h"; x9 ~' x) m  N) D3 N* D
  2. ' i6 F% q4 C6 ^: {$ f
  3. //蓝牙模块唤醒函数
    ) a9 z( |0 g. E0 W* ^) p& Q9 K' @# x
  4. //对蓝牙模块上的PWRC(P00)接口一个低电平脉冲,如不使用睡眠模式可忽略此函数, R1 W1 Y2 ~$ y
  5. void BT_WEEKUP (void)2 x* l$ E  V5 q$ ?
  6. {
    & x- y, L3 n0 b! d- S4 ?. p
  7.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_RESET);//PWRC接口控制
    ! z7 \- _& c& L7 \
  8.         delay_us(100);
    7 _- ^) s( }, W9 r5 J
  9.         HAL_GPIO_WritePin(BT_RE_GPIO_Port,BT_RE_Pin, GPIO_PIN_SET);//PWRC接口控制
      x7 x* m9 y1 M- b* N$ o
  10. }/ W/ n1 a' Y9 I
  11. //蓝牙模块通信,使用UART2,这是BT蓝牙的printf函数6 ^7 E" C  |7 w, F4 C, Z# \
  12. //调用方法:BT_printf("123"); //向UART2发送字符123
    + f" ?4 e7 ?, O( f
  13. void BT_printf (char *fmt, ...)$ z+ z% G2 ?( B/ d2 q" I6 S
  14. {" i6 n2 k" r7 _2 Q1 _) Z
  15.     char buff[USART2_REC_LEN+1];  //用于存放转换后的数据 [长度]
    8 A7 e% o/ v" u7 e
  16.     uint16_t i=0;- U8 F3 D# E# Y1 v
  17.     va_list arg_ptr;. A4 c$ n' K" r' C
  18.     va_start(arg_ptr, fmt);$ L6 [( }0 V$ L6 H! N. m- A
  19.     vsnprintf(buff, USART2_REC_LEN+1, fmt,  arg_ptr);//数据转换
    . r- {9 _& Y2 I
  20.     i=strlen(buff);//得出数据长度  h; l% ~& y" L; g  O
  21.     if(strlen(buff)>USART2_REC_LEN)i=USART2_REC_LEN;//如果长度大于最大值,则长度等于最大值(多出部分忽略)! R2 h' a$ H, s" ]8 g9 w
  22.     HAL_UART_Transmit(&huart2,(uint8_t  *)buff,i,0xffff);//串口发送函数(串口号,内容,数量,溢出时间)
    * P' P2 k9 B; X$ h; j/ {+ t
  23.     va_end(arg_ptr);1 }* t  y. g8 t/ E# o  s4 }
  24. }
    / P6 o9 w7 Y/ n
  25. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback,统一存放在USART.C文件中。
复制代码

% ]. |/ t0 r; s五、编译及测试
  p" E! n7 @; _9 ]5 g( W3 ?        【1】功能调用及编译
# O( M# J( D6 j        1)在main.c文件中进行蓝牙功能调用实现,部分源码如下:* Q- c) m) ]$ A$ I4 R6 [
  1. /* USER CODE END Header */
    # V  v0 y0 H; L4 O- Y8 C& g
  2. /* Includes ------------------------------------------------------------------*/& _6 I1 U8 J3 K: b/ l% O4 {
  3. #include "main.h"+ S# l: |" w* t5 g

  4. . L4 Z! ]4 ?, u( S$ d5 F
  5. /* Private includes ----------------------------------------------------------*/8 u1 `! x3 v/ y3 H9 f) j; x$ r+ C
  6. /* USER CODE BEGIN Includes */: Z! f, U1 [9 U6 D# n
  7. #include "../../ICore/led/led.h"
    ( C1 K0 s' Z' G9 b, t0 `
  8. #include "../../ICore/key/key.h"
    2 p7 L7 _( U$ o7 V) M
  9. #include "../../ICore/delay/delay.h". F8 y4 O. y# `+ v3 L4 u
  10. #include "../../ICore/print/print.h"//用于printf函数串口重映射
    ! z$ p8 L& p( W+ ]+ |5 V4 ?# ?6 z
  11. #include "../../ICore/bt/bt.h"
    # Y0 Q' Y+ {- r! M3 f: O
  12. /* USER CODE END Includes */4 d/ q8 b& {) J. G7 Y: K! o
  13. ) [* w' i; g) q2 F
  14. /* Private typedef -----------------------------------------------------------*/3 X, g- o& t) ^0 t$ u9 K
  15. /* USER CODE BEGIN PTD */2 R* V; c1 O+ [  }, H: `% J

  16. - ?- r! p7 P7 ]" E
  17. /* USER CODE END PTD */
    ! W- ^- o) [! N6 G8 x6 m8 c

  18. ) }$ h  @' B# f
  19. /* Private define ------------------------------------------------------------*/3 v6 K, O! Y" [3 p
  20. /* USER CODE BEGIN PD */
    9 ?2 f' Q* j* d
  21. /* USER CODE END PD *// b$ T$ E. Z4 h3 F) c& J
  22. 5 l6 j$ r- W2 P) @. d3 M
  23. /* Private macro -------------------------------------------------------------*/1 F9 Y7 H6 M+ I4 ^0 c- s; M
  24. /* USER CODE BEGIN PM */
    / D! a  D/ S. q% o5 I

  25. & w% s5 z; A3 }6 k
  26. /* USER CODE END PM */- L8 K, K- a% E
  27. 5 d% f+ }# C9 C& ~
  28. /* Private variables ---------------------------------------------------------*/
    8 f2 S$ n# z9 \7 ~6 F
  29. UART_HandleTypeDef huart1;
    7 u4 ~5 D! P" z7 ?$ T/ o: v  B7 U
  30. UART_HandleTypeDef huart2;
    1 s" E% s* H, l- J

  31. 0 g) G) U, P1 r( [6 j$ U: r, v
  32. /* USER CODE BEGIN PV */& Z7 w' n, c" I( W3 w
  33. + |- q% s' R  [1 j
  34. /* USER CODE END PV */; P/ H: v, C; e% l+ [9 o
  35. ) Z4 F& ?' K! j$ L- [7 j* P
  36. /* Private function prototypes -----------------------------------------------*/
    & J# U( z) G9 r, n# L1 W8 G3 \
  37. void SystemClock_Config(void);
    % f* c* ~2 G# P
  38. static void MX_GPIO_Init(void);! R. ^* T) S, y0 K3 r& |
  39. static void MX_USART1_UART_Init(void);0 i: Y6 @" P- C: r  J( V* k
  40. static void MX_USART2_UART_Init(void);4 k( K, T8 R7 T; i  ^, s6 p! X
  41. /* USER CODE BEGIN PFP */
    . i4 i+ {0 L. @3 I
  42. / R. l* J& I( i) ~- q/ B
  43. /* USER CODE END PFP */
    + s# y; Z& v0 d0 q
  44. % }; l1 {+ p5 C
  45. /* Private user code ---------------------------------------------------------*/6 b- {0 c4 v+ F  }
  46. /* USER CODE BEGIN 0 */
    8 L: @- n* I# c" c
  47. 6 ?* s2 j- g: G5 w% w, l$ ]
  48. /* USER CODE END 0 */, e) W' J& _' L& D" k) K! v) X

  49. 3 ]( K' F6 Y' Y3 f
  50. /**
    6 Q, O) m2 B- l- _1 F
  51.   * @brief  The application entry point.
    / V+ @- \! D  F- l$ s. ?1 r
  52.   * @retval int
    * K' ~0 t; B3 ^& {
  53.   */: }. f9 u  N1 ^) j" i3 y4 x0 ?
  54. int main(void)
    / g8 I% F  _3 n
  55. {
    8 Z6 r% x( w* [
  56.   /* USER CODE BEGIN 1 */
    0 A) m" q6 t: v% {# h' n, ~) G

  57. 0 m! e7 d% ]: D% k
  58.   /* USER CODE END 1 */( r) D, b. r( E( [0 F$ d" x# }6 b

  59. 9 V. h5 X, @! z, M0 ]
  60.   /* MCU Configuration--------------------------------------------------------*/
    & E; h3 U: v: T. ?1 e2 j2 V: L# h# p

  61. & K5 y$ _6 ~  a) j1 Q
  62.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */- f& B" ~  u! y& D3 ?. J  L
  63.   HAL_Init();
    ! Z$ T" H$ e# K. s& f6 \* i

  64. " @+ r: |3 {! N, P$ u$ a( A
  65.   /* USER CODE BEGIN Init */
    9 |) W" s$ ]. e- Q
  66. ; M1 Y, Q* [6 o
  67.   /* USER CODE END Init */
    " D7 ^) r/ s" d( ]# O2 p

  68. ( y* P( e- E' P  t+ n
  69.   /* Configure the system clock */
    * x/ j* K4 K: s
  70.   SystemClock_Config();; t/ X7 C$ \/ H) R
  71. # j' M' X" Y% ~! a
  72.   /* USER CODE BEGIN SysInit */. n5 H" e# D  c7 @8 n
  73. ; C  q7 j$ m& m, G; I
  74.   /* USER CODE END SysInit */# o/ e4 l: ^6 q% g& H
  75. / \& K( x2 l+ }3 c3 Q& Q
  76.   /* Initialize all configured peripherals */
    " j# j0 |2 W: W5 U+ ~. ]: P
  77.   MX_GPIO_Init();
    $ R0 W" ~! ]& e" }9 y% T+ ]
  78.   MX_USART1_UART_Init();! h4 R7 `- {5 |9 S. Q
  79.   MX_USART2_UART_Init();
    8 G5 e6 H3 {: s; p  f
  80.   /* USER CODE BEGIN 2 */
    & [' \0 Z! q1 j  O
  81.   ResetPrintInit(&huart1);//将printf()函数映射到UART1串口上
    ; l$ S% e1 J* X$ j6 _
  82.   HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);//开启串口1接收中断
    # }" |( k$ L, }0 c& `: d
  83.   HAL_UART_Receive_IT(&huart2,(uint8_t *)&USART2_NewData,1); //再开启串口3接收中断
    8 G0 o2 y" a5 v- C
  84.   /* USER CODE END 2 *// n: w5 ]  ]0 p$ i/ K
  85. + r# V. V& n* E- W. C0 m% g
  86.   /* Infinite loop */
    3 M! r+ D. N, |5 I* E3 l/ V* Z
  87.   /* USER CODE BEGIN WHILE */1 P3 E# ^& w8 ?( E' n/ }
  88.   while (1)
    " b$ T2 v9 Y9 C3 o% a- V; O9 e2 s  C
  89.   {: z' ~+ G1 J) y: m
  90.           //demo 蓝牙02
    ! j  F, d- \. D$ p, o
  91.       if(USART2_RX_STA&0xC000){//判断中断接收标志位(蓝牙模块BT,使用USART2)
    7 j( w2 y/ \7 Q+ s9 k( y
  92.              BT_printf("%c",USART2_RX_STA);/ p$ F5 L, R" z
  93.              if((USART2_RX_STA&0x7FFF) == 1)        //判断接收数量1个(手机控制程序)
    3 f4 s0 s1 |: h( W. h
  94.              {
    1 s3 m7 l6 \% }" d# o- |* H
  95.                      BT_printf("%c",USART2_RX_BUF[0]);7 I  C' x5 d* Z3 }5 L! C; T. {
  96.                      switch (USART2_RX_BUF[0]){//判断接收数据的内容
    9 h3 u( l8 M# T& W$ n& B
  97.                                 case 0x41:
    9 F- u6 v3 y) o8 d
  98.                                         LED_1(1);//LED1控制
    ) O: O- K% a% v# K/ }) Q' R3 r
  99.                                         BT_printf("Relay ON");//返回数据内容,在手机APP上显示
    . V" B% r" n0 S
  100.                                         break;6 ~, @; o8 k6 T
  101.                                 case 0x44:
    & O+ A& ^/ x3 U1 I1 V6 P) J: M
  102.                                         LED_1(0);//LED1控制. o! \+ b0 K0 [% r/ f
  103.                                         BT_printf("Relay OFF");//返回数据内容,在手机APP上显示
    $ ^. |( L) J7 f3 Y. q& p
  104.                                         break;
    ; F& O+ t- G* p) v; q
  105.                                 case 0x42:) i( X- M5 N6 k( }/ q9 R
  106.                                         LED_2(1);//LED1控制/ z7 `* p6 Q/ X3 u4 Y/ Y5 I8 ?
  107.                                         BT_printf("LED1 ON");//返回数据内容,在手机APP上显示
    ; g, e% z  P' q7 E% j( A5 F8 a
  108.                                         break;3 v$ I: p, W9 E
  109.                                 case 0x45:
    . L) w9 {9 P, U( {) f: ?* o6 B
  110.                                         LED_2(0);//LED1控制
    3 g1 n1 I; C3 {
  111.                                         BT_printf("LED1 OFF");//返回数据内容,在手机APP上显示9 C! w  o) W! {1 J% V* J
  112.                                         break;
    & n3 v( ]  n4 h" ?: B9 p
  113.                                 case 0x43:
    5 U0 `. j4 g4 {$ I  ]& J9 F$ P: ^6 n& k
  114.                                         LED_1(0);//LED1控制
    2 X- O! e. ?+ _% _5 g
  115.                                         LED_2(0);//LED1控制
    - Z# }7 j; ?& q! u
  116.                                         BT_printf("BEEP");//返回数据内容,在手机APP上显示. i% R1 W4 E/ [3 q# ~
  117.                                         break;0 Y& e" q8 e) ~" y  A/ P6 {- K
  118.                                 case 0x46:
    . c% a1 \" Y$ k$ M# ~
  119.                                         BT_printf("CPU Reset");//返回数据内容,在手机APP上显示7 o9 }6 k& ^% c$ {  n
  120.                                         HAL_Delay(1000);//延时7 j5 F6 A" q8 r$ [9 l, C* {
  121.                                         NVIC_SystemReset();//系统软件复位函数
    4 {) h5 X) b  m  M% B3 q/ w
  122.                                         break;
      Z; ~1 k, w' E' e
  123.                                 default:
    / q0 f9 t; K* Y8 {7 }) u
  124.                                         //冗余语句) q' L) J: h  ]6 }# F. `/ r4 o
  125.                                         break;
    7 L. z( z0 T5 z" E
  126.                           }- P. ]. Q: e! |( y
  127.                  }
    6 S7 c- ~0 g& ~: {  v( v$ D8 e
  128.                 printf("%.*s\r\n", USART2_RX_STA&0X0FFF, USART2_RX_BUF);//BT接收内容,转发usart16 W' a7 k+ p7 e5 N
  129.          USART2_RX_STA=0;//标志位清0,准备下次接收5 ^/ Q7 e# `! B, w$ ^) @' y
  130.       }
    * ~$ C4 a. o6 Q; P1 ~" ^
  131.       //接收到电脑发送给(usart1)数据,转身将其发送到给usart2,进而实现送数据给BT模块, h  p# T# F3 e
  132.       if(USART1_RX_STA&0xC000){//结束标记& f* ^' |8 }$ U) y* n$ G: o5 ^5 |  Y
  133.               BT_printf("%.*s\r\n",USART1_RX_STA&0X0FFF, USART1_RX_BUF);
    * Y$ p3 q3 ]4 B; B6 T' l: u+ P
  134.               USART1_RX_STA=0;//接收重新开始
    1 b* t, ^) Y$ j. H$ c3 O
  135.               HAL_Delay(100);//等待
    - ?( q7 j* |! K+ h7 P' _
  136.       }
    + M) n7 L& o! m- N$ y/ U
  137.           if(KEY_1())//按下KEY1判断9 W- k+ @& R1 t9 O
  138.           {
    . ?& u$ l! {+ w" G' E; s9 j
  139.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
    " B1 S0 a9 w/ I0 h% z4 G
  140.                   LED_2(0);//LED2控制3 _4 m: [- A' R; U  o$ H; h
  141.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令(修改模块的广播名为PYFREEBT)
      p/ W3 K3 @- [; V
  142.           }
    9 e: v! t' D- V; x9 v
  143.           if(KEY_2())//按下KEY2判断) y4 p+ |# @* v2 g" A
  144.           {% ]; Q5 H3 a0 @/ Y, e: g% z
  145.                   LED_1(0);//LED1控制 //在蓝牙模块回复之前先将LED状态复位
    ! A" J; \- b7 E+ E
  146.                   LED_2(1);//LED2控制
    , R0 r: P  q1 f$ |7 w' w. V
  147.                   BT_printf("AT+DISC");//向蓝牙模块发送AT指令(断开与手机的连接)
    ( T0 S% p2 B5 Q7 y
  148.           }! u, `$ y* U+ M* }6 w5 M) W2 s
  149.     /* USER CODE END WHILE */- G+ j( M! K( u4 N6 ~- C

  150. " k! F: M3 Y" ]- Z! I
  151.     /* USER CODE BEGIN 3 */
    , Q8 W) q$ P) p* Z
  152.   }
    9 x# ~( y. d' u
  153.   /* USER CODE END 3 */
    2 U8 O( I: U# V5 ]
  154. }
复制代码
, |8 X$ n& }- k9 ?
       2)设置编译输出支持,右键工程进入项目属性设置页面:. Q/ G; H! ?# V' L  t2 X

) j, I* O% T% }0 y) r# a
b959f3b4bbc34e9a933d8fa45890c6ba.png . s* m& a1 _  x2 }

& d& i" [5 A, @  D: ]# |  s; M          3)点击编译按钮,完成编译(整个工程需要源码修改或添加的源文件如下):
7 }4 [  |6 m; I$ d# r# {7 p5 G* ~" F* m% k
288d14c992b3413ab8b2e3c42e0994ed.png ) E, R+ M# Z2 Z  w+ C
5 J1 v# n. p  p0 s
        【2】程序测试7 K1 U2 i: \6 E  m9 f! L& n& ]& |
        1)测试过程需要三个工具文件支持,读者可以自网上搜索最新版本或采用其他同功能工具替代测试:% m5 H5 W( B5 l+ s$ X
        FlyMCU加载工具,将生成的.hex程序文件加载到板子上
' T  L" X- N) T  {6 S        SSCOM5串口工具,连接MCU的USART1,实现调试信息显示及下行指令输入
/ [+ v& }( n- Y. w: ?        蓝牙调试器工具,本文用的是1.9安卓版本。
% C2 R7 Q& l( g1 E% Z# H( B1 p) \9 H; Y# M
616ca3780a8b4077ba5ba5f13ad76834.png
: Q; L5 y6 t- [+ m% U4 P: S
7 {7 s/ b/ q4 {2 R$ y4 @7 b. ?4 x8 u! X7 V# p! @2 ~$ l5 w' c
        2)加载程序,选择串口,选择程序(.hex),点击开始编程按钮:/ s* B: k$ j9 Q
# [; b5 R9 O/ \  M" j$ W
5da0d56a3c4e4c45a74e90e7fbf4b989.png ( Z) j; K7 |5 l, _+ t. B& a
& b: d8 N! G" d/ w
         3)手机打开蓝牙调试器(别忘了开启手机蓝牙功能),进入界面,搜索蓝牙,点击蓝牙边上“+”按钮连接蓝牙模块,采用SSCOM串口工具连接到usart1上,就可以通过蓝牙通信实现手机(蓝牙调试器)与电脑(串口工具)的通信了,在蓝牙调试器发送数据时,十六进制时需要加上“0A”作为结尾,如果十进制发送时,注意加上换行再发送:/ `; [8 M  f5 [- H( P

9 J1 T( }$ l  ~1 w( O
df172bc6aaa94e678d2c06fb92dbe6a9.png a573139985cc47b79688e2ee52359e8e.png
  [3 g5 {% V/ S! g" J
4 G; R/ z! G" I; H# e. E& O, \' K
        注:本文连接前,点击开发板的按键1更改了蓝牙名称PYFREEBT:
' p2 s! U9 k/ g+ R( T
  1. if(KEY_1())//按下KEY1判断
    1 e8 @& C2 H; E1 W6 D( z
  2.           {* Z& K5 c# C; A+ w. `' v3 Z& m
  3.                   LED_1(1);//LED1控制 //在蓝牙模块回复之前先将LED状态复位5 ~, c9 t. t6 `3 U6 K$ l+ _0 B
  4.                   LED_2(0);//LED2控制
    * e8 w' b6 w+ H# p- }4 r
  5.                   BT_printf("AT+NAMEPYFREEBT");//向蓝牙模块发送AT指令(修改模块的广播名为PYFREEBT)8 i! X! |" S5 D) m8 R
  6.           }
复制代码

' e3 g% A7 h. P' [& ~+ R        串口发送数据:" J5 J5 q/ M. f* x

# a9 j6 ?% [. {/ W
399927e9b5474fd4bafe8534255fab31.png
9 ?; X, a0 A6 @3 W
2 U6 s& i& o, Y* H- Y! d. z

- O! r6 \# V, e        可以进入按钮控制页面进行指令定制设置2 `  {7 c& A" ^( n' W6 j' d

6 f6 j( A8 r5 `6 N0 _; ^
56473e9c27a04fafaa96bc2f0dab5f08.png 9ac0cde743b143e08e391b2d9e793b56.png
1 J/ P1 G6 G  o/ J  f6 j0 v1 ~2 s- G' w, a5 `8 V2 Q
         至此实现了MCU(STM32F103C8T6)通过蓝牙模块与外界设备进行通信,另外通过AT指令也可以控制蓝牙模块。. g5 k* i- z4 y7 d& F
————————————————6 x- L2 y9 j: X
版权声明:py_free-物联智能
6 R- e1 ]9 j) N7 o8 b2 O如有侵权请联系删除
+ j# S& K. q2 q. g& F2 u6 S" x9 t* T" O

5 }0 B8 o; l1 B" O1 z
+ w9 n* x9 X# E
赞 收藏 评论0 发布时间:2023-4-7 15:54

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版