项目设计的前言：作为一个嵌入式的工程师，在编写代码时候，难免会遇到不同电平之间的转换。例如：RS485通讯方式，RS232，TTL信号，为了查看通讯之间数据的正确性，经常使用到不同的电平转换模块，还需要一个USB转串口工具，将数据上传到PC端，这样我们才能将查看控制器或者是负载返回的数据，为了避免调试代码起来方便，让自己的工作变得整洁，方便我们自己的工作，前端时间正好研究SPI通讯方式的NRF24L01这款无线芯片，利用业余时间做了一个无线通讯模块。在这里分享一下开发的经验。

一：部分原理图设计：

" P2 s. w: M% @6 a6 z

; g* A& e5 h6 s; I二：PCB图展示：

$ F- k( m5 l/ r5 h4 B- ]
三：软硬件设计的思路：

, T" R4 m7 I( @' Q0 d  ~在本次项目中使用主控为STM32F103C8T6芯片，当时使用该块芯片是因为该款芯片具有USB功能，该芯片可以虚拟一个USB的串口进行数据交互，而且封装也比较小，在PCB布局方面比较简单。
/ J0 U! L& \5 p+ G- I
: H- X0 L# C2 I0 P无线模块采用的是一款SPI通讯的NRF24L01芯片，在实际的使用过程中比较稳定，可以满足数据之间的交互。
3 E2 [3 w( x  J, P/ W/ {
6 l- z( S' y% b, R软件设计思路：利用串口1的引脚的接收发送引脚，使用消息队列的方式，可以将USB下发的的数据发送出去。

& d: F6 O$ `9 w% s1 A使用串口2完成与SPI之间的交互，

软件配置参数：使用STM32cube MX软件生成USB，SPI，串口底层的驱动部分，这样开发起来也比较容易；

cube软件配置图如下，主要是对该项目中使用到的引脚进行配置

. R1 T( K$ O% W" u8 @( i  k
* y  S" x& d  a$ Z+ U! l& B& p
2 j  e7 i6 ]5 K" y0 l部分软件代码：

9 d9 W1 ?* {& K) Y5 l```abc
5 d7 g6 ?" Q( N; Q. ]                if(sd == 0)
                {
                        USART_Cmd(USART2, ENABLE);                    //使能串口
! d$ v! H0 y: N: s/ V, b! z5 Y                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
" g$ R/ e0 u; Q* p9 b$ l# c  v                                        linecoding_old.format != linecoding.format ||
                                        linecoding_old.paritytype != linecoding.paritytype )
                        {
  n: F9 r' `; Q5 `2 F9 p. j( }5 F+ H0 V                                if(        usart2_flag == 0 )
  s: ?$ H" l: T. O% U$ k  A) ?$ V' m4 N                                {
0 c5 R+ j& g# _- O( H4 z, Y& l  B                                        uart2_config_change(linecoding);
9 i0 H" U) k1 ~3 C( \& ^/ j# Z0 V                                        memcpy((void *)(&linecoding_old),(void *)&linecoding,sizeof(linecoding));
" N. k8 k1 ]# J, L1 ~, ?( ?                                }
. u3 V" O, F8 R) X; Y                        }
                        else if(queue_size(&Qusart2Send) > 0 && usart2_flag == 0)
) X) \; j5 P6 r+ w                        {
; }( Y+ M; [$ [( u8 e& b                                QueueElementByte data_byte;
                                usart2_flag = 1;
. x0 O# L% X8 ?3 h- p7 F; |; T                                if(dequene(&Qusart2Send,&data_byte) == 0 )
) i0 w& Y2 Z& n1 L. b! o7 D                                {
                                        USART_SendData(USART2,data_byte.buffer);
5 t1 Y3 S8 G5 X                                }
' \: C4 k5 i! l  b# f4 ?7 g* r                                USART_ITConfig(USART2, USART_IT_TXE, ENABLE);//开启ENABLE/关闭DISABLE中断
5 [+ C# K6 C8 T, G, S4 M8 \                        }
              
                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
; z- \, a8 O4 |9 D! N9 y+ `2 P" V6 v                        {
                                SetEPRxValid(ENDP6);
                        }
+ ~/ [8 |# j# I( N1 i* n( S: ?                        if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
. ~- f3 U& x1 q7 M$ _1 l                        {
3 `. b3 M' d5 x: j. L                                if(CDC_MAXSIZE - queue_size(&Qusart2Send) >= 64 )
3 ?; W4 h, N. V( D1 [8 Q                                        SetEPRxValid(ENDP4);
                        }

                        if(nrf_state == 0)
( P6 D6 m  `# b: S, Y6 C; X7 M$ n                                NRF24L01_TxPacket(buffer,1);
                }
8 k: ^, g. n9 J9 F+ p* T                else
4 ^* h* E/ @# N: {% v9 _# R8 U                {
' c6 \$ N' E& Z! @$ |                        USART_Cmd(USART2, DISABLE);                    //失能串口
                        if(nrf_state == 0)
                        {
/ N6 ~& Q" I- B$ q                                if(dap2nrf_Data() == -1)
                                {
                              
                                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
* I' O- |9 m" c& V7 |! s                                        {
                                                SetEPRxValid(ENDP6);
                                        }
                              
  H$ t& ]) C( s7 h. [                                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
                                        linecoding_old.format != linecoding.format ||
2 ?$ h1 e* _! m                                        linecoding_old.paritytype != linecoding.paritytype        )
                                        {
                                                buffer[0] = 33;//特殊串口设置指令
( ?8 O: |) T' _8 n: H+ O                                                memcpy((void *)(buffer+1),(void *)&linecoding,sizeof(linecoding));
% ]& ^; [" ~+ a  H" F                                                NRF24L01_TxPacket(buffer,sizeof(linecoding)+1);
9 J. I1 E! i; E1 M8 ]+ V                                        }
8 V; s; W3 U1 d$ _4 H: O                                        else if(queue_size(&Qusart2Send) > 0)
; l$ H, h! ]# P/ C1 j5 ], {                                        {
                                                QueueElementByte data_byte;
                                                for(i = 1; i < 32; i ++)
                                                {
0 U% e6 |7 t! Z                                                        if(dequene(&Qusart2Send,&data_byte) == -1 )
                                                                break;
                                                        buffer = data_byte.buffer;
4 y( t5 C( _' e8 g/ \- I0 o) a. H                                                }
                                                buffer[0] = i - 1;
                                                NRF24L01_TxPacket(buffer,buffer[0]+1);
  p6 P& v8 i& p4 g9 h                                        }
. T6 S% s& B: B% h0 ?: N                                        else
/ `2 ?4 L! l) e  n                                        {
                                                if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
                                                {
" a' R) u3 k% ^: l" l                                                        SetEPRxValid(ENDP4);
                                                }
                                                buffer[0] = 0;
                                                NRF24L01_TxPacket(buffer,1);
- e- j. ^! Y( p                                        }
                              
, z: ]  y1 _/ o. ^- C                                }
                        }
( N& S% \! p! i1 J) m                }
+ \! e/ Q$ ~! ]/ B```
6 y3 _$ {  a9 z( v" W
实物使用截图如下：

4 S9 @2 S1 G# e' ?" D* M0 `% P6 W
3 |; ]* f1 Y$ W1 L+ Q5 ?
7 t& _/ y. n' X" y在实际使用中发现，硬件功耗大概在130ma左右，在数据交互的时候功耗会增加至170ma左右，不过并不影响模块的使用。

使用该模块的最大好处就是可以让硬件工程师的桌面更加的整洁。

2 @1 \  V* X% h1 i1 M' F6 S硬件设计的时候，设计注意事项：

% u4 y5 f( @5 N1 s- I" W使用PS7516用作升压芯片，将电池电压3.7V升压至5V，为外设可以提供5v的电压输出。
+ n+ @: S& f/ C$ U9 d* M$ s
# |9 G3 c( F5 U! T. Y' \2 j, RMP2155为降压型LDO，具有可关断功能，当不使用时候，可以使整个系统处于低功耗状态，从而延长电池寿命。
5 O( P; H: n* z' q4 u5 u. M! R
PW4054为锂电池充电芯片，可使用type-c为电池充电，充电电流由R26取样电阻设定。
+ S' x2 {' ^. o5 _7 H9 K, {7 d
0 v/ T' F  }, D9 ^) }( _同时PL5356A芯片为锂电池电压检测芯片，可以显示当前的电池电量，后期将电池电压分压至单片机的ADC内，从而精准的检测电池电压。

( g. A- S4 V4 A在软件开发时候，有以下的注意事项：
! p% d7 y% u% U  \4 b- d8 H, v( W
抗干扰能力：NRF24L01工作在2.4GHz频段，该频段易受到WiFi、蓝牙等设备的干扰。在布局布线时要尽量减少干扰源的影响，并合理设置通信参数以提高抗干扰能力。
( `! y; U: v) D- `: b. ?* n% L. W
( k: C6 N! y' p9 k7 e功耗管理：在不需要通信时及时将NRF24L01置于待机模式或掉电模式以降低功耗。
) b' @# A0 O8 m. u( U
# F1 F: \: U7 T- ]7 [距离与障碍物：无线通信距离受环境因素影响较大，障碍物会严重影响通信质量。在实际应用中要考虑通信距离和障碍物的影响并采取相应的措施。
( @. Y9 c8 g7 v6 u% c/ n
, h9 Z( g, U. Q- A; n5 x' K0 ANRF24L01的开发过程需要仔细规划硬件连接、合理配置软件参数、掌握调试技巧并关注实际应用中的注意事项。通过不断的实践和总结可以逐渐提高开发效率和应用效果。
9 D( v- N+ l8 S# V3 Z7 H
6 |9 E! B& e3 U原理图见附件：
2 s- y+ x6 _" I' ?5 m
* o& h4 h8 w) z2 ^# v8 ^6 Y
" s: o, e1 u- w3 F* ]" T

7 e1 K# l9 ]* h0 u8 \重新上传一下　原理图！！！
无线下载器原理图.pdf (1.56 MB, 下载次数: 2)

2024-12-25 16:51 上传

点击文件名下载附件
! e( ]3 Z- d) d+ r) Z