设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › NRF24L01在STM32开发板烧录或复位接收不到数据
返回列表 发新帖
查看: 1239|回复: 3
打印 上一主题 下一主题
收起左侧

NRF24L01在STM32开发板烧录或复位接收不到数据

[复制链接]
跳转到指定楼层
楼主
ID:932115 发表于 2022-3-11 22:59 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
NRF24L01在开发板烧录或按下复位接收不到数据，只有把模块拔掉再插上才能正常接收，不然一直没有反应模块检测也能通过，大佬们这种情况怎么办，下面是初始化代码
  1. void RF24L01_Init( void )
  2. {
  3.     uint8_t addr[5] = {INIT_ADDR};

  5.     RF24L01_SET_CE_HIGH( );//CE拉高
  6.     //IRQ_ALL  ( (1<<RX_DR) | (1<<TX_DS) | (1<<MAX_RT) )
  7.     NRF24L01_Clear_IRQ_Flag( IRQ_ALL );
  8.     //0xE2 命令
  9.     NRF24L01_Flush_Rx_Fifo();//清除接收缓冲区
  10. //DYNAMIC_PACKET      1
  11. #if DYNAMIC_PACKET == 1
  12.     //DYNPD   0x1c
  13.     NRF24L01_Write_Reg( DYNPD, ( 1 << 0 ) );         //使能通道1动态数据长度
  14.     //FEATRUE  0x1d
  15.     NRF24L01_Write_Reg( FEATRUE, 0x07 );
  16.     //DYNPD  0x1c
  17.     NRF24L01_Read_Reg( DYNPD );
  18.     //FEATRUE  0x1d
  19.     NRF24L01_Read_Reg( FEATRUE );
  20.         
  21. #elif DYNAMIC_PACKET == 0//不执行
  22.    
  23.     L01_WriteSingleReg( L01REG_RX_PW_P0, FIXED_PACKET_LEN );        //固定数据长度
  24.    
  25. //DYNAMIC_PACKET      1
  26. #endif        //DYNAMIC_PACKET
  27.   // CONFIG 0x00       EN_CRC 3         PWR_UP 1
  28.     NRF24L01_Write_Reg( CONFIG, /*( 1<<MASK_RX_DR ) |*/                //接收中断
  29.                                       ( 1 << EN_CRC ) |     //使能CRC 1个字节
  30.                                       ( 1 << PWR_UP ) );    //开启设备
  31.     //EN_AA 0x01       ENAA_P0  0
  32.     NRF24L01_Write_Reg( EN_AA, ( 1 << ENAA_P0 ) );                   //通道0自动应答
  33.     //EN_RXADDR  0x02     ERX_P0   0
  34.     NRF24L01_Write_Reg( EN_RXADDR, ( 1 << ERX_P0 ) );                //通道0接收
  35.     //SETUP_AW   0x03     AW_5BYTES 0x3
  36.     NRF24L01_Write_Reg( SETUP_AW, AW_5BYTES );                             //地址宽度 5个字节
  37.     //SETUP_RETR  0x04    ARD_4000US (0x0F<<4)   REPEAT_CNT  15
  38.     NRF24L01_Write_Reg( SETUP_RETR, ARD_4000US |
  39.                         ( REPEAT_CNT & 0x0F ) );                 //重复等待时间 250us
  40.     //RF_CH  0x05
  41.     NRF24L01_Write_Reg( RF_CH, 60 );                                     //初始化通道
  42.     //RF_SETUP  0x06
  43.     NRF24L01_Write_Reg( RF_SETUP, 0x26 );
  44.     //{0x34,0x43,0x10,0x10,0x01}
  45.     NRF24L01_Set_TxAddr( &addr[0], 5 );                      //设置TX地址
  46.     NRF24L01_Set_RxAddr( 0, &addr[0], 5 );                   //设置RX地址
  47. }
复制代码



分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:932115 发表于 2022-3-11 23:01 | 只看该作者
开发板使用的是STM32F407VET6
回复

使用道具 举报

板凳
ID:276663 发表于 2022-3-12 10:08 | 只看该作者
就这些代码你让看啥？
回复

使用道具 举报

地板
ID:932115 发表于 2022-3-12 12:06 | 只看该作者
IdeaMing 发表于 2022-3-12 10:08
就这些代码你让看啥？

大佬这是其他代码
  1. #include "stm32f4xx.h"
  2. #include "nrf24l01.h"
  3. #include "sys.h"
  4. #include <stdio.h>

  6. const char *g_ErrorString = "RF24L01 is not find !...";

  8. /**
  9.   * @brief :NRF24L01读寄存器
  10.   * @param :
  11.            @Addr:寄存器地址
  12.   * @note  :地址在设备中有效
  13.   * @retval:读取的数据
  14.   */
  15. uint8_t NRF24L01_Read_Reg( uint8_t RegAddr )
  16. {
  17.     uint8_t btmp;
  18.        
  19.     RF24L01_SET_CS_LOW( );                        //片选
  20.        
  21.     drv_spi_read_write_byte( NRF_READ_REG | RegAddr );        //读命令 地址
  22.     btmp = drv_spi_read_write_byte( 0xFF );                                //读数据
  23.        
  24.     RF24L01_SET_CS_HIGH( );                        //取消片选
  25.        
  26.     return btmp;
  27. }

  29. /**
  30.   * @brief :NRF24L01读指定长度的数据
  31.   * @param :
  32.   *                        @reg:地址
  33.   *                        @pBuf:数据存放地址
  34.   *                        @len:数据长度
  35.   * @note  :数据长度不超过255，地址在设备中有效
  36.   * @retval:读取状态
  37.   */
  38. void NRF24L01_Read_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
  39. {
  40.     uint8_t btmp;
  41.        
  42.     RF24L01_SET_CS_LOW( );                        //片选
  43.        
  44.     drv_spi_read_write_byte( NRF_READ_REG | RegAddr );        //读命令 地址
  45.     for( btmp = 0; btmp < len; btmp ++ )
  46.     {
  47.         *( pBuf + btmp ) = drv_spi_read_write_byte( 0xFF );        //读数据
  48.     }
  49.     RF24L01_SET_CS_HIGH( );                //取消片选
  50. }

  52. /**
  53.   * @brief :NRF24L01写寄存器
  54.   * @param :无
  55.   * @note  :地址在设备中有效
  56.   * @retval:读写状态
  57.   */
  58. void NRF24L01_Write_Reg( uint8_t RegAddr, uint8_t Value )
  59. {
  60.     RF24L01_SET_CS_LOW( );                //片选
  61.        
  62.     drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );        //写命令 地址
  63.     drv_spi_read_write_byte( Value );                        //写数据
  64.        
  65.     RF24L01_SET_CS_HIGH( );                //取消片选
  66. }

  68. /**
  69.   * @brief :NRF24L01写指定长度的数据
  70.   * @param :
  71.   *                        @reg:地址
  72.   *                        @pBuf:写入的数据地址
  73.   *                        @len:数据长度
  74.   * @note  :数据长度不超过255，地址在设备中有效
  75.   * @retval:写状态
  76.   */
  77. void NRF24L01_Write_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
  78. {
  79.     uint8_t i;
  80.        
  81.     RF24L01_SET_CS_LOW( );                //片选
  82.        
  83.     drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );        //写命令 地址
  84.     for( i = 0; i < len; i ++ )
  85.     {
  86.         drv_spi_read_write_byte( *( pBuf + i ) );                //写数据
  87.     }
  88.        
  89.     RF24L01_SET_CS_HIGH( );                //取消片选
  90. }

  92. /**
  93.   * @brief :清空TX缓冲区
  94.   * @param :无
  95.   * @note  :无
  96.   * @retval:无
  97.   */
  98. void NRF24L01_Flush_Tx_Fifo ( void )
  99. {
  100.     RF24L01_SET_CS_LOW( );                //片选
  101.        
  102.     drv_spi_read_write_byte( FLUSH_TX );        //清TX FIFO命令
  103.        
  104.     RF24L01_SET_CS_HIGH( );                //取消片选
  105. }

  107. /**
  108.   * @brief :清空RX缓冲区
  109.   * @param :无
  110.   * @note  :无
  111.   * @retval:无
  112.   */
  113. void NRF24L01_Flush_Rx_Fifo( void )
  114. {
  115.     RF24L01_SET_CS_LOW( );                //片选
  116.        
  117.     drv_spi_read_write_byte( FLUSH_RX );        //清RX FIFO命令
  118.        
  119.     RF24L01_SET_CS_HIGH( );                //取消片选
  120. }

  122. /**
  123.   * @brief :重新使用上一包数据
  124.   * @param :无
  125.   * @note  :无
  126.   * @retval:无
  127.   */
  128. void NRF24L01_Reuse_Tx_Payload( void )
  129. {
  130.     RF24L01_SET_CS_LOW( );                //片选
  131.        
  132.     drv_spi_read_write_byte( REUSE_TX_PL );                //重新使用上一包命令
  133.        
  134.     RF24L01_SET_CS_HIGH( );                //取消片选
  135. }

  137. /**
  138.   * @brief :NRF24L01空操作
  139.   * @param :无
  140.   * @note  :无
  141.   * @retval:无
  142.   */
  143. void NRF24L01_Nop( void )
  144. {
  145.     RF24L01_SET_CS_LOW( );                //片选
  146.        
  147.     drv_spi_read_write_byte( NOP );                //空操作命令
  148.        
  149.     RF24L01_SET_CS_HIGH( );                //取消片选
  150. }

  152. /**
  153.   * @brief :NRF24L01读状态寄存器
  154.   * @param :无
  155.   * @note  :无
  156.   * @retval:RF24L01状态
  157.   */
  158. uint8_t NRF24L01_Read_Status_Register( void )
  159. {
  160.     uint8_t Status;
  161.        
  162.     RF24L01_SET_CS_LOW( );                //片选
  163.        
  164.     Status = drv_spi_read_write_byte( NRF_READ_REG + STATUS );        //读状态寄存器
  165.        
  166.     RF24L01_SET_CS_HIGH( );                //取消片选
  167.        
  168.     return Status;
  169. }

  171. /**
  172.   * @brief :NRF24L01清中断
  173.   * @param :
  174.            @IRQ_Source:中断源
  175.   * @note  :无
  176.   * @retval:清除后状态寄存器的值
  177.   */
  178. uint8_t NRF24L01_Clear_IRQ_Flag( uint8_t IRQ_Source )
  179. {
  180.     uint8_t btmp = 0;

  182.     IRQ_Source &= ( 1 << RX_DR ) | ( 1 << TX_DS ) | ( 1 << MAX_RT );        //中断标志处理
  183.     btmp = NRF24L01_Read_Status_Register( );                        //读状态寄存器
  184.                
  185.     RF24L01_SET_CS_LOW( );                        //片选
  186.     drv_spi_read_write_byte( NRF_WRITE_REG + STATUS );        //写状态寄存器命令
  187.     drv_spi_read_write_byte( IRQ_Source | btmp );                //清相应中断标志
  188.     RF24L01_SET_CS_HIGH( );                        //取消片选
  189.        
  190.     return ( NRF24L01_Read_Status_Register( ));                        //返回状态寄存器状态
  191. }

  193. /**
  194.   * @brief :读RF24L01中断状态
  195.   * @param :无
  196.   * @note  :无
  197.   * @retval:中断状态
  198.   */
  199. uint8_t RF24L01_Read_IRQ_Status( void )
  200. {
  201.     return ( NRF24L01_Read_Status_Register( ) & (( 1 << RX_DR ) | ( 1 << TX_DS ) | ( 1 << MAX_RT )));        //返回中断状态
  202. }

  204. /**
  205.   * @brief :读FIFO中数据宽度
  206.   * @param :无
  207.   * @note  :无
  208.   * @retval:数据宽度
  209.   */
  210. uint8_t NRF24L01_Read_Top_Fifo_Width( void )
  211. {
  212.     uint8_t btmp;
  213.        
  214.     RF24L01_SET_CS_LOW( );                //片选
  215.        
  216.     drv_spi_read_write_byte( R_RX_PL_WID );        //读FIFO中数据宽度命令
  217.     btmp = drv_spi_read_write_byte( 0xFF );        //读数据
  218.        
  219.     RF24L01_SET_CS_HIGH( );                //取消片选
  220.        
  221.     return btmp;
  222. }

  224. /**
  225.   * @brief :读接收到的数据
  226.   * @param :无
  227.   * @note  :无
  228.   * @retval:
  229.            @pRxBuf:数据存放地址首地址
  230.   */
  231. uint8_t NRF24L01_Read_Rx_Payload( uint8_t *pRxBuf )
  232. {
  233.     uint8_t Width, PipeNum;
  234.        
  235.     PipeNum = ( NRF24L01_Read_Reg( STATUS ) >> 1 ) & 0x07;        //读接收状态
  236.     Width = NRF24L01_Read_Top_Fifo_Width( );                //读接收数据个数

  238.     RF24L01_SET_CS_LOW( );                //片选
  239.     drv_spi_read_write_byte( RD_RX_PLOAD );                        //读有效数据命令
  240.        
  241.     for( PipeNum = 0; PipeNum < Width; PipeNum ++ )
  242.     {
  243.         *( pRxBuf + PipeNum ) = drv_spi_read_write_byte( 0xFF );                //读数据
  244.     }
  245.     RF24L01_SET_CS_HIGH( );                //取消片选
  246.     NRF24L01_Flush_Rx_Fifo( );        //清空RX FIFO
  247.        
  248.     return Width;
  249. }

  251. /**
  252.   * @brief :发送数据（带应答）
  253.   * @param :
  254.   *                        @pTxBuf:发送数据地址
  255.   *                        @len:长度
  256.   * @note  :一次不超过32个字节
  257.   * @retval:无
  258.   */
  259. void NRF24L01_Write_Tx_Payload_Ack( uint8_t *pTxBuf, uint8_t len )
  260. {
  261.     uint8_t btmp;
  262.     uint8_t length = ( len > 32 ) ? 32 : len;                //数据长达大约32 则只发送32个

  264.     NRF24L01_Flush_Tx_Fifo( );                //清TX FIFO
  265.        
  266.     RF24L01_SET_CS_LOW( );                        //片选
  267.     drv_spi_read_write_byte( WR_TX_PLOAD );        //发送命令
  268.        
  269.     for( btmp = 0; btmp < length; btmp ++ )
  270.     {
  271.         drv_spi_read_write_byte( *( pTxBuf + btmp ) );        //发送数据
  272.     }
  273.     RF24L01_SET_CS_HIGH( );                        //取消片选
  274. }

  276. /**
  277.   * @brief :发送数据（不带应答）
  278.   * @param :
  279.   *                        @pTxBuf:发送数据地址
  280.   *                        @len:长度
  281.   * @note  :一次不超过32个字节
  282.   * @retval:无
  283.   */
  284. void NRF24L01_Write_Tx_Payload_NoAck( uint8_t *pTxBuf, uint8_t len )
  285. {
  286.     if( len > 32 || len == 0 )
  287.     {
  288.         return ;                //数据长度大于32 或者等于0 不执行
  289.     }
  290.        
  291.     RF24L01_SET_CS_LOW( );        //片选
  292.     drv_spi_read_write_byte( WR_TX_PLOAD_NACK );        //发送命令
  293.     while( len-- )
  294.     {
  295.         drv_spi_read_write_byte( *pTxBuf );                        //发送数据
  296.                 pTxBuf++;
  297.     }
  298.     RF24L01_SET_CS_HIGH( );                //取消片选
  299. }

  301. /**
  302.   * @brief :在接收模式下向TX FIFO写数据(带ACK)
  303.   * @param :
  304.   *                        @pData:数据地址
  305.   *                        @len:长度
  306.   * @note  :一次不超过32个字节
  307.   * @retval:无
  308.   */
  309. void NRF24L01_Write_Tx_Payload_InAck( uint8_t *pData, uint8_t len )
  310. {
  311.     uint8_t btmp;
  312.        
  313.         len = ( len > 32 ) ? 32 : len;                //数据长度大于32个则只写32个字节

  315.     RF24L01_SET_CS_LOW( );                        //片选
  316.     drv_spi_read_write_byte( W_ACK_PLOAD );                //命令
  317.     for( btmp = 0; btmp < len; btmp ++ )
  318.     {
  319.         drv_spi_read_write_byte( *( pData + btmp ) );        //写数据
  320.     }
  321.     RF24L01_SET_CS_HIGH( );                        //取消片选
  322. }

  324. /**
  325.   * @brief :设置发送地址
  326.   * @param :
  327.   *                        @pAddr:地址存放地址
  328.   *                        @len:长度
  329.   * @note  :无
  330.   * @retval:无
  331.   */
  332. void NRF24L01_Set_TxAddr( uint8_t *pAddr, uint8_t len )
  333. {
  334.         len = ( len > 5 ) ? 5 : len;                                        //地址不能大于5个字节
  335.     NRF24L01_Write_Buf( TX_ADDR, pAddr, len );        //写地址
  336. }

  338. /**
  339.   * @brief :设置接收通道地址
  340.   * @param :
  341.   *                        @PipeNum:通道
  342.   *                        @pAddr:地址存肥着地址
  343.   *                        @Len:长度
  344.   * @note  :通道不大于5 地址长度不大于5个字节
  345.   * @retval:无
  346.   */
  347. void NRF24L01_Set_RxAddr( uint8_t PipeNum, uint8_t *pAddr, uint8_t Len )
  348. {
  349.     Len = ( Len > 5 ) ? 5 : Len;
  350.     PipeNum = ( PipeNum > 5 ) ? 5 : PipeNum;                //通道不大于5 地址长度不大于5个字节

  352.     NRF24L01_Write_Buf( RX_ADDR_P0 + PipeNum, pAddr, Len );        //写入地址
  353. }

  355. /**
  356.   * @brief :设置通信速度
  357.   * @param :
  358.   *                        @Speed:速度
  359.   * @note  :无
  360.   * @retval:无
  361.   */
  362. void NRF24L01_Set_Speed( nRf24l01SpeedType Speed )
  363. {
  364.         uint8_t btmp = 0;
  365.        
  366.         btmp = NRF24L01_Read_Reg( RF_SETUP );
  367.         btmp &= ~( ( 1<<5 ) | ( 1<<3 ) );
  368.        
  369.         if( Speed == SPEED_250K )                //250K
  370.         {
  371.                 btmp |= ( 1<<5 );
  372.         }
  373.         else if( Speed == SPEED_1M )   //1M
  374.         {
  375.                    btmp &= ~( ( 1<<5 ) | ( 1<<3 ) );
  376.         }
  377.         else if( Speed == SPEED_2M )   //2M
  378.         {
  379.                 btmp |= ( 1<<3 );
  380.         }

  382.         NRF24L01_Write_Reg( RF_SETUP, btmp );
  383. }

  385. /**
  386.   * @brief :设置功率
  387.   * @param :
  388.   *                        @Speed:速度
  389.   * @note  :无
  390.   * @retval:无
  391.   */
  392. void NRF24L01_Set_Power( nRf24l01PowerType Power )
  393. {
  394.     uint8_t btmp;
  395.        
  396.         btmp = NRF24L01_Read_Reg( RF_SETUP ) & ~0x07;
  397.     switch( Power )
  398.     {
  399.         case POWER_F18DBM:
  400.             btmp |= PWR_18DB;
  401.             break;
  402.         case POWER_F12DBM:
  403.             btmp |= PWR_12DB;
  404.             break;
  405.         case POWER_F6DBM:
  406.             btmp |= PWR_6DB;
  407.             break;
  408.         case POWER_0DBM:
  409.             btmp |= PWR_0DB;
  410.             break;
  411.         default:
  412.             break;
  413.     }
  414.     NRF24L01_Write_Reg( RF_SETUP, btmp );
  415. }

  417. /**
  418.   * @brief :设置频率
  419.   * @param :
  420.   *                        @FreqPoint:频率设置参数
  421.   * @note  :值不大于127
  422.   * @retval:无
  423.   */
  424. void RF24LL01_Write_Hopping_Point( uint8_t FreqPoint )
  425. {
  426.     NRF24L01_Write_Reg(  RF_CH, FreqPoint & 0x7F );
  427. }

  429. /**
  430.   * @brief :NRF24L01单次检测
  431.   * @param printf_sw 串口是否打印连接失败  1:是  0:否
  432.   * @note  :循环
  433.   * @retval:0:连接成功    1:连接失败
  434.   */
  435. uint8_t NRF24L01_check( uint8_t printf_sw )
  436. {
  437.         uint8_t i;
  438.         uint8_t buf[5]={ 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 };
  439.         uint8_t read_buf[ 5 ] = { 0 };
  440.   NRF24L01_Write_Buf( TX_ADDR, buf, 5 );                        //写入5个字节的地址
  441.   NRF24L01_Read_Buf( TX_ADDR, read_buf, 5 );                //读出写入的地址  
  442.   for( i = 0; i < 5; i++ )
  443.   {
  444.     if( buf[ i ] != read_buf[ i ] )
  445.     {
  446.       break;
  447.     }       
  448.   }
  449.   if( 5 == i )
  450.   {
  451.     return 0;
  452.   }
  453.   else
  454.   {
  455.     if(printf_sw)
  456.     {
  457.       // printf("RF24L01 is not find !...");
  458.       printf(g_ErrorString);
  459.     }
  460.       //===============================
  461.     // delay_ms(1500);//连接失败延迟1.5s
  462.     //OLED_ShowString(0,3,(uint8_t *)g_ErrorString,8);
  463.     // printf("end\r\n");
  464.     return 1;
  465.   }
  466. }

  468. // /**
  469. //   * @brief :NRF24L01循环检测
  470. //   * @param :无
  471. //   * @note  :无限循环版
  472. //   * @retval:无
  473. //   */
  474. // uint8_t NRF24L01_while_check( void )
  475. // {
  476. //         uint8_t i;
  477. //         uint8_t buf[5]={ 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 };
  478. //         uint8_t read_buf[ 5 ] = { 0 };
  479.          
  480. //         while( 1 )
  481. //         {
  482. //                 NRF24L01_Write_Buf( TX_ADDR, buf, 5 );                        //写入5个字节的地址
  483. //                 NRF24L01_Read_Buf( TX_ADDR, read_buf, 5 );                //读出写入的地址  
  484. //                 for( i = 0; i < 5; i++ )
  485. //                 {
  486. //                         if( buf[ i ] != read_buf[ i ] )
  487. //                         {
  488. //                                 break;
  489. //                         }       
  490. //                 }
  491.                
  492. //                 if( 5 == i )
  493. //                 {
  494. //                         break;
  495. //                 }
  496. //                 else
  497. //                 {
  498. //       printf(g_ErrorString);//===============================
  499. // //                        OLED_ShowString(0,3,(uint8_t *)g_ErrorString,8);
  500. //                 }
  501. //                 delay_ms(1500);
  502. //         }
  503. // }

  505. /**
  506.   * @brief :设置模式
  507.   * @param :
  508.   *                        @Mode:模式发送模式或接收模式
  509.   * @note  :无
  510.   * @retval:无
  511.   */
  512. void RF24L01_Set_Mode( nRf24l01ModeType Mode )
  513. {
  514.     uint8_t controlreg = 0;
  515.         controlreg = NRF24L01_Read_Reg( CONFIG );
  516.        
  517.     if( Mode == MODE_TX )      
  518.         {
  519.                 controlreg &= ~( 1<< PRIM_RX );
  520.         }
  521.     else
  522.         {
  523.                 if( Mode == MODE_RX )  
  524.                 {
  525.                         controlreg |= ( 1<< PRIM_RX );
  526.                 }
  527.         }

  529.     NRF24L01_Write_Reg( CONFIG, controlreg );
  530. }

  532. /**
  533.   * @brief :NRF24L01发送一次数据
  534.   * @param :
  535.   *                        @txbuf:待发送数据首地址
  536.   *                        @Length:发送数据长度
  537.   * @note  :无
  538.   * @retval:
  539.   *                        MAX_TX：达到最大重发次数
  540.   *                        TX_OK：发送完成
  541.   *                        0xFF:其他原因
  542.   */
  543. uint8_t NRF24L01_TxPacket( uint8_t *txbuf, uint8_t Length )
  544. {
  545.         uint8_t l_Status = 0;
  546.         uint16_t l_MsTimes = 0;
  547.        
  548.         RF24L01_SET_CS_LOW( );                //片选
  549.         drv_spi_read_write_byte( FLUSH_TX );
  550.         RF24L01_SET_CS_HIGH( );
  551.        
  552.         RF24L01_SET_CE_LOW( );               
  553.         NRF24L01_Write_Buf( WR_TX_PLOAD, txbuf, Length );        //写数据到TX BUF 32字节  TX_PLOAD_WIDTH
  554.         RF24L01_SET_CE_HIGH( );                        //启动发送
  555.         while( 0 != RF24L01_GET_IRQ_STATUS( ))
  556.         {
  557.                 delay_ms( 1 );
  558.                 if( 500 == l_MsTimes++ )                                                //500ms还没有发送成功，重新初始化设备
  559.                 {
  560.                         NRF24L01_Gpio_Init( );
  561.                         RF24L01_Init( );
  562.                         RF24L01_Set_Mode( MODE_TX );
  563.                         break;
  564.                 }
  565.         }
  566.         l_Status = NRF24L01_Read_Reg(STATUS);                                                //读状态寄存器
  567.         NRF24L01_Write_Reg( STATUS, l_Status );                                                //清除TX_DS或MAX_RT中断标志
  568.        
  569.         if( l_Status & MAX_TX )        //达到最大重发次数
  570.         {
  571.                 NRF24L01_Write_Reg( FLUSH_TX,0xff );        //清除TX FIFO寄存器
  572.                 return MAX_TX;
  573.         }
  574.         if( l_Status & TX_OK )        //发送完成
  575.         {
  576.                 return TX_OK;
  577.         }
  578.        
  579.         return 0xFF;        //其他原因发送失败
  580. }

  582. /**
  583.   * @brief :NRF24L01接收数据
  584.   * @param :
  585.   *                        @rxbuf:接收数据存放地址
  586.   * @note  :无
  587.   * @retval:接收的数据个数
  588.   */
  589. uint8_t NRF24L01_RxPacket( uint8_t *rxbuf )
  590. {
  591.         uint8_t l_Status = 0, l_RxLength = 0;
  592.        
  593.         RF24L01_SET_CS_LOW( );                //片选
  594.         drv_spi_read_write_byte( FLUSH_RX );
  595.         RF24L01_SET_CS_HIGH( );
  596.        
  597.   //无用
  598.         // while( 0 != RF24L01_GET_IRQ_STATUS( ))
  599.         // {
  600.         //         delay_ms( 100 );
  601.                
  602.         //         if( 30 == l_100MsTimes++ )                //3s没接收过数据，重新初始化模块
  603.         //         {
  604.         //                 NRF24L01_Gpio_Init( );
  605.         //                 RF24L01_Init( );
  606.         //                 RF24L01_Set_Mode( MODE_RX );
  607.   //     printf("init\r\n");
  608.         //                 break;
  609.         //         }
  610.         // }
  611.        
  612.         l_Status = NRF24L01_Read_Reg( STATUS );                //读状态寄存器
  613.         NRF24L01_Write_Reg( STATUS,l_Status );                //清中断标志
  614.         if( l_Status & RX_OK)        //接收到数据
  615.         {
  616.                 l_RxLength = NRF24L01_Read_Reg( R_RX_PL_WID );                //读取接收到的数据个数
  617.                 NRF24L01_Read_Buf( RD_RX_PLOAD,rxbuf,l_RxLength );        //接收到数据
  618.                 NRF24L01_Write_Reg( FLUSH_RX,0xff );                                //清除RX FIFO
  619.                 return l_RxLength;
  620.         }       
  621.        
  622.         return 0;                                //没有收到数据       
  623. }

  625. /**
  626.   * @brief :RF24L01引脚初始化
  627.   * @param :无
  628.   * @note  :无
  629.   * @retval:无
  630.   */

  632. void NRF24L01_Gpio_Init( void )
  633. {
  634.         GPIO_InitTypeDef        RF24L01_GpioInitStructer;
  635.   EXTI_InitTypeDef EXTI_InitStructure;
  636.   NVIC_InitTypeDef NVIC_InitStructure;
  637.        
  638.         RCC_APB2PeriphClockCmd( RF24L01_CE_GPIO_CLK | RF24L01_IRQ_GPIO_CLK, ENABLE );        //?? CE IRQ????  CS SCK MISO MOSI?SPI?????
  639.   //使能（打开）系统配置时钟
  640.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
  641.        
  642.         //??CE?? ????
  643.         RF24L01_GpioInitStructer.GPIO_Mode = GPIO_Mode_OUT;
  644.         RF24L01_GpioInitStructer.GPIO_Speed = GPIO_Speed_100MHz;
  645.         RF24L01_GpioInitStructer.GPIO_Pin = RF24L01_CE_GPIO_PIN;
  646.         GPIO_Init( RF24L01_CE_GPIO_PORT, &RF24L01_GpioInitStructer );
  647.         //??
  648.         GPIO_SetBits( RF24L01_CE_GPIO_PORT, RF24L01_CE_GPIO_PIN);
  649.        
  650.         //??IRQ?? ????
  651.         RF24L01_GpioInitStructer.GPIO_Mode = GPIO_Mode_IN;
  652.         RF24L01_GpioInitStructer.GPIO_Speed = GPIO_Speed_100MHz;
  653.         RF24L01_GpioInitStructer.GPIO_Pin = RF24L01_IRQ_GPIO_PIN;
  654.         GPIO_Init( RF24L01_IRQ_GPIO_PORT, &RF24L01_GpioInitStructer );
  655.   //将Pb8和EXTI8连接在一起
  656.   SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB,EXTI_PinSource8);
  657.   EXTI_InitStructure.EXTI_Line = EXTI_Line8;//外部中断4
  658.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//设置为中断
  659.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发 识别按键按下
  660.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;//打开(使能)
  661.   EXTI_Init(&EXTI_InitStructure);
  662.   //优先级配置
  663.   NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;                        //外部中断4的请求通道
  664.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;        //抢占优先级0x02
  665.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;                //响应优先级0x02
  666.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                //使能（打开）该通道
  667.   NVIC_Init(&NVIC_InitStructure);
  668.         //??
  669.         GPIO_SetBits( RF24L01_IRQ_GPIO_PORT, RF24L01_IRQ_GPIO_PIN);
  670.        
  671.         RF24L01_SET_CE_LOW( );                //??24L01
  672.         RF24L01_SET_CS_HIGH( );                //??SPI??
  673. }

  675. /**
  676.   * @brief :RF24L01模块初始化
  677.   * @param :无
  678.   * @note  :无
  679.   * @retval:无
  680.   */
  681. void RF24L01_Init( void )
  682. {
  683.     uint8_t addr[5] = {INIT_ADDR};

  685.     RF24L01_SET_CE_HIGH( );
  686.     NRF24L01_Clear_IRQ_Flag( IRQ_ALL );
  687.     NRF24L01_Flush_Rx_Fifo();//清除接收缓冲区(复位时避免程序跑偏接收不到数据)
  688.     NRF24L01_Flush_Tx_Fifo();
  689. #if DYNAMIC_PACKET == 1

  691.     NRF24L01_Write_Reg( DYNPD, ( 1 << 0 ) );         //使能通道1动态数据长度
  692.     NRF24L01_Write_Reg( FEATRUE, 0x07 );
  693.     NRF24L01_Read_Reg( DYNPD );
  694.     NRF24L01_Read_Reg( FEATRUE );
  695.        
  696. #elif DYNAMIC_PACKET == 0
  697.    
  698.     L01_WriteSingleReg( L01REG_RX_PW_P0, FIXED_PACKET_LEN );        //固定数据长度
  699.        
  700. #endif        //DYNAMIC_PACKET

  702.     NRF24L01_Write_Reg( CONFIG, /*( 1<<MASK_RX_DR ) |*/                //接收中断
  703.                                       ( 1 << EN_CRC ) |     //使能CRC 1个字节
  704.                                       ( 1 << PWR_UP ) );    //开启设备
  705.     NRF24L01_Write_Reg( EN_AA, ( 1 << ENAA_P0 ) );                   //通道0自动应答
  706.     NRF24L01_Write_Reg( EN_RXADDR, ( 1 << ERX_P0 ) );                //通道0接收
  707.     NRF24L01_Write_Reg( SETUP_AW, AW_5BYTES );                             //地址宽度 5个字节
  708.     NRF24L01_Write_Reg( SETUP_RETR, ARD_4000US |
  709.                         ( REPEAT_CNT & 0x0F ) );                 //重复等待时间 250us
  710.     // NRF24L01_Write_Reg(STATUS,0X70);
  711.     NRF24L01_Write_Reg( RF_CH, 60 );                                     //初始化通道
  712.     NRF24L01_Write_Reg( RF_SETUP, 0x26 );
  713.     NRF24L01_Set_TxAddr( &addr[0], 5 );                      //设置TX地址
  714.     NRF24L01_Set_RxAddr( 0, &addr[0], 5 );                   //设置RX地址
  715. }
复制代码
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表