Example #1
0
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;
}
Example #2
0
/**************************************************
函数: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;

}
unsigned char NRF24L01_Check(void)
	{
	uchar check_in_buf[5]={0x11,0x22,0x33,0x44,0x55};
	uchar check_out_buf[5]={0x00};
	SPI_Write_Buf(WRITE_REG+TX_ADDR,check_in_buf,5);//写入5个字节的地址.	
	SPI_Read_Buf(TX_ADDR,check_out_buf,5); //读出写入的地址  
	if((check_out_buf[0] == 0x11)&&(check_out_buf[1] == 0x22)&&(check_out_buf[2] == 0x33)&&(check_out_buf[3] == 0x44)&&(check_out_buf[4] == 0x55))
	return 0;
	else return 1;
}	 							   
Example #4
0
//检测24L01是否存在
//返回值:0,成功;1,失败	
uchar NRF_Check(void)
{
	uchar buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
	uchar i;
	SPI_Write_Buf(WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.	
	SPI_Read_Buf(TX_ADDR,buf,5); //读出写入的地址  
	for(i=0;i<5;i++)if(buf[i]!=0XA5)break;	 							   
	if(i!=5)return 1;//检测24L01错误	
	return 0;		 //检测到24L01
}
Example #5
0
void NRF_Receive(uchar * buf_recv){
	//uchar revale=0;
	sta=SPI_ReadReg(STATUS);	// 读取状态寄存其来判断数据接收状况
	if(Flag_Receive)				// 判断是否接收到数据
	{
	    CE = 0; 			//SPI使能
		SPI_Read_Buf(RD_RX_PLOAD,buf_recv,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
		//revale =1;			//读取数据完成标志
	}
	SPI_WriteReg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1,通过写1来清楚中断标志
}
/**************************************************
Function: Receive_Packet
Description:
	read FIFO to read a packet
Parameter:
	None
Return:
	None
**************************************************/
char Receive_Packet(char * buf, char buf_len)
{
	UINT8 len,i,sta,fifo_sta,value,chksum,aa, res = 0;
	UINT8 rx_buf[MAX_PACKET_LEN];

	sta=SPI_Read_Reg(STATUS);	// read register STATUS's value

	if((STATUS_RX_DR&sta) == 0x40)				// if receive data ready (RX_DR) interrupt
	{
		do
		{
			len=SPI_Read_Reg(R_RX_PL_WID_CMD);	// read len

			if(len<=MAX_PACKET_LEN)
			{
				SPI_Read_Buf(RD_RX_PLOAD,buf,len);// read receive payload from RX_FIFO buffer
			}
			else
			{
				SPI_Write_Reg(FLUSH_RX,0);//flush Rx
			}

			fifo_sta=SPI_Read_Reg(FIFO_STATUS);	// read register FIFO_STATUS's value
							
		}while((fifo_sta&FIFO_STATUS_RX_EMPTY)==0); //while not empty

/*		
		chksum = 0;
		for(i=0;i<16;i++)
		{
			chksum +=rx_buf[i]; 
		}
		if(chksum==rx_buf[16]&&rx_buf[0]==0x30)
		{

//			GREEN_LED = 1;
//			delay_50ms();
//			delay_50ms();
//			GREEN_LED = 0;
			_delay_ms(100);

			//Send_Packet(W_TX_PAYLOAD_NOACK_CMD,rx_buf,17);
			SwitchToRxMode();//switch to RX mode	

			res = 1;
		}
		
*/
		res = len;		
	}
	SPI_Write_Reg(WRITE_REG|STATUS,sta);// clear RX_DR or TX_DS or MAX_RT interrupt flag
	
	return res;	
}
Example #7
0
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;
	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,sta);   									//接收到数据后RX_DR,TX_DS,MAX_PT都置高为1,通过写1来清楚中断标志
	return revale;
}
Example #8
0
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;
	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,sta);   //接收到數據後RX_DR,TX_DS,MAX_PT都置高,透過寫1清除中斷標誌 
	return revale;
}
Example #9
0
//启动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;//没收到任何数据
}
Example #10
0
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;
}
Example #11
0
// 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;
}
Example #12
0
bool NRFLib::receive_message(unsigned char buf[]) {
	if (_txmode)
		RXMode();
	unsigned char status = SPI_Read(STATUS);                         // read register STATUS's value
	unsigned char fifo = SPI_Read(0x17);
	//if(status&RX_DR){                                              // if receive data ready (TX_DS) interrupt
	if (!(fifo&1)) {
	  SPI_Read_Buf(RD_RX_PLOAD, buf, _payload);             // read playload to rx_buf
	  //flushRX();                                        // clear RX_FIFO
	  SPI_RW_Reg(WRITE_REG+STATUS,0x70); //0x70);                             // clear RX_DR or TX_DS or MAX_RT interrupt flag
	  return true;
	}
	return false;
}
Example #13
0
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;

    sta=SPI_Read(STATUS);	// read register STATUS's value
    if(RX_DR)			// if receive data ready (RX_DR) interrupt
    {
        nRF24L01_CE_CLR; 
        SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
        revale =1;//we have receive data
    }
    SPI_RW_Reg(WRITE_REG+STATUS,sta);// clear RX_DR or TX_DS or MAX_RT interrupt flag
    
    return revale;
}
Example #14
0
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;
    unsigned char sta;
	sta=SPI_Read(STATUS);	// Read Status 
	//if(RX_DR)				// Data in RX FIFO
    if((sta&0x40)!=0)		// Data in RX FIFO
	{
	    cbi(PORTC,CE);//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,sta); 
    sbi(PORTC,CE);//CE = 1; 			//SPI  
	return revale;
}
Example #15
0
uchar NRF24L01_RxPacket(uchar *rxbuf)
{
  uchar stat = 0;
  stat = SPI_Read_Reg(STATUS);
  SPI_Write_Reg(WRITE_REG + STATUS, stat);
  if(stat&RX_OK)
  {
    NRF_CE0;
    SPI_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);
    SPI_Write_Reg(FLUSH_RX,0xff);
    NRF_CE1;
    Delay_us(130);  ///???
    return 1;
  }
  return 0;
}
Example #16
0
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);
}
Example #17
0
uchar NRF24L01_Check(void)
{//check if there is a NRE24L01
  uchar check_in_buf[5]={0x11,0x22,0x33,0x44,0x55};
  uchar check_out_buf[5]={0x00};
  
  NRF_SCK0;
  NRF_CSN1;    
  NRF_CE0;
  
  SPI_Write_Buf(WRITE_REG+TX_ADDR, check_in_buf, 5);
  SPI_Read_Buf(READ_REG+TX_ADDR, check_out_buf, 5);
  
  if((check_out_buf[0] == 0x11)&&\
     (check_out_buf[1] == 0x22)&&\
     (check_out_buf[2] == 0x33)&&\
     (check_out_buf[3] == 0x44)&&\
     (check_out_buf[4] == 0x55))return 0;
  else return 1;
}
Example #18
0
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;
}
Example #19
0
uchar nRF24L01_RxPacket(uchar *rx_buf)
{	 
    uchar revale=0;
	SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,RX0_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;			//读取数据完成标志
		switch(sta%16/2) 
		{	
			case 0:    {
						write_com(0x80+0x43);
						write_data((rx_buf[1]*256+rx_buf[2])/100%10+48);
						write_data(((rx_buf[1]*256+rx_buf[2])/10)%10+48);
						write_data('.');
						write_data((rx_buf[1]*256+rx_buf[2])%10+48);
						write_data(0xdf);
						write_data('c');	 	
						break;
						}
			case 1:    {
						write_com(0x80+0x03);
						write_data(((rx_buf[1]*256+rx_buf[2])/100)%10+48);
						write_data(((rx_buf[1]*256+rx_buf[2])/10)%10+48);
						write_data('.');
						write_data((rx_buf[1]*256+rx_buf[2])%10+48);
						write_data(0xdf);
						write_data('c'); 
 						break;
						}
		}	
	}
	SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1,通过写1来清楚中断标志
	return revale;
}
Example #20
0
__interrupt void IRQHandler_PortD_nRF(void)
{
	IRQ_Printf("(IRQ)");

	BYTE status = SPI_Read_Register(STATUS);		
	IRQ_PrintStatus(status);
	
	#if(Enable_RX_IRQ == 1)
	if(( status & (bit_RX_DR) ) != 0)//Rx IRQ was triggered
	{
		BYTE fifo_Status;
		do
		{
			SPI_Read_Buf(RD_RX_PLOAD,RxData,RX_DataSize);
			ProcessUserData_inIRQ();
			
			nRF_ClearStatus( bit_RX_DR );
			
			fifo_Status = SPI_Read_Register(FIFO_STATUS);
			IRQ_Printf("  FifoStatus: ");
			IRQ_PrintfHex(fifo_Status);
			IRQ_Printf("\n\r");
		}while((fifo_Status & 0x01) == 0 );
	}
	#endif
	#if(Enable_TX_IRQ == 1)	
	if(	( status & (bit_TX_DS ) ) != 0	)
	{
		nRF_ClearStatus(bit_TX_DS);
	}
	#endif
	#if(Enable_RT_IRQ == 1)	
	if(	( status & (bit_MAX_RT) ) != 0	)//check other IRQs
	{
		nRF_ClearStatus(bit_MAX_RT);
	}
	#endif

}
Example #21
0
void main(void)
{
	init_io();		              // 初始化IO
	RX_Mode();		              // 设置为接收模式
	while(1)
	{
		CheckButtons();           // 按键扫描
		sta = SPI_Read(STATUS);	  // 读状态寄存器
	    if(RX_DR)				  // 判断是否接受到数据
		{
			SPI_Read_Buf(RD_RX_PLOAD, RX_BUF, TX_PLOAD_WIDTH);  // 从RX FIFO读出数据
			flag = 1;
		}
		SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除RX_DS中断标志
		if(flag)		           // 接受完成
		{
			flag = 0;		       // 清标志
			LED = RX_BUF[0];	   // 数据送到LED显示
			delay_ms(250);
			delay_ms(250);
  			LED = 0xff;		       // 关闭LED
		}
	}
}