使用无线收发模块G01-S(芯片:Si24R1)

已于 2023-12-20 14:52:46 修改
阅读量480 收藏 13
点赞数 8
文章标签： 单片机 嵌入式硬件
于 2023-12-16 20:07:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JustBare/article/details/135036571
版权

摘要

使用Arduino IDE将下面的代码烧写到开发板“LGT8F328P-LQFP32 MiniEVB”或“Arduino nano”中，可实现在开发板1的串口输入待发送的数据，两个无线收发模块G01-S之间通讯完成后，开发板2的串口输出接收到的数据。

环境

软件

IDE:Arduino IDE 2.2.1

硬件

两个无线收发模块：G01-S(芯片是Si24R1)
开发板1：Arduino nano(芯片是Atmega168)
开发板2：LGT8F328P-LQFP32 MiniEVB

接线

G01-S的【GDN】引脚接开发板的【GND】
G01-S的【IRQ】引脚接开发板的【D8】
G01-S的【MISO】引脚接开发板的【D12】
G01-S的【MOSI】引脚接开发板的【D11】
G01-S的【SCK】引脚接开发板的【D13】
G01-S的【CSN】引脚接开发板的【D10】
G01-S的【CE】引脚接开发板的【D9】
G01-S的【VDD】引脚接开发板的【3V3】

代码

//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum
/** 发送模式定义 */
enum
{
	TX_MODE_1 = 0,		//发送模式1，发送固定的字符串
	TX_MODE_2			//发送模式2，发送串口接收到的数据
};

typedef enum ModeType
{
	MODE_TX = 0,
	MODE_RX
}nRf24l01ModeType;

typedef enum SpeedType
{
	SPEED_250K = 0,
	SPEED_1M,
	SPEED_2M
}nRf24l01SpeedType;

typedef enum PowerType
{
	POWER_F18DBM = 0,
	POWER_F12DBM,
	POWER_F6DBM,
	POWER_0DBM
}nRf24l01PowerType;
//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum//  enum




/** NRF24L01定义 */
//
//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令
#define NRF_READ_REG    0x00	//读配置寄存器，低5位为寄存器地址
#define NRF_WRITE_REG   0x20	//写配置寄存器，低5位为寄存器地址
#define RD_RX_PLOAD     0x61	//读RX有效数据，1~32字节
#define WR_TX_PLOAD     0xA0	//写TX有效数据，1~32字节
#define FLUSH_TX        0xE1	//清除TX FIFO寄存器，发射模式下使用
#define FLUSH_RX        0xE2	//清除RX FIFO寄存器，接收模式下使用
#define REUSE_TX_PL     0xE3	//重新使用上一包数据，CE为高，数据包被不断发送
#define R_RX_PL_WID     0x60
#define NOP             0xFF	//空操作，可以用来读状态寄存器
#define W_ACK_PLOAD		0xA8
#define WR_TX_PLOAD_NACK 0xB0
//SPI(NRF24L01)寄存器地址
#define CONFIG          0x00	//配置寄存器地址，bit0:1接收模式,0发射模式;bit1:电选择;bit2:CRC模式;bit3:CRC使能;
							    //bit4:中断MAX_RT(达到最大重发次数中断)使能;bit5:中断TX_DS使能;bit6:中断RX_DR使能	
#define EN_AA           0x01	//使能自动应答功能 bit0~5 对应通道0~5
#define EN_RXADDR       0x02	//接收地址允许 bit0~5 对应通道0~5
#define SETUP_AW        0x03	//设置地址宽度(所有数据通道) bit0~1: 00,3字节 01,4字节, 02,5字节
#define SETUP_RETR      0x04	//建立自动重发;bit0~3:自动重发计数器;bit4~7:自动重发延时 250*x+86us
#define RF_CH           0x05	//RF通道,bit0~6工作通道频率
#define RF_SETUP        0x06	//RF寄存器，bit3:传输速率( 0:1M 1:2M);bit1~2:发射功率;bit0:噪声放大器增益
#define STATUS          0x07	//状态寄存器;bit0:TX FIFO满标志;bit1~3:接收数据通道号(最大:6);bit4:达到最多次重发次数
								//bit5:数据发送完成中断;bit6:接收数据中断
#define MAX_TX  		0x10	//达到最大发送次数中断
#define TX_OK   		0x20	//TX发送完成中断
#define RX_OK   		0x40	//接收到数据中断

#define OBSERVE_TX      0x08	//发送检测寄存器,bit7~4:数据包丢失计数器;bit3~0:重发计数器
#define CD              0x09	//载波检测寄存器,bit0:载波检测
#define RX_ADDR_P0      0x0A	//数据通道0接收地址，最大长度5个字节，低字节在前
#define RX_ADDR_P1      0x0B	//数据通道1接收地址，最大长度5个字节，低字节在前
#define RX_ADDR_P2      0x0C	//数据通道2接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[39:8]相等
#define RX_ADDR_P3      0x0D	//数据通道3接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[39:8]相等
#define RX_ADDR_P4      0x0E	//数据通道4接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[39:8]相等
#define RX_ADDR_P5      0x0F	//数据通道5接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[39:8]相等
#define TX_ADDR         0x10	//发送地址(低字节在前),ShockBurstTM模式下，RX_ADDR_P0与地址相等
#define RX_PW_P0        0x11	//接收数据通道0有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P1        0x12	//接收数据通道1有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P2        0x13	//接收数据通道2有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P3        0x14	//接收数据通道3有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P4        0x15	//接收数据通道4有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P5        0x16	//接收数据通道5有效数据宽度(1~32字节),设置为0则非法
#define NRF_FIFO_STATUS 0x17	//FIFO状态寄存器;bit0:RX FIFO寄存器空标志;bit1:RX FIFO满标志;bit2~3保留
								//bit4:TX FIFO 空标志;bit5:TX FIFO满标志;bit6:1,循环发送上一数据包.0,不循环								
#define DYNPD			0x1C
#define FEATRUE			0x1D
//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令//寄存器操作命令
//





//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义
#define MASK_RX_DR   	6 
#define MASK_TX_DS   	5 
#define MASK_MAX_RT  	4 
#define EN_CRC       	3 
#define CRCO         	2 
#define PWR_UP       	1 
#define PRIM_RX      	0 

#define ENAA_P5      	5 
#define ENAA_P4      	4 
#define ENAA_P3      	3 
#define ENAA_P2      	2 
#define ENAA_P1      	1 
#define ENAA_P0      	0 

#define ERX_P5       	5 
#define ERX_P4       	4 
#define ERX_P3       	3 
#define ERX_P2      	2 
#define ERX_P1       	1 
#define ERX_P0       	0 

#define AW_RERSERVED 	0x0 
#define AW_3BYTES    	0x1
#define AW_4BYTES    	0x2
#define AW_5BYTES    	0x3

#define ARD_250US    	(0x00<<4)
#define ARD_500US    	(0x01<<4)
#define ARD_750US    	(0x02<<4)
#define ARD_1000US   	(0x03<<4)
#define ARD_2000US   	(0x07<<4)
#define ARD_4000US   	(0x0F<<4)
#define ARC_DISABLE   	0x00
#define ARC_15        	0x0F

#define CONT_WAVE     	7 
#define RF_DR_LOW     	5 
#define PLL_LOCK      	4 
#define RF_DR_HIGH    	3 
//bit2-bit1:
#define PWR_18DB  		(0x00<<1)
#define PWR_12DB  		(0x01<<1)
#define PWR_6DB   		(0x02<<1)
#define PWR_0DB   		(0x03<<1)

#define RX_DR         	6 
#define TX_DS         	5 
#define MAX_RT        	4 
//for bit3-bit1, 
#define TX_FULL_0     	0 

#define RPD           	0 

#define TX_REUSE      	6 
#define TX_FULL_1     	5 
#define TX_EMPTY      	4 
//bit3-bit2, reserved, only '00'
#define RX_FULL       	1 
#define RX_EMPTY      	0 

#define DPL_P5        	5 
#define DPL_P4        	4 
#define DPL_P3        	3 
#define DPL_P2        	2 
#define DPL_P1        	1 
#define DPL_P0        	0 

#define EN_DPL        	2 
#define EN_ACK_PAY    	1 
#define EN_DYN_ACK    	0 
#define IRQ_ALL  ( (1<<RX_DR) | (1<<TX_DS) | (1<<MAX_RT) )
//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义//位定义




/** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 */
#define DYNAMIC_PACKET      1 		//1:动态数据包, 0:固定
#define FIXED_PACKET_LEN    32		//包长度
#define REPEAT_CNT          15		//重复次数
#define INIT_ADDR           0x34,0x43,0x10,0x10,0x01
/** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 *//** 配置和选项定义 */


const char *g_ErrorString = "RF24L01 is not find !...\n";
const char *g_Ashining = "gisemi\n";
uint8_t g_TxMode = 0, g_UartRxFlag = 0;
uint8_t g_UartRxBuffer[ 32 ] = { 0 };
uint8_t g_RF24L01RxBuffer[ 32 ] = { 0 }; 


// inslude the SPI library:
#include <SPI.h>

// set pin 10 as the slave select for the digital pot:
const byte CSN = 10;
const byte CE = 9;
const byte IRQ = 8;


//CSN
//CSN
//CSN
void set_csn_output()
{
  pinMode(CSN, OUTPUT);
}
void set_csn_low()
{
  digitalWrite(CSN, LOW);
}
void set_csn_high()
{
  digitalWrite(CSN, HIGH);
}
//CSN
//CSN
//CSN



//CE
//CE
//CE
void set_ce_output()
{
  pinMode(CE, OUTPUT);
}
void set_ce_high()
{
  digitalWrite(CE, HIGH);
}
void set_ce_low()
{
  digitalWrite(CE, LOW);
}
//CE
//CE
//CE



//IRQ
//IRQ
//IRQ
void set_irq_input()
{
  pinMode(IRQ, INPUT);
}
void set_irq_low()
{
  digitalWrite(IRQ, LOW);
}
void set_irq_high()
{
  digitalWrite(IRQ, HIGH);
}
//IRQ
//IRQ
//IRQ



//串口初始化
void drv_uart_init()
{
  Serial.begin(9600);
  Serial.setTimeout(1000);  //  字节之间到达时间间隔超过1000ms后，available()函数返回
}
//SPI初始化
void drv_spi_init()
{
  SPI.begin();
}
//引脚初始化
void NRF24L01_Gpio_Init()
{
//  CE 配置为输出 //使能设备
  set_ce_output();
  set_ce_low();
//  IRQ配置为输入 //清中断
  set_irq_input();
  set_irq_high(); //  输入引脚也可以设置高低电平
//  CSN配置为输出 //取消SPI片选
  set_csn_output();
  set_csn_high();
}







/**
  * @brief :NRF24L01写指定长度的数据
  * @param :
  *			@reg:地址
  *			@pBuf:写入的数据地址
  *			@len:数据长度
  * @note  :数据长度不超过255，地址在设备中有效
  * @retval:写状态
  */
void NRF24L01_Write_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
{
    uint8_t i;
	
  
  //  RF24L01_SET_CS_LOW( );		//片选
  set_csn_low();  //片选
	
  
    //drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );	//写命令 地址
    SPI.transfer(NRF_WRITE_REG | RegAddr);  //写命令 地址


    for( i = 0; i < len; i ++ )
    {
        //drv_spi_read_write_byte( *( pBuf + i ) );		//写数据
        SPI.transfer( *( pBuf + i ) );		//写数据
    }
	
    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
}


/**
  * @brief :NRF24L01读指定长度的数据
  * @param :
  *			@reg:地址
  *			@pBuf:数据存放地址
  *			@len:数据长度
  * @note  :数据长度不超过255，地址在设备中有效
  * @retval:读取状态
  */
void NRF24L01_Read_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
{
    uint8_t btmp;
	
    //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	
    //drv_spi_read_write_byte( NRF_READ_REG | RegAddr );	//读命令 地址
    SPI.transfer( NRF_READ_REG | RegAddr );	//读命令 地址

    for( btmp = 0; btmp < len; btmp ++ )
    {
        //*( pBuf + btmp ) = drv_spi_read_write_byte( 0xFF );	//读数据
        *( pBuf + btmp ) = SPI.transfer( 0xFF );	//读数据
    }


    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
}



/**
  * @brief :串口发送数据
  * @param :
  *			@TxBuffer:发送数据首地址
  *			@Length:数据长度
  * @note  :无
  * @retval:无
  */
void drv_uart_tx_bytes( uint8_t* TxBuffer, uint8_t Length )
{
	while( Length-- )
	{
    char c = *TxBuffer;
    Serial.print(c);
		TxBuffer++;
	}
}
/**
  * @brief :NRF24L01检测
  * @param :无
  * @note  :无
  * @retval:无
  */ 
void  NRF24L01_check( void )
{
	uint8_t i;
	uint8_t buf[5]={ 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 };
	uint8_t read_buf[ 5 ] = { 0 };
	 
	while( 1 )
	{
		NRF24L01_Write_Buf( TX_ADDR, buf, 5 );			//写入5个字节的地址
		NRF24L01_Read_Buf( TX_ADDR, read_buf,5 );		//读出写入的地址  
		for( i = 0; i < 5; i++ )
		{
			if( buf[ i ] != read_buf[ i ] )
			{
				break;			//读出的值和写入的置不同
			}	
		} 
		
		if( 5 == i )
		{
      drv_uart_tx_bytes((char*)"exist\n",6);
			break;				//读出的字符串与写入的字符串相同，判断为设备存在
		}
		else
		{
			drv_uart_tx_bytes( (uint8_t *)g_ErrorString, 25 );	//检测不到设备，输出警告信息
		}

		// drv_delay_ms( 500 );	//500MS检测一次
    delay( 500 );	//500MS检测一次
	}
}







/**
  * @brief :NRF24L01读状态寄存器
  * @param :无
  * @note  :无
  * @retval:RF24L01状态
  */
uint8_t NRF24L01_Read_Status_Register( void )
{
    uint8_t Status;
	
    //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	
    //Status = drv_spi_read_write_byte( NRF_READ_REG + STATUS );	//读状态寄存器
    Status = SPI.transfer( NRF_READ_REG + STATUS );	//读状态寄存器
	
    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
	
    return Status;
}

/**
  * @brief :NRF24L01清中断
  * @param :
           @IRQ_Source:中断源
  * @note  :无
  * @retval:清除后状态寄存器的值
  */
uint8_t NRF24L01_Clear_IRQ_Flag( uint8_t IRQ_Source )
{
    uint8_t btmp = 0;

    IRQ_Source &= ( 1 << RX_DR ) | ( 1 << TX_DS ) | ( 1 << MAX_RT );	//中断标志处理
    btmp = NRF24L01_Read_Status_Register();			//读状态寄存器
			
    //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
    //drv_spi_read_write_byte( NRF_WRITE_REG + STATUS );	//写状态寄存器命令
    SPI.transfer( NRF_WRITE_REG + STATUS );	//写状态寄存器命令
    //drv_spi_read_write_byte( IRQ_Source | btmp );		//清相应中断标志
    SPI.transfer( IRQ_Source | btmp );		//清相应中断标志
    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
	
    return ( NRF24L01_Read_Status_Register());			//返回状态寄存器状态
}



/**
  * @brief :NRF24L01写寄存器
  * @param :无
  * @note  :地址在设备中有效
  * @retval:读写状态
  */
void NRF24L01_Write_Reg( uint8_t RegAddr, uint8_t Value )
{
     //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	
    //drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );	//写命令 地址
    SPI.transfer( NRF_WRITE_REG | RegAddr );	//写命令 地址
    //drv_spi_read_write_byte( Value );			//写数据
    SPI.transfer( Value );			//写数据
	
    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
}


/**
  * @brief :NRF24L01读寄存器
  * @param :
           @Addr:寄存器地址
  * @note  :地址在设备中有效
  * @retval:读取的数据
  */
uint8_t NRF24L01_Read_Reg( uint8_t RegAddr )
{
    uint8_t btmp;
	
     //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	
    //drv_spi_read_write_byte( NRF_READ_REG | RegAddr );	//读命令 地址
    SPI.transfer( NRF_READ_REG | RegAddr );	//读命令 地址
    //btmp = drv_spi_read_write_byte( 0xFF );				//读数据
    btmp = SPI.transfer( 0xFF );				//读数据
	
    //RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
	
    return btmp;
}


 /**
  * @brief :设置发送地址
  * @param :
  *			@pAddr:地址存放地址
  *			@len:长度
  * @note  :无
  * @retval:无
  */
void NRF24L01_Set_TxAddr( uint8_t *pAddr, uint8_t len )
{
	len = ( len > 5 ) ? 5 : len;					//地址不能大于5个字节
    NRF24L01_Write_Buf( TX_ADDR, pAddr, len );	//写地址
}


 /**
  * @brief :设置接收通道地址
  * @param :
  *			@PipeNum:通道
  *			@pAddr:地址存肥着地址
  *			@Len:长度
  * @note  :通道不大于5 地址长度不大于5个字节
  * @retval:无
  */
void NRF24L01_Set_RxAddr( uint8_t PipeNum, uint8_t *pAddr, uint8_t Len )
{
    Len = ( Len > 5 ) ? 5 : Len;
    PipeNum = ( PipeNum > 5 ) ? 5 : PipeNum;		//通道不大于5 地址长度不大于5个字节

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


/**
  * @brief :RF24L01模块初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void RF24L01_Init( void )
{
    uint8_t addr[5] = {INIT_ADDR};

    //RF24L01_SET_CE_HIGH();
    set_ce_high();
    NRF24L01_Clear_IRQ_Flag( IRQ_ALL );
//#if DYNAMIC_PACKET == 1
if(DYNAMIC_PACKET == 1){


    NRF24L01_Write_Reg( DYNPD, ( 1 << 0 ) ); 	//使能通道1动态数据长度
    NRF24L01_Write_Reg( FEATRUE, 0x07 );
    NRF24L01_Read_Reg( DYNPD );
    NRF24L01_Read_Reg( FEATRUE );
}
//#elif DYNAMIC_PACKET == 0
else{
    
    //L01_WriteSingleReg( L01REG_RX_PW_P0, FIXED_PACKET_LEN );	//固定数据长度
	
//#endif	//DYNAMIC_PACKET
}

    NRF24L01_Write_Reg( CONFIG, /*( 1<<MASK_RX_DR ) |*/		//接收中断
                                      ( 1 << EN_CRC ) |     //使能CRC 1个字节
                                      ( 1 << PWR_UP ) );    //开启设备
    NRF24L01_Write_Reg( EN_AA, ( 1 << ENAA_P0 ) );   		//通道0自动应答
    NRF24L01_Write_Reg( EN_RXADDR, ( 1 << ERX_P0 ) );		//通道0接收
    NRF24L01_Write_Reg( SETUP_AW, AW_5BYTES );     			//地址宽度 5个字节
    NRF24L01_Write_Reg( SETUP_RETR, ARD_4000US |
                        ( REPEAT_CNT & 0x0F ) );         	//重复等待时间 250us
    NRF24L01_Write_Reg( RF_CH, 60 );             			//初始化通道
    NRF24L01_Write_Reg( RF_SETUP, 0x26 );

    NRF24L01_Set_TxAddr( &addr[0], 5 );                      //设置TX地址
    NRF24L01_Set_RxAddr( 0, &addr[0], 5 );                   //设置RX地址
}




 /**
  * @brief :设置模式
  * @param :
  *			@Mode:模式发送模式或接收模式
  * @note  :无
  * @retval:无
  */
void RF24L01_Set_Mode( nRf24l01ModeType Mode )
{
    uint8_t controlreg = 0;
	controlreg = NRF24L01_Read_Reg( CONFIG );
	
    if( Mode == MODE_TX )       
	{
		controlreg &= ~( 1<< PRIM_RX );
	}
    else 
	{
		if( Mode == MODE_RX )  
		{ 
			controlreg |= ( 1<< PRIM_RX ); 
		}
	}

    NRF24L01_Write_Reg( CONFIG, controlreg );
}



int RF24L01_GET_IRQ_STATUS()
{
  return digitalRead(IRQ);
}


/**
  * @brief :NRF24L01发送一次数据
  * @param :
  *			@txbuf:待发送数据首地址
  *			@Length:发送数据长度
  * @note  :无
  * @retval:
  *			MAX_TX：达到最大重发次数
  *			TX_OK：发送完成
  *			0xFF:其他原因
  */ 
uint8_t NRF24L01_TxPacket( uint8_t *txbuf, uint8_t Length )
{
	uint8_t l_Status = 0;
	uint16_t l_MsTimes = 0;
	
	 //RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	//drv_spi_read_write_byte( FLUSH_TX );
  SPI.transfer( FLUSH_TX );
	//RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
	
	//RF24L01_SET_CE_LOW( );
  set_ce_low();		
	NRF24L01_Write_Buf( WR_TX_PLOAD, txbuf, Length );	//写数据到TX BUF 32字节  TX_PLOAD_WIDTH
	// RF24L01_SET_CE_HIGH( );			//启动发送
  set_ce_high();
	while( 0 != RF24L01_GET_IRQ_STATUS())
	{
		// drv_delay_ms( 1 );
    delay(1);
		if( 500 == l_MsTimes++ )						//500ms还没有发送成功，重新初始化设备
		{
			NRF24L01_Gpio_Init( );
			RF24L01_Init( );
			RF24L01_Set_Mode( MODE_TX );
			break;
		}
	}
	l_Status = NRF24L01_Read_Reg(STATUS);						//读状态寄存器
	NRF24L01_Write_Reg( STATUS, l_Status );						//清除TX_DS或MAX_RT中断标志
	
	if( l_Status & MAX_TX )	//达到最大重发次数
	{
		NRF24L01_Write_Reg( FLUSH_TX,0xff );	//清除TX FIFO寄存器
		return MAX_TX; 
	}
	if( l_Status & TX_OK )	//发送完成
	{
		return TX_OK;
	}
	
	return 0xFF;	//其他原因发送失败
}




/**
  * @brief :串口接收数据
  * @param :
  *			@RxBuffer:发送数据首地址
  * @note  :无
  * @retval:接收到的字节个数
  */
uint8_t drv_uart_rx_bytes( uint8_t* RxBuffer )
{
	// uint8_t l_RxLength = 0;
	// uint16_t l_UartRxTimOut = 0x7FFF;
	
	// while( l_UartRxTimOut-- )		//在超时范围内检测数据
	// {
	// 	if( 0 != RI )				//检测是否接收到数据
	// 	{
	// 		RI = 0;					//清标志位		
	// 		*RxBuffer = SBUF;		//读数据
	// 		RxBuffer++;
	// 		l_RxLength++;
	// 		l_UartRxTimOut = 0x7FFF;//重置超时检测
	// 	}
	// }
	
	// return l_RxLength;			//等待超时，数据接收完成  


uint8_t l_RxLength = 0;
	uint16_t l_UartRxTimOut = 0x7FFF;
	
	while( l_UartRxTimOut-- )		//在超时范围内检测数据
	{
		if(Serial.available() )				//检测是否接收到数据
		{
			// RI = 0;					//清标志位		
			// *RxBuffer = SBUF;		//读数据
			*RxBuffer = Serial.read();		//读数据
			RxBuffer++;
			l_RxLength++;
			l_UartRxTimOut = 0x7FFF;//重置超时检测
		}
	}

  if(l_RxLength!=0)
{
  Serial.print("l_RxLength:");
  //drv_uart_tx_bytes(RxBuffer,l_RxLength);
  Serial.println(l_RxLength);
}
	
	return l_RxLength;			//等待超时，数据接收完成  


//   uint8_t l_RxLength = 0;
//   l_RxLength = Serial.available();
//   for(int i=0;i<l_RxLength;i++)
//   {
//     *RxBuffer = Serial.read();
//     RxBuffer++;
//   }

// if(l_RxLength!=0)
// {
//   Serial.print("l_RxLength:");
//   //drv_uart_tx_bytes(RxBuffer,l_RxLength);
//   Serial.println(l_RxLength);
// }
  

//   return l_RxLength;
}




/**
  * @brief :NRF24L01接收数据
  * @param :
  *			@rxbuf:接收数据存放地址
  * @note  :无
  * @retval:
  *			0:接收完成
  *			1:没有接收到数据
  */ 
uint8_t NRF24L01_RxPacket( uint8_t *rxbuf )
{
	uint8_t l_Status = 0, l_RxLength = 0, l_100MsTimes = 0;
	
	//RF24L01_SET_CS_LOW( );			//片选
    set_csn_low();  //片选
	//drv_spi_read_write_byte( FLUSH_RX );
  SPI.transfer( FLUSH_RX );
	//RF24L01_SET_CS_HIGH( );		//取消片选
    set_csn_high();  //取消片选
	
	while( 0 != RF24L01_GET_IRQ_STATUS( ))
	{
		//drv_delay_ms( 100 );
    delay(100);
		
		if( 30 == l_100MsTimes++ )		//3s没接收过数据，重新初始化模块
		{
			NRF24L01_Gpio_Init( );
			RF24L01_Init( );
			RF24L01_Set_Mode( MODE_RX );
			break;
		}
	}
	
	l_Status = NRF24L01_Read_Reg( STATUS );		//读状态寄存器
	NRF24L01_Write_Reg( STATUS,l_Status );		//清中断标志
	if( l_Status & RX_OK)	//接收到数据
	{
		l_RxLength = NRF24L01_Read_Reg( R_RX_PL_WID );		//读取接收到的数据个数
		NRF24L01_Read_Buf( RD_RX_PLOAD,rxbuf,l_RxLength );	//接收到数据 
		NRF24L01_Write_Reg( FLUSH_RX,0xff );				//清除RX FIFO
		return l_RxLength; 
	}	
	
	return 0;				//没有收到数据	
}


void setup() {
  //串口初始化
	drv_uart_init( );

	//SPI初始化
	drv_spi_init( );
	
	//RF24L01引脚初始化
	NRF24L01_Gpio_Init( );

  //检测nRF24L01
	NRF24L01_check();	
  RF24L01_Init();



if(1)
{
  //  发送  

  RF24L01_Set_Mode( MODE_TX );		//发送模式
  while(1)
  {

    g_TxMode = 1; //  串口输入要发送的数据
    // g_TxMode = 0; //  发送固定字符


    //发送
      if( TX_MODE_1 == g_TxMode )
      {
        NRF24L01_TxPacket( (uint8_t *)g_Ashining, 7 );		//模式1发送固定字符,1S一包
        // drv_delay_ms( 500 );	
        // drv_delay_ms( 500 );	
        // led_red_flashing( );	
        delay(1000);	
      }
      else
      {	
        //查询串口数据
        int i = drv_uart_rx_bytes( g_UartRxBuffer );
        
        if( 0 != i )
        {
          NRF24L01_TxPacket( g_UartRxBuffer, i );
          //led_red_flashing( );
        }
      }
    }
}
else
{
  //  接收

  RF24L01_Set_Mode( MODE_RX );		//接收模式
	while( 1 )
	{
		int i = NRF24L01_RxPacket( g_RF24L01RxBuffer );		//接收字节
		if( 0 != i )
		{
			//led_green_flashing( );
			drv_uart_tx_bytes( g_RF24L01RxBuffer,i );	//输入接收到的字节
			
		}
	}
}

 

 
 


}
 

void loop() {
  
    delay(1000);

    
}

ps:大部分代码来自淘宝客服

JustBare
关注
  • 8
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
si24r1程序_Si24R1_Si24R1数据手册_2.4G无线射频芯片Si24R1_一牛网
weixin_39646021的博客
12-23 2万+
在过去多年，2.4GHz无线数传领域中，NRF24L01以其易于调试、价格合适、性能优越，始终在短距离数据(也可用于音频)传输领域的主流应用端，近几年，SI24R1芯片的出现，几乎算是完美代替了NRF24L01这颗料， 下面来细数SI24R1模块的特点。 一：模块简介 SI24R1模块是采用 2.4G 无线收 发IC设计的一款高性能 2.4G无线收发模块，采用GFSK 调制，...
G01服务器安全管理系统,在云端服务器+终端的方式安装配置网防G01管理监测系统...
weixin_39560924的博客
08-06 696
生产环境：操作系统：CentOS release 6.9 (Final)任务：网防G01管理监测系统操作步骤：网防监测系统网址：http://www.gov110.cn/1.在网防监测系统注册账号2.登录系统下载Linux服务版和客户PC端版3.Linux服务器安装步骤：即服务端wget http://update.gov110.cn/v3/gov_defence_agent_64bit.tar....
数控机床G代码指令详解
热门推荐
走错路的程序员
10-29 4万+
一、G代码功能简述 G00------快速定位 G01------直线插补 G02------顺时针方向圆弧插补 G03------逆时针方向圆弧插补 G04------定时暂停 G05------通过中间点圆弧插补 G06------抛物线插补 G07------Z 样条曲线插补 G08------进给加速 G09------进给减速 G10------数据设置 G16------极坐标编程 G17------加工XY平面 G18------加工XZ平面 G19------加工YZ平面 G20------
数控加工插补功能指令
a66889999的博客
05-28 2613
须知：（1）刀具从上向下移动时：G00 XY；先定 XY 面，然后 Z 轴下降。格式含义：G00 指令使刀具以点位控制方式从刀具当前点以最快速度运动到另一点。格式含义：G01 指令使刀具按 F 指令从当前运动到指定点。上移动时：G00 Z；Z 轴先上升，然后定ＸＹ面。格式：G17 ｛G02 /G03｝XY（R/IJ）F;3、G02—顺时针插补、G03—逆时针插补。迹不一定是两点一线，有可能是一条折线。1、G00—快速定位指令。2、G01—直线插补指令。格式：G01 XYZF；格式：G00 XYZ；
player.getcurrentposition() 与暂停时设置的值不一致_数控车床编程常用指令介绍，你还不赶紧学习！...
weixin_39638929的博客
12-09 1004
数控车床编程常用指令介绍1. F功能F功能指令用于控制切削进给量。在程序中，有两种使用方法。(1)每转进给量编程格式 G99 F~F后面的数字表示的是主轴每转进给量，单位为mm/r。例：G99 F0.2 表示进给量为0.2 mm/r。(2)每分钟进给量编程格式G98 F~F后面的数字表示的是每分钟进给量，单位为 mm/min。例：G94 F100 表示进给量为100mm/min。2. S功能S功能...
STC8G1K08驱动Si24R1无线模块（1个发送程序1个接收程序）SPI通信
02-24
程序功能如下： 1.发送端发送数据， 2.接收端接收数据并返回响应并且串口输出数据 发送端收到响应点亮小灯 压缩包含2个程序 发送程序，接收程序
STC8H开发(十五): GPIO驱动Ci24R1无线模块
IOsetting的专栏
08-09 2795
STC8H开发(十五): GPIO驱动Ci24R1无线模块Ci24R1是Si24R1的SOP8封装简化版, 厂商为南京中科微, 他们还有一个比较常见的型号是Si24R1, Si24R1就是应用极广的nRF24L1的克隆版. Ci24R1的通信协议和Si24R1, nRF24L01是兼容的, 另外支持蓝牙BLE4.2标准. 本文介绍Ci24R1如何使用GPIO模拟SPI驱动, 并提供STC8H的接收发送示例代码...
STM32 + 无线通信模块 NRF24L01 数据收发
zhouml_msn的博客
02-15 1万+
尽管网上关于NRF24L01的资料，已很详尽，但从入手NRF24L01到基本调通收发，断断续续用了近十天。 看来自己的学习方法得要认真复盘改进。 下面5个部分描述，只着重解释其中重点和暗坑。以方便自己日后回看，方便同行兄弟查阅。 一、引脚连接，解释 二、配置 三、中断 四、发送数据 五、接收数据 ......
SI24R1引脚及软硬件中文开发资料
Zhao13682455391的博客
06-24 1327
Si24R1是一颗由无锡中科微专为低功耗无线通信应用场合设计的一颗自有知识产权的2.4G RF芯片。目前主要针对低功耗的校讯通、2.4G停车场、智能家居、无线音频等领域。 当然，这颗芯片进入大众的视野是与友商的NRF24L01P芯片兼容通信。从而被打上了国产NRF24L01P的标签，更有甚者居然磨掉芯片原本的SI24R1的LOGO打成NRF24L01P，给很多客户产生了很多不必要的损失。大家定向的理解，国产的东西总是会比国外进口的相差到哪里哪里，如此云云。其实，在很多客户在使用Si24R1的时候，通过
CI24R1/SI24R1 2.4G无线传输技术--无线门铃
weng2355573209的博客
12-12 1224
基于2.4G无线收发芯片CI24R1无线门铃方案介绍
基于si24r1的2.4G无线通信模块-电路方案
04-21
板卡介绍 PCB工程文件 电路图: 电路来自:技新网
SI24R1_2.4G 源码
08-24
SI24R1_2.4G 源码 有兴趣的朋友拿去玩玩 Si24R1是一颗工作在2.4GHz ISM频段，专为低功耗无线场合设计，集成嵌入式发射基带的无线发射芯片。工作频率范围为2400MHz-2525MHz，共有126个1MHz带宽的信道
2.4G无线模块SI24R1开发资料g01_d.zip
07-29
2.4G无线模块SI24R1开发资料 替代nrf24l01
29505-中文版-5G系统：使用订阅数据的统一数据存储库服务g01(1).pdf
07-07
3GPP 5G标准 29505-中文版-5G系统：使用订阅数据的统一数据存储库服务g01
CNC-G00-and-G01-Implementation:G->准备命令的地址-> G命令通常告诉控件需要哪种运动（例如，快速定位，线性进给，循环进给，固定循环）或要使用的偏移值
04-13
CNC-G00和G01的实施 G-准备命令的地址 该命令通常告诉控制器需要哪种运动（例如，快速定位，线性进给，圆形进给，固定循环）或要使用的偏移值。 G00（快速定位）->在2轴或3轴运动中，G00（与G01不同）传统上不一定...
cen4010-s21-g01:团队1的CEN4010项目存储库
04-01
团队0xC0FFEE项目存储库 课程 CEN4010软件工程原理佛罗里达大西洋大学黄世宏博士-教授Nataliia Neshenko-教师助理2021年Spring 会员 林赛·巴茨（Lindsey Butts） 加里·... 要使用最新更改更新Web应用程序，请通过VMw
威伦通.cMT-G01技术规格书.pdf
05-31
威伦通.cMT-G01技术规格书.pdf
干数控编程这么多年，还不知道什么叫模态代码，机加工都白干了
j13712128767的博客
04-06 1538
以下给大家介绍，数控机床FANUC（发兰克）体系中，常用的F、S、T等功用属性代码，这些含义在初期学徒工中要学扎实，不然后期操机编程可是会头疼哦！ 代码分组 功用相近的代码分为同一组，同一段中同组代码有一个生效，若写多个，则最终一个代码有用，如：G00 G01 G03,这个程序段G03有用，同组代码如下表所示： 模态代码 又名续效代码，一经指定，一向有用，只到同组代码呈现后被替代。 比方：G01 X100;(指定G01切削) Y30;(G01续效，即使没写G01，仍然认为是G01切削) G02 X-40
Golang安全编码手册-上篇
宵小小沉的专栏
02-28 712
前言 本手册为go语言开发人员，为提升编码效率和为满足安全编码规范的随手参考书。内容条目以安全编码为主和常易忽视的编码细节为主，来自于以下三个方面的总结： 1、gosec、govet等go语言安全编码扫描工具，的规则的解读； 2、字节跳动、uber等使用go语言较成熟的大厂，的go语言编码规范的一些提取； 3、我们平时工作中对go语言代码走查，达成一致意见的总结。 本手册每个条目，包含条目的目的，为什么这么做以及正例和反例。条目分类开头的关键字，说明如下： G开头: 表示go语言基本要求的编码规
G01X-17.7080Y155.0830
最新发布
12-16
根据提供的引用内容，G01和G02是G代码中的两个基本指令，用于控制CNC机床上的直线和圆弧插补运动。X和Y是直线插补指令的坐标参数，分别表示在X轴和Y轴上的移动距离。因此，G01 X-17.7080 Y155.0830表示在X轴上向左移动17.7080个单位，在Y轴上向上移动155.0830个单位。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值