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

一：部分原理图设计：
5 ~  R- k9 |. z0 G

3 @' m1 D0 ~+ r' _二：PCB图展示：

6 W- k. R& k% j& h. i% J7 \$ o
' t/ L: P6 Z4 ?2 O6 c三：软硬件设计的思路：
3 z0 @6 H" I5 [/ V1 t0 }5 m
在本次项目中使用主控为STM32F103C8T6芯片，当时使用该块芯片是因为该款芯片具有USB功能，该芯片可以虚拟一个USB的串口进行数据交互，而且封装也比较小，在PCB布局方面比较简单。
" l" r1 `! s9 Z1 d5 C. @  J1 s6 J
无线模块采用的是一款SPI通讯的NRF24L01芯片，在实际的使用过程中比较稳定，可以满足数据之间的交互。
( Z8 L9 e; N9 E
" ]2 o: `. G0 Q软件设计思路：利用串口1的引脚的接收发送引脚，使用消息队列的方式，可以将USB下发的的数据发送出去。
! z2 X5 k0 {4 }
使用串口2完成与SPI之间的交互，
- Z, d' X) t# }3 T0 H: S
+ P" F7 U; i( p7 v软件配置参数：使用STM32cube MX软件生成USB，SPI，串口底层的驱动部分，这样开发起来也比较容易；

cube软件配置图如下，主要是对该项目中使用到的引脚进行配置
$ s! B; S5 j; `5 v

) q/ \  F7 i  s" u' Z/ u5 K部分软件代码：
7 Q( X& ?6 Q# \
; n7 i- J$ X( T8 P```abc
                if(sd == 0)
                {
                        USART_Cmd(USART2, ENABLE);                    //使能串口
; d5 e0 q* K/ e# E3 ~& F                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
7 N8 c7 v/ P! {: Q/ m6 w* \                                        linecoding_old.format != linecoding.format ||
6 ?6 |" h& h, [9 n                                        linecoding_old.paritytype != linecoding.paritytype )
1 a( G$ G" p+ b& o8 c# U                        {
( Y8 [  z. _/ I* n; l7 V                                if(        usart2_flag == 0 )
                                {
- G# y8 W) H9 Q6 |. c                                        uart2_config_change(linecoding);
                                        memcpy((void *)(&linecoding_old),(void *)&linecoding,sizeof(linecoding));
                                }
                        }
                        else if(queue_size(&Qusart2Send) > 0 && usart2_flag == 0)
3 A8 b& F, ], I4 x9 i" G1 f                        {
                                QueueElementByte data_byte;
                                usart2_flag = 1;
8 u7 q- O* j( u* n                                if(dequene(&Qusart2Send,&data_byte) == 0 )
                                {
                                        USART_SendData(USART2,data_byte.buffer);
8 x+ I2 O0 o% b5 @. s- M4 x$ H                                }
                                USART_ITConfig(USART2, USART_IT_TXE, ENABLE);//开启ENABLE/关闭DISABLE中断
. t) g7 L9 Y0 h' b6 V- Z                        }
2 _1 @" y2 \* y0 C, @              
7 j8 W& W5 F3 m# e                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
                        {
                                SetEPRxValid(ENDP6);
                        }
                        if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
                        {
                                if(CDC_MAXSIZE - queue_size(&Qusart2Send) >= 64 )
                                        SetEPRxValid(ENDP4);
                        }

                        if(nrf_state == 0)
                                NRF24L01_TxPacket(buffer,1);
                }
1 {7 w' Q( P5 h6 o5 l  d                else
  R4 {; a! k- X8 f9 J" d$ t+ X                {
                        USART_Cmd(USART2, DISABLE);                    //失能串口
                        if(nrf_state == 0)
7 g$ V' _6 G& c* V                        {
                                if(dap2nrf_Data() == -1)
5 Y% D, _8 ?: S5 Y$ `' @! }- a                                {
+ C, z" Y! ^% J6 Z/ e                              
                                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
5 z- u$ j) U% _! X                                        {
                                                SetEPRxValid(ENDP6);
- y* S8 C, c' ?5 x                                        }
- O% S' b2 n8 g' r                              
* x) ~& `9 J: s! Z- m                                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
) R1 R# g* a* m& @" U  J6 V* \3 t                                        linecoding_old.format != linecoding.format ||
                                        linecoding_old.paritytype != linecoding.paritytype        )
# n8 i, H. E8 L; W4 f                                        {
                                                buffer[0] = 33;//特殊串口设置指令
                                                memcpy((void *)(buffer+1),(void *)&linecoding,sizeof(linecoding));
- ]1 M+ j& l! }9 R4 U/ e                                                NRF24L01_TxPacket(buffer,sizeof(linecoding)+1);
% O- }3 k# v& M+ ^; E& p3 k                                        }
" Q: B  p# }/ d# r) l8 P9 D                                        else if(queue_size(&Qusart2Send) > 0)
                                        {
                                                QueueElementByte data_byte;
2 D# h( [5 @1 L" ~+ @) Q! g; d, C                                                for(i = 1; i < 32; i ++)
                                                {
, @6 l2 o2 v7 a8 s                                                        if(dequene(&Qusart2Send,&data_byte) == -1 )
! `2 [) S& x0 J( h5 `' z                                                                break;
! J. U/ S  u5 L/ T                                                        buffer = data_byte.buffer;
                                                }
                                                buffer[0] = i - 1;
                                                NRF24L01_TxPacket(buffer,buffer[0]+1);
7 _) j' T: V) q( Z; R                                        }
                                        else
                                        {
                                                if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
, \) T  f: ~. @8 e/ q                                                {
                                                        SetEPRxValid(ENDP4);
                                                }
                                                buffer[0] = 0;
                                                NRF24L01_TxPacket(buffer,1);
. \( c, V( v' @" y) p                                        }
                              
1 d! @' O8 }/ L; ]: d, h                                }
                        }
3 H9 n) ?/ F3 o5 @1 b                }
```
* ~8 W/ L1 h5 _4 V2 N: a
: `7 A, K) P3 G' s9 v5 w% Y% \实物使用截图如下：

4 Q4 k2 f, Z5 {
在实际使用中发现，硬件功耗大概在130ma左右，在数据交互的时候功耗会增加至170ma左右，不过并不影响模块的使用。

使用该模块的最大好处就是可以让硬件工程师的桌面更加的整洁。
3 b3 b1 G4 j5 n5 i3 q
5 i9 Z/ J; C- c8 P& F6 V硬件设计的时候，设计注意事项：
* ?- n- G* K+ L! F
8 W! R0 h: D! V3 K- c使用PS7516用作升压芯片，将电池电压3.7V升压至5V，为外设可以提供5v的电压输出。

' [& f: S# F, x+ d( CMP2155为降压型LDO，具有可关断功能，当不使用时候，可以使整个系统处于低功耗状态，从而延长电池寿命。
& k9 f% e3 n; c! k, Z9 E* R
" d4 ~8 P# a4 M$ w9 gPW4054为锂电池充电芯片，可使用type-c为电池充电，充电电流由R26取样电阻设定。
' \0 d6 W+ y: k, t1 o. r, w2 Y
同时PL5356A芯片为锂电池电压检测芯片，可以显示当前的电池电量，后期将电池电压分压至单片机的ADC内，从而精准的检测电池电压。
: `) Y5 Y/ b5 z0 q
在软件开发时候，有以下的注意事项：
7 a9 m4 ]( G8 H- L. i
, B+ p* Q. f% D抗干扰能力：NRF24L01工作在2.4GHz频段，该频段易受到WiFi、蓝牙等设备的干扰。在布局布线时要尽量减少干扰源的影响，并合理设置通信参数以提高抗干扰能力。
, Y* T( u7 h/ I% h; Z
功耗管理：在不需要通信时及时将NRF24L01置于待机模式或掉电模式以降低功耗。

0 _4 g! [: u4 C; ~7 o: d4 k1 U: b2 W距离与障碍物：无线通信距离受环境因素影响较大，障碍物会严重影响通信质量。在实际应用中要考虑通信距离和障碍物的影响并采取相应的措施。
8 a5 @* K7 e" H
( l, p3 G+ x) N4 h( BNRF24L01的开发过程需要仔细规划硬件连接、合理配置软件参数、掌握调试技巧并关注实际应用中的注意事项。通过不断的实践和总结可以逐渐提高开发效率和应用效果。
6 O, I+ w5 J* f2 G' T: b9 B
原理图见附件：
1 L0 K* N. M/ ~6 W( b/ S
3 b9 T* s. [, o0 ]4 X
, q! T8 _* ]1 I" r/ P8 E

, h0 \# H! x% u. K8 `* _重新上传一下　原理图！！！
3 ]5 d* b3 `' G$ ?3 \& E& o/ {* S 无线下载器原理图.pdf (1.56 MB, 下载次数: 2)

2024-12-25 16:51 上传

点击文件名下载附件
( A5 e$ Y8 V1 U2 K