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

/ ?% u& }  q1 b( h  a9 G" x一：部分原理图设计：
% i0 h& y9 v! Q8 h1 ?
; x7 l; ?4 E- S- d& \! G
- C; J  K! s. e3 [二：PCB图展示：
4 l# e( n. ~1 i9 \1 i

三：软硬件设计的思路：

在本次项目中使用主控为STM32F103C8T6芯片，当时使用该块芯片是因为该款芯片具有USB功能，该芯片可以虚拟一个USB的串口进行数据交互，而且封装也比较小，在PCB布局方面比较简单。
: c# D/ M; w$ }8 d& F$ g2 d
无线模块采用的是一款SPI通讯的NRF24L01芯片，在实际的使用过程中比较稳定，可以满足数据之间的交互。

软件设计思路：利用串口1的引脚的接收发送引脚，使用消息队列的方式，可以将USB下发的的数据发送出去。

使用串口2完成与SPI之间的交互，

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

) i2 W/ B/ y$ A9 n: ]5 y6 Vcube软件配置图如下，主要是对该项目中使用到的引脚进行配置
' a0 `  Y9 v% K/ l) ~2 J

+ X: {. j& ~$ y% u4 V+ H! K# S3 G部分软件代码：
1 ?6 w4 |" f( Q. g% `' t* L) m
```abc
                if(sd == 0)
                {
  P0 P" I* J" q9 K. X. N/ \                        USART_Cmd(USART2, ENABLE);                    //使能串口
5 E7 p/ ^2 H( D: }% J( j+ u4 k                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
                                        linecoding_old.format != linecoding.format ||
                                        linecoding_old.paritytype != linecoding.paritytype )
  P& b6 s+ F0 A$ m, s( i                        {
                                if(        usart2_flag == 0 )
                                {
                                        uart2_config_change(linecoding);
/ v$ M2 C& H5 Q) I; o                                        memcpy((void *)(&linecoding_old),(void *)&linecoding,sizeof(linecoding));
5 W' ^. S) `/ Q                                }
3 G2 x  P* N1 Y4 d0 V" S0 x5 `                        }
                        else if(queue_size(&Qusart2Send) > 0 && usart2_flag == 0)
$ C2 t+ F" C( D2 r; M                        {
                                QueueElementByte data_byte;
                                usart2_flag = 1;
6 n5 C: W: D5 n% ?) ^- ?6 y                                if(dequene(&Qusart2Send,&data_byte) == 0 )
# u$ I$ f* `1 k3 |0 |% L, |                                {
                                        USART_SendData(USART2,data_byte.buffer);
                                }
                                USART_ITConfig(USART2, USART_IT_TXE, ENABLE);//开启ENABLE/关闭DISABLE中断
                        }
3 Z" G3 K& ~9 t              
                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
                        {
                                SetEPRxValid(ENDP6);
                        }
: ~& c! a2 M8 G! s. m+ ~. a  c                        if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
3 h1 f/ s2 Y# |- a9 U1 B                        {
                                if(CDC_MAXSIZE - queue_size(&Qusart2Send) >= 64 )
' A: W% j( g* T  @                                        SetEPRxValid(ENDP4);
% q1 I' V: {8 w2 H$ _) i1 [                        }
& k& L- {" T# ], _! {- ?  N  r
                        if(nrf_state == 0)
                                NRF24L01_TxPacket(buffer,1);
" t9 a, I; j8 D1 f+ i& T                }
                else
: u1 a, I4 Z; r/ [# J                {
1 ?' y+ b$ q& f  ]                        USART_Cmd(USART2, DISABLE);                    //失能串口
/ ^" t2 S$ f% P9 k                        if(nrf_state == 0)
                        {
                                if(dap2nrf_Data() == -1)
" K- N6 K3 u6 w, ]                                {
                              
                                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
9 A2 ^& L& R4 \9 p/ F7 B                                        {
                                                SetEPRxValid(ENDP6);
/ p* q; h0 Z1 {+ N' E                                        }
                              
2 _/ ~9 M8 g: [$ ^, M                                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
2 \, V% i! g; O, j( P; ]  J! {                                        linecoding_old.format != linecoding.format ||
/ V: a% f$ w' K                                        linecoding_old.paritytype != linecoding.paritytype        )
7 u' k3 y& k* M) `4 w9 j- q# Y% a8 U                                        {
                                                buffer[0] = 33;//特殊串口设置指令
8 r2 N2 r% _! ?* m5 v. T                                                memcpy((void *)(buffer+1),(void *)&linecoding,sizeof(linecoding));
8 |# k9 T3 ?& t6 u4 a* a3 l                                                NRF24L01_TxPacket(buffer,sizeof(linecoding)+1);
8 I9 G, U, r( b" z/ H7 m                                        }
                                        else if(queue_size(&Qusart2Send) > 0)
                                        {
" ~/ h2 |2 N# p5 B/ G8 T" u                                                QueueElementByte data_byte;
                                                for(i = 1; i < 32; i ++)
                                                {
+ z, x2 w  D; l; N4 X) t+ }0 G6 I/ k                                                        if(dequene(&Qusart2Send,&data_byte) == -1 )
                                                                break;
                                                        buffer = data_byte.buffer;
& o4 t- v2 u# u( O7 `                                                }
                                                buffer[0] = i - 1;
                                                NRF24L01_TxPacket(buffer,buffer[0]+1);
                                        }
$ E2 d" R0 \4 E- `  V" m                                        else
                                        {
6 l' C& x) n6 |/ ]5 f* d" m                                                if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
                                                {
                                                        SetEPRxValid(ENDP4);
5 Y. o+ N3 n5 i- p$ R2 ]( h                                                }
                                                buffer[0] = 0;
                                                NRF24L01_TxPacket(buffer,1);
                                        }
                              
) v/ H; {, z. s# Q                                }
                        }
. q% O/ w- H4 m, |& H                }
9 _6 C  h  Y. a, U: j& ]/ f```

/ e, k3 @  f, k& y+ f$ Z0 l实物使用截图如下：

9 I5 K+ }) L$ i* ~9 L6 `
, q: v; P, L5 T# s  X在实际使用中发现，硬件功耗大概在130ma左右，在数据交互的时候功耗会增加至170ma左右，不过并不影响模块的使用。
2 `3 s, `/ O5 g' T/ h
2 b9 K1 ~! k' k+ `使用该模块的最大好处就是可以让硬件工程师的桌面更加的整洁。

硬件设计的时候，设计注意事项：
2 l( V: o- [6 [  f/ n% ]
使用PS7516用作升压芯片，将电池电压3.7V升压至5V，为外设可以提供5v的电压输出。

MP2155为降压型LDO，具有可关断功能，当不使用时候，可以使整个系统处于低功耗状态，从而延长电池寿命。

  \: c7 c3 M- M6 H+ gPW4054为锂电池充电芯片，可使用type-c为电池充电，充电电流由R26取样电阻设定。

) d, G6 f# G3 h2 W0 `$ M8 y+ @" c$ X同时PL5356A芯片为锂电池电压检测芯片，可以显示当前的电池电量，后期将电池电压分压至单片机的ADC内，从而精准的检测电池电压。

在软件开发时候，有以下的注意事项：
% i7 l3 Y4 [* P, t2 S, P
7 d3 r2 K; [) c5 z抗干扰能力：NRF24L01工作在2.4GHz频段，该频段易受到WiFi、蓝牙等设备的干扰。在布局布线时要尽量减少干扰源的影响，并合理设置通信参数以提高抗干扰能力。
0 R- B; _+ X( d" ~# {
功耗管理：在不需要通信时及时将NRF24L01置于待机模式或掉电模式以降低功耗。
, ?6 c5 ^2 m! U$ R
+ N7 B5 P! `4 U( H/ n1 I距离与障碍物：无线通信距离受环境因素影响较大，障碍物会严重影响通信质量。在实际应用中要考虑通信距离和障碍物的影响并采取相应的措施。

NRF24L01的开发过程需要仔细规划硬件连接、合理配置软件参数、掌握调试技巧并关注实际应用中的注意事项。通过不断的实践和总结可以逐渐提高开发效率和应用效果。

原理图见附件：
3 m' s" i: M' L8 Q: e7 }) q& J
. T2 {% j- Q$ h! h. W" u" |

, _5 Z7 w" x. D" {6 v) Z, e

0 ]" j$ G$ _& s4 g* g4 Z% x重新上传一下　原理图！！！
& k8 e1 y5 \5 }1 l" M 无线下载器原理图.pdf (1.56 MB, 下载次数: 2)

2024-12-25 16:51 上传

点击文件名下载附件
+ P" [! Q0 W5 B% W& F3 r