uchar nRF24L01_RxPacket(uchar *rx_buf)
{
uchar revale=0;
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,RX_ADDRESS, RX_ADR_WIDTH);
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // IRQ收发完成中断响应，16位CRC ，主接收
CE = 1;
inerDelay_us(130);
sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况
if(RX_DR) // 判断是否接收到数据
{
CE = 0; //SPI使能
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //读取数据完成标志
write_com(0x80);
write_str(" Hum");
write_data(':');
write_data(rx_buf[1]/10%10+48);
write_data(rx_buf[1]%10+48);
write_data('%');
write_com(0x80+0x40);
write_str(" Tem");
write_data(':');
write_data(rx_buf[2]/10%10+48);
write_data(rx_buf[2]%10+48);
write_data(0xdf);
write_data('c');
}
SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
return revale;
}
void main()
{
nRF24L01_Config();
SetRX_Mode();
if(MAX_RT)
{
SPI_RW_Reg(FLUSH_TX,0);
}
SPI_RW_Reg(WRITE_REG+STATUS,0xFF);// clear RX_DR or TX_DS or MAX_RT interrupt flag
SPI_RW_Reg(FLUSH_RX,0);
SCON =0x40;
TMOD = 0x20;
TH1 = 0xfd;
TL1 = 0xfd;
TR1 = 1;
EX1=1;
IT1=0;
EA=1;
init_1602();
while(1)
{
Control();
display();
if(RxBuf[0]==0xAA)
{
RxBuf[0]=0;
//PH_dat=RxBuf[1];
temp_dat=RxBuf[2];
temp_dot=RxBuf[3];
beep_flag=RxBuf[4];
}
delay1ms(10);
}
}
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(100);
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; // Spi clock line init high
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 写本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX0_ADDRESS, RX_ADR_WIDTH); // 写接收端地址 P0
SPI_Write_Buf(WRITE_REG + RX_ADDR_P1, RX1_ADDRESS, RX_ADR_WIDTH); // 写接收端地址 P1
SPI_Write_Buf(WRITE_REG + RX_ADDR_P2, RX2_ADDRESS, 1); // 写接收端地址 P2
SPI_Write_Buf(WRITE_REG + RX_ADDR_P3, RX3_ADDRESS, 1); // 写接收端地址 P3
SPI_Write_Buf(WRITE_REG + RX_ADDR_P4, RX4_ADDRESS, 1); // 写接收端地址 P4
SPI_Write_Buf(WRITE_REG + RX_ADDR_P5, RX5_ADDRESS, 1); // 写接收端地址 P5
SPI_RW_Reg(WRITE_REG + EN_AA,0x3F); // 频道0 - 5 自动 ACK应答允许
SPI_RW_Reg(WRITE_REG + EN_RXADDR,0x3F); // 允许接收地址频道0 - 5
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 设置信道工作为2.4GHZ，收发必须一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RX_PW_P1, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RX_PW_P2, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RX_PW_P3, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RX_PW_P4, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RX_PW_P5, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为RX_PLOAD_WIDTH字节
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //设置发射速率为1MHZ，发射功率为最大值0dB
CE=1; // chip disable
}
/**************************************************/
char SPI_Read(char reg)
{
char reg_val;
RF24L01_CSN_0; // CSN low, initialize SPI communication...
SPI_RW(reg); // Select register to read from..
reg_val = SPI_RW(0); // ..then read registervalue
RF24L01_CSN_1; // CSN high, terminate SPI communication
return(reg_val); // return register value
}
char SPI_RW_Reg(char reg, char value)
{
char status1;
RF24L01_CSN_0; // CSN low, init SPI transaction
status1 = SPI_RW(reg); // select register
SPI_RW(value); // ..and write value to it..
RF24L01_CSN_1; // CSN high again
return(status1); // return nRF24L01 status uchar
}
char SPI_W_Reg(char reg){
char status1;
RF24L01_CSN_0; // CSN low, init SPI transaction
status1 = SPI_RW(reg); // select register
RF24L01_CSN_1; // CSN high again
return(status1);
}
char SPI_Read_Buf(char reg, char *pBuf, char chars)
{
char status2,uchar_ctr;
RF24L01_CSN_0; // Set CSN low, init SPI tranaction
status2 = SPI_RW(reg); // Select register to write to and read status uchar
for(uchar_ctr=0;uchar_ctr<chars;uchar_ctr++)
{
pBuf[uchar_ctr] = SPI_RW(0); //
}
RF24L01_CSN_1; // Set CSN high
return(status2); // return nRF24L01 status uchar
}
char SPI_Write_Buf(char reg, char *pBuf, char chars)
{
char status1,uchar_ctr;
RF24L01_CSN_0; // Set CSN low, init SPI tranaction
status1 = SPI_RW(reg); // Select register to write to and read status byte
for(uchar_ctr=0; uchar_ctr<chars; uchar_ctr++) // then write all byte in buffer(*pBuf)
{
SPI_RW(*pBuf++);
}
RF24L01_CSN_1; // Set CSN high
return(status1); //
}
void SetRX_Mode(void)
{
RF24L01_CE_0 ;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x3B); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:RX. RX_DR enabled..
RF24L01_CE_1; // Set CE pin high to enable RX device
inerDelay_us(1000);//delay for about 1 second
}
char nRF24L01_RxPacket(char* rx_buf)
{
char revale=0;
sta=SPI_Read(STATUS); // read register STATUS's value
if(sta&0x40) // success!
{
RF24L01_CE_0 ; //SPI enable
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //set flag to 1
}
SPI_RW_Reg(WRITE_REG+STATUS,sta);
return revale;
}
void nRF24L01_TxPacket(char * tx_buf)
{
RF24L01_CE_0 ; //StandBy
SPI_Write_Buf(0x2A, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack
SPI_Write_Buf(0x30, TX_ADDRESS, TX_ADR_WIDTH);
SPI_RW_Reg(0x20,0x0A);
SPI_Write_Buf(0xA0, tx_buf, 0x05); // Writes data to TX payload
RF24L01_CE_1; // finish
inerDelay_us(1000);
}
//****************************************************************************************
//NRF24L01 init
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(1000);
RF24L01_CE_0 ; // chip enable
RF24L01_CSN_1; // Spi disable
RF24L01_SCK_0; // Spi clock line init high
inerDelay_us(15);
SPI_Write_Buf(0x2B, TX_ADDRESS, TX_ADR_WIDTH);
inerDelay_us(15);
SPI_RW_Reg(WRITE_REG + RF_CH, 0x00);
inerDelay_us(20);
//SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x00);
inerDelay_us(20);
SPI_RW_Reg(0x25,0x00);
SPI_RW_Reg(0x31, 0x05);
inerDelay_us(20);
SPI_RW_Reg(0x32, 0x05);
inerDelay_us(20);
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0b00100110);
inerDelay_us(20);
SPI_RW_Reg(0x31, 0x05);
inerDelay_us(20);
SPI_RW_Reg(0x32, 0x05);
inerDelay_us(20);
SPI_RW_Reg(0x21, 0x00); //disable acks!!
inerDelay_us(20);
SPI_RW_Reg(0x20, 0x00);
inerDelay_us(20);
SPI_RW_Reg(0x27, 0x30);
inerDelay_us(20);
SPI_W_Reg(FLUSH_RX);
inerDelay_us(20);
}
/**************************************************
Function: RX_Mode();
Description:
**************************************************/
void SetRX_Mode(void)
{
nRF24L01_CE_CLR;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);
SPI_RW_Reg(WRITE_REG + STATUS, 0x70);
nRF24L01_CE_SET;
delay_us(400);
}
// Switch to TX mode
void nrf24l01plus_mode_tx_send(void)
{
PIO_Clear(&CE);
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:TX.
SPI_RW_Reg(FLUSH_TX,0);
SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); // write playload to TX_FIFO
PIO_Set(&CE); // Set CE pin high to enable RX device
}
void SetTX_Mode(void)
{
CE=0;
SPI_RW_Reg(WRITE_REG+STATUS,0xff);
SPI_RW_Reg(FLUSH_TX, 0x00);
SPI_RW_Reg(WRITE_REG + CONFIG2, 0x7e); // IRQ收发完成中断响应，16位CRC ，主接收
CE = 1;
inerDelay_us(2600);
}
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
SPI_RW_Reg(WRITE_REG+STATUS,0xff);
SPI_RW_Reg(0xE1,0xff);
CE=0;
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);
CE=1;
inerDelay_us(200); //CE高电平大于10us才能进入发射模式
}
//启动NRF24L01发送一次数据
//txbuf:待发送数据首地址
//返回值:0，接收完成；其他，错误代码
uchar NRF24L01_RxPacket(uchar *rxbuf)
{
uchar sta;
sta=SPI_Read(STATUS); //读取状态寄存器的值
SPI_RW_Reg(WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志
if(sta&RX_OK)//接收到数据
{
SPI_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
SPI_RW_Reg(FLUSH_RX,0xff);//清除RX FIFO寄存器
return 0;
}
return 1;//没收到任何数据
}
// Attempts to receive a packet and puts it into rx_buf. Returns 1 on successful receive.
int nrf24l01plus_receive_packet(void)
{
int rec = 0;
unsigned char status = SPI_Rd(STATUS); // read register STATUS's value
if((status & RX_DR) && !nrf24l01plus_rxFifoEmpty()) // if receive data ready interrupt and FIFO full.
{
SPI_Read_Buf(RD_RX_PLOAD, rx_buf, TX_PLOAD_WIDTH); // read playload to rx_buf
SPI_RW_Reg(FLUSH_RX,0); // clear RX_FIFO
rec = 1;
}
SPI_RW_Reg(WRITE_REG+STATUS,status); // clear RX_DR or TX_DS or MAX_RT interrupt flag
return rec;
}
bool NRFLib::is_sending(void) {
unsigned char status = SPI_Read(STATUS);
// if sending successful (TX_DS) or max retries exceeded (MAX_RT).
if (status & TX_DS) {
SPI_RW_Reg(WRITE_REG+STATUS, status);
return false;
} else if (status & MAX_RT) {
SPI_RW_Reg(WRITE_REG+STATUS, status);
return false;
} else
return true;
}
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(100);
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; // Spi clock line init high
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 写本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // 频道0自动 ACK应答允许
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // 允许接收地址只有频道0，如果需要多频道可以参考Page21
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 设置信道工作为2.4GHZ，收发必须一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为20字节
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //设置发射速率为1MHZ，发射功率为最大值0dB
}
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(100);
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; // Spi clock line init high
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 寫本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 寫接收端地址
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // 頻道0自動 ACK應答允許
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // 允許接收地址只有頻道0
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 設置工作頻率2.4GHZ，收發必需一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //設置接收數據長度，本次設置為20 bit
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //設置工作頻率1MHZ，發射功率為最大值0dB
}
/**************************************************
函数：nrf24l01_rxPacket(uchar * rx_buf)
描述：
向rx_buf 指向的缓冲区位置按照RX_PLOAD_WIDTH宽度数据接收
**************************************************/
int nrf24l01_rxPacket(uchar * rx_buf)
{
int rx_result=0;
sta=SPI_Read(STATUS);
#ifdef DEBUG
printk("Statue is %x",sta);
#endif
if(sta & (1<<RX_DR) ) //收到数据
{
#ifdef DEBUG
printk("Data received!\n");
#endif
// CE_L;
// udelay(10);
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH); //从节点读取数据到RxBuffer
rx_result = 1;
}
SPI_RW_Reg(WRITE_REG + STATUS, sta); // 清除RX_DS中断标志
return rx_result;
}
void SetRX_Mode(void)
{
cbi(PORTC,CE);//CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x07); // enable power up and prx
sbi(PORTC,CE);//CE = 1;
_delay_us(130); //
}
void SetTX_Mode(void)
{
cbi(PORTC,CE);//CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // Enable CRC, 2 byte CRC, Send
sbi(PORTC,CE);//CE = 1;
_delay_us(130); //
}
void main()
{
TxBuf[0]=0x00;
Read_18B20_Temperature();
Read_18B20_Temperature();
delay1ms(200);
Read_18B20_Temperature();
Read_18B20_Temperature();
delay1ms(200);
Read_18B20_Temperature();
Read_18B20_Temperature();
delay1ms(200);
nRF24L01_Config(); //初始化NRF24L01
SPI_RW_Reg(FLUSH_TX,0);
EX1=1;
IT1=1;
EA=1;
init_1602();
while(1)
{
Read_18B20_Temperature();
keyscan();
Control();
display();
TxBuf[0]=0xAA;
TxBuf[2]=Tem_dispbuf[4];
TxBuf[3]=Tem_dispbuf[0];
TxBuf[4]=beep_flag;
nRF24L01_TxPacket(TxBuf); //发送数据
delay1ms(10);
}
}
void SetRX_Mode(void)
{
RF24L01_CE_0 ;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x3B); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:RX. RX_DR enabled..
RF24L01_CE_1; // Set CE pin high to enable RX device
inerDelay_us(1000);//delay for about 1 second
}
/**************************************************
驱动函数：nrf24l01_write()
描述：
写设备函数
**************************************************/
static ssize_t nrf24l01_write(struct file *filp, const char *buffer,size_t count, loff_t *ppos)
{
uchar * TxBuf =
(uchar *)kmalloc(((count+TX_PLOAD_WIDTH-1)/TX_PLOAD_WIDTH)*TX_PLOAD_WIDTH * sizeof(uchar),0); //申请缓冲区作为发送缓冲
if (copy_from_user(TxBuf,buffer,count)) //从用户空间复制发送内容 如果成功返回0
{
printk(DEVICE_NAME "Can't get user data!\n"); //若失败 则错误退出
kfree(TxBuf);
return -EFAULT;
}
else
{
int countDevide = (count+TX_PLOAD_WIDTH-1)/TX_PLOAD_WIDTH;
uchar * TxBufPtr = TxBuf;
// count /TX_PLOAD_WIDTH向上取整作为发送次数 保证count 数目数据全部发送
while(countDevide)
{
nrf24l01_txPacket(TxBufPtr);
SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
TxBufPtr += TX_PLOAD_WIDTH;
countDevide--;
}
}
kfree(TxBuf);
udelay(200);
nrf24l01_setRx(); //发送完毕 切换设备为接收状态
return count;
}
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; //
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 写本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // 频道0自动 ACK应答允许
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // 允许接收地址只有频道0，如果需要多频道可以参考Page21
//SPI_RW_Reg(WRITE_REG + EN_AA, 0x00); //失能通道0自动应答
//SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); //接收要使能接收通道0
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 设置信道工作为2.4GHZ，收发必须一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //设置发射速率为1MB/S，发射功率为最大值+7dB，由于有X2401L功放，实际+21dbm输出
}
void NRFLib::RXMode(void) {
digitalWrite(_cepin, 0);
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, _rx_addr, ADR_WIDTH); // Use the same address on the RX device as the TX device
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 unsigned chars) & Prim:RX.
_txmode = false;
digitalWrite(_cepin, 1); // Set CE pin high to enable RX device
}
void SetRX_Mode(void)
{
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // IRQ收發完成中響應，16位CRC，主接收
CE = 1;
inerDelay_us(130); //延時不能太短
}
unsigned char nRF24L01_debug(void)
{
#ifdef nRF24L01_RX_Debug
unsigned char RxBuf[RX_PLOAD_WIDTH]={0};
SetRX_Mode();
while(1){
SetRX_Mode();
if(nRF24L01_RxPacket(RxBuf)){
//add your code
return 1;
}
}
#endif
#ifdef nRF24L01_TX_Debug
unsigned char sta=0;
unsigned char TxBuf[TX_PLOAD_WIDTH]={0};
nRF24L01_TxPacket(TxBuf);
while(1){
nRF24L01_TxPacket(TxBuf);
sta = SPI_Read(STATUS);
if(sta == 0x2e){
//add your code
return 1;
}
SPI_RW_Reg(WRITE_REG+STATUS, 0xff);
xSysCtlDelay(10000);
}
#endif
}
// Sends packet currenting in the tx_buf.
int nrf24l01plus_Send_Packet(void)
{
int rec = 0;
unsigned char status = SPI_Rd(STATUS); // read register STATUS's value
if(status&TX_DS || status&MAX_RT) // if receive data ready (TX_DS) interrupt
{
PIO_Clear(&CE);
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);
SPI_RW_Reg(FLUSH_TX,0);
SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH); // write playload to TX_FIFO
rec = 1;
PIO_Set(&CE);
}
SPI_RW_Reg(WRITE_REG+STATUS,status); // clear RX_DR or TX_DS or MAX_RT interrupt flag
return rec;
}
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
cbi(PORTC,CE);//CE=0;
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Send Address
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); //send data
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // Send Out
sbi(PORTC,CE);//CE=1;
}
void NRF24_Check_Event(void)
{
rt_uint8_t buff[34];
rt_uint8_t sta = SPI_Read(NRF_READ_REG + NRFRegSTATUS);
//rt_kprintf("sta=0x%x\n",sta);
if(sta & (0x01 << 6))
{
rt_uint8_t rx_len = SPI_Read(R_RX_PL_WID);
if(rx_len<33)
{
SPI_Read_Buf(RD_RX_PLOAD,buff,rx_len);// read receive payload from RX_FIFO buffer
rt_kprintf("Data_Receive:");
for(rt_uint8_t i=0;i<32;i++)
{
rt_kprintf("%c",buff[i]);
}
rt_kprintf("\n");
//LED1_ONOFF();
Data_Receive_Anl(buff,rx_len);
}
else
{
SPI_RW_Reg(FLUSH_RX,0xff);//Çå¿Õ»º³åÇø
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
if(sta & (1<<5))
{
//LED1_ONOFF();
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
if(sta & (1<<4))
{
if(sta & 0x01) //TX FIFO FULL
{
SPI_RW_Reg(FLUSH_TX,0xff);
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
SPI_RW_Reg(RF_WRITE_REG + NRFRegSTATUS, sta);
}
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
CE=0; //StandBy I模式
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // 装载数据
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收发完成中断响应，16位CRC，主发送
CE=1; //置高CE，激发数据发送
inerDelay_us(10);
}
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
CE=0; //StandBy I模式
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 裝載接收端地址
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // 裝載數據
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收發完成中響應，16位CRC，主發送
CE=1; //置高CE，激發數據發送
inerDelay_us(10);
}
/**************************************************
Function: nRF24L01_TxPacket();
Description:
This function initializes one nRF24L01 device to
TX mode, set TX address, set RX address for auto.ack,
fill TX payload, select RF channel, datarate & TX pwr.
PWR_UP is set, CRC(2 bytes) is enabled, & PRIM:TX.
ToDo: One high pulse(>10us) on CE will now send this
packet and expext an acknowledgment from the RX device.
**************************************************/
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
nRF24L01_CE_CLR;//StandBy Iģʽ
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);
nRF24L01_CE_SET;
delay_us(100);
}
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
unsigned char revale=0;
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);
CE=1;
inerDelay_us(10);
inerDelay_us(10);
sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况
// if(RX_DR) // 判断是否接收到数据
// {
CE=0; //SPI使能
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //读取数据完成标志
// }
SPI_RW_Reg(WRITE_REG+STATUS,0x07); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
return revale;
}
