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

7 b4 A% h( F& g/ A+ a' ]一：部分原理图设计：
, m8 r: o2 S2 M$ f( o
  |4 Q: U' }+ A+ d% V& q
7 f/ W4 x: p; l9 J' g
' a3 Q) U9 u& ~2 M  g4 W- P二：PCB图展示：
( B$ b/ {3 N. e* R  i' @) t/ w& g& \! T4 O
$ `+ I9 s$ H7 a# C5 }# i% T4 t. }- n' M

7 p: _; c5 Y6 n+ {, v- h1 W三：软硬件设计的思路：

1 X0 j& ]' l: f在本次项目中使用主控为STM32F103C8T6芯片，当时使用该块芯片是因为该款芯片具有USB功能，该芯片可以虚拟一个USB的串口进行数据交互，而且封装也比较小，在PCB布局方面比较简单。
8 S' m1 h0 x& r) `
- B$ u% s5 T0 @+ ?; N: [无线模块采用的是一款SPI通讯的NRF24L01芯片，在实际的使用过程中比较稳定，可以满足数据之间的交互。
4 Q4 I  V4 j- Q! A/ h
$ I5 c. H) N  R6 Z$ ~6 [# O* D软件设计思路：利用串口1的引脚的接收发送引脚，使用消息队列的方式，可以将USB下发的的数据发送出去。

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

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

+ S3 l/ i: _! c$ ?; qcube软件配置图如下，主要是对该项目中使用到的引脚进行配置

: a: G8 |) |. A3 c. P. T& Y
+ R; V+ j' `8 Q* K7 h部分软件代码：

```abc
" e8 G9 W- {' z) v1 S5 w' X2 M                if(sd == 0)
2 r: n+ G3 a+ R; W$ Y& G2 |  ~                {
                        USART_Cmd(USART2, ENABLE);                    //使能串口
, g5 O. R1 Q8 O* _                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
1 R" a; S4 e/ D8 H3 K2 ]                                        linecoding_old.format != linecoding.format ||
                                        linecoding_old.paritytype != linecoding.paritytype )
                        {
                                if(        usart2_flag == 0 )
                                {
                                        uart2_config_change(linecoding);
                                        memcpy((void *)(&linecoding_old),(void *)&linecoding,sizeof(linecoding));
! c5 N! r+ A9 O7 S- [' F                                }
% ]( Z! X* L- S5 P0 F: b) y' [                        }
                        else if(queue_size(&Qusart2Send) > 0 && usart2_flag == 0)
                        {
                                QueueElementByte data_byte;
                                usart2_flag = 1;
  I" \3 j- d9 k' G( S# E                                if(dequene(&Qusart2Send,&data_byte) == 0 )
                                {
                                        USART_SendData(USART2,data_byte.buffer);
/ U9 k; q9 R5 a                                }
! ~# c7 N. U( v6 c& U6 m! q                                USART_ITConfig(USART2, USART_IT_TXE, ENABLE);//开启ENABLE/关闭DISABLE中断
                        }
              
: K- W( Y" m, \2 L                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
                        {
0 H% z' h8 g; b" J: X                                SetEPRxValid(ENDP6);
1 B& A2 C  N" ^& [                        }
                        if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
                        {
, e. d. H1 l. b6 E/ w                                if(CDC_MAXSIZE - queue_size(&Qusart2Send) >= 64 )
& b+ W1 }' D6 @! ^                                        SetEPRxValid(ENDP4);
                        }

9 e- a, Y6 G, y/ {                        if(nrf_state == 0)
/ p1 z5 P8 ~$ j0 J# M                                NRF24L01_TxPacket(buffer,1);
                }
                else
- Y8 H" y+ [* H$ M: g                {
1 K! _- r& \( a7 ]                        USART_Cmd(USART2, DISABLE);                    //失能串口
, e2 v0 e0 z# v+ V$ }                        if(nrf_state == 0)
" B; e1 E/ J1 i, k2 X5 b$ }  L                        {
                                if(dap2nrf_Data() == -1)
) X$ y, z5 y/ U1 ^; r" r                                {
                              
                                        if(GetEPRxStatus(ENDP6) == EP_RX_NAK)
                                        {
                                                SetEPRxValid(ENDP6);
                                        }
! h9 @; l& q8 h: A) h8 \                              
                                        if(        linecoding_old.bitrate != linecoding.bitrate ||
                                        linecoding_old.datatype != linecoding.datatype ||
2 c; D/ k5 @! B+ q6 r% S8 r, L                                        linecoding_old.format != linecoding.format ||
                                        linecoding_old.paritytype != linecoding.paritytype        )
                                        {
                                                buffer[0] = 33;//特殊串口设置指令
                                                memcpy((void *)(buffer+1),(void *)&linecoding,sizeof(linecoding));
                                                NRF24L01_TxPacket(buffer,sizeof(linecoding)+1);
# p) F; q3 F! ^/ J                                        }
                                        else if(queue_size(&Qusart2Send) > 0)
* g" y  S/ p4 y$ A                                        {
9 G: ?7 V# b& H8 V9 B: O, t, x                                                QueueElementByte data_byte;
                                                for(i = 1; i < 32; i ++)
( y* x3 u* b( C" m                                                {
0 }' l  i$ S$ q& J                                                        if(dequene(&Qusart2Send,&data_byte) == -1 )
! Z% q+ o' D. I                                                                break;
                                                        buffer = data_byte.buffer;
                                                }
, V. E+ V- I3 o                                                buffer[0] = i - 1;
                                                NRF24L01_TxPacket(buffer,buffer[0]+1);
                                        }
. ?/ _7 m0 ^+ L' |1 F                                        else
                                        {
: @' o! B/ C& A9 Z4 O1 f                                                if(GetEPRxStatus(ENDP4) == EP_RX_NAK)
                                                {
                                                        SetEPRxValid(ENDP4);
  h7 @  S; v( E$ K  N4 C  D& w0 M                                                }
                                                buffer[0] = 0;
$ {" t1 g1 y. K; s2 R: Z5 O% d                                                NRF24L01_TxPacket(buffer,1);
                                        }
1 ?( W8 m! O+ t* y8 }. g3 O                              
                                }
                        }
                }
. ^9 v! r% J0 {0 T0 V```

. N  t2 w8 f) M% c实物使用截图如下：

0 a" S% w' @9 R/ b- J: ~& _

& L- V7 h8 M  T( E) R4 ~& R! y& X在实际使用中发现，硬件功耗大概在130ma左右，在数据交互的时候功耗会增加至170ma左右，不过并不影响模块的使用。

, p: k( C. Y1 i- F使用该模块的最大好处就是可以让硬件工程师的桌面更加的整洁。
4 e* Y' k/ M5 _0 ]! n1 c
硬件设计的时候，设计注意事项：
( O, ^" `2 F, e- {9 d
使用PS7516用作升压芯片，将电池电压3.7V升压至5V，为外设可以提供5v的电压输出。

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

PW4054为锂电池充电芯片，可使用type-c为电池充电，充电电流由R26取样电阻设定。
& ^0 S! S9 v. l6 u7 h
* I. D) A7 G5 j6 k$ V/ E+ W3 p同时PL5356A芯片为锂电池电压检测芯片，可以显示当前的电池电量，后期将电池电压分压至单片机的ADC内，从而精准的检测电池电压。

在软件开发时候，有以下的注意事项：

0 X0 n; Q# K, B" l* r7 y* @抗干扰能力：NRF24L01工作在2.4GHz频段，该频段易受到WiFi、蓝牙等设备的干扰。在布局布线时要尽量减少干扰源的影响，并合理设置通信参数以提高抗干扰能力。

( J2 f& r- U# d4 G( ~功耗管理：在不需要通信时及时将NRF24L01置于待机模式或掉电模式以降低功耗。

距离与障碍物：无线通信距离受环境因素影响较大，障碍物会严重影响通信质量。在实际应用中要考虑通信距离和障碍物的影响并采取相应的措施。

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

  i5 E/ e5 w* e. `4 n9 _# ]0 c原理图见附件：
  N& x/ G; T7 H: Y' D6 n- a8 u+ x

0 M. d/ G( ]2 i# n6 e重新上传一下　原理图！！！
7 ^/ h- x% Z& V2 ?8 { 无线下载器原理图.pdf (1.56 MB, 下载次数: 2)

2024-12-25 16:51 上传

点击文件名下载附件