/***************************************************/
/* 
 * @compiler This program has been tested with Keil C51 V7.50.
 *
 * NOTES:
 * This program is for the nRF24L01 with 232 interface;
 * The nRF24L01 is:
 *     one packet of 20 bytes payload from a TX device sending to address'3443101001', with auto acknowledgment,
 *     retransmit count of 10,TX_PWR:0dBm,Auto Re-transmit Delay 500us + 86us, use Pipe0,RF channel 40 and datarate = 1Mbps.
 *
 * $write date: 2006.4.7 ;time 16:30$
 *
 */
 /***************************************************/
#include <reg51.h>
#include <intrins.h>
#include "api.h"
/***************************************************/
#define uchar unsigned char
#define TX_ADR_WIDTH    5   // 5 bytes TX(RX) address width
#define TX_PLOAD_WIDTH  10  // 20 bytes TX payload


#define MAX_RT          0x10  // Max #of TX retrans interrupt
#define TX_DS           0x20  // TX data sent interrupt
#define RX_DR           0x40  // RX data received

uchar const TX_ADDRESS[TX_ADR_WIDTH]  = {0xcc,0xcc,0xcc,0xcc,0xcc}; // Define a static TX address

uchar rx_buf[TX_PLOAD_WIDTH];
uchar tx_buf[TX_PLOAD_WIDTH];
uchar flag;
uchar TX_DS_flag;
/**************************************************/
sbit CE =  P2^5;
sbit CSN=  P2^0;
sbit SCK=  P2^1;
sbit MOSI= P2^2;
sbit MISO= P2^3;
sbit IRQ = P3^2;

/**************************************************
uchar 	bdata sta;
sbit	RX_DR	=sta^6;
sbit	TX_DS	=sta^5;
sbit	MAX_RT	=sta^4;
/**************************************************/

/**************************************************
Function: init_io();
Description:
  flash led one time,chip enable(ready to TX or RX Mode),
  Spi disable,Spi clock line init high
/**************************************************/
void init_io(void)
{
	P0=0x0f;		// led light
	CE=0;			// chip enable
	CSN=1;			// Spi disable	
	SCK=0;			// Spi clock line init high
	P0=0xff;		// led close
}
/**************************************************/

/**************************************************
Function: Inituart();

Description:
  set uart working mode 
/**************************************************/
void Inituart(void)
{
	TMOD = 0x20;				//timer1 working mode 1
	TL1 = 0xfd;					//f7=9600 for 16mhz Fosc,and ... 
	TH1 = 0xfd;					//...fd=19200 for 11.0592mhz Fosc
	SCON = 0xd8;				//uart mode 3,ren==1
	PCON = 0x80;				//smod=0
	TR1 = 1;					//start timer1
}
/**************************************************/

/**************************************************
Function: init_int0();

Description:
  enable int0 interrupt;
/**************************************************/
void init_int0(void)
{
	EA=1;
	EX0=1;						// Enable int0 interrupt.
}
/**************************************************/

/**************************************************
Function: delay100();

Description:
  delay 100ms
/**************************************************
void delay(uchar )
{
	uchar  x;
	uchar  y;
	for(x=0;x<100;x++)
	{
		for(y=0;y<100;y++)
		_nop_();
	}
}

/**************************************************/
void delay_ms(unsigned int x)
{
    unsigned int i,j;
    i=0;
    for(i=0;i<x;i++)
    {
       j=108;
           ;
       while(j--);
    }
}
/**************************************************/

/**************************************************
Function: SPI_RW();

Description:
  Writes one byte to nRF24L01, and return the byte read
  from nRF24L01 during write, according to SPI protocol
/**************************************************/
uchar SPI_RW(uchar byte)
{
	uchar bit_ctr;
   	for(bit_ctr=0;bit_ctr<8;bit_ctr++)   // output 8-bit
   	{
   		MOSI = (byte & 0x80);         // output 'byte', MSB to MOSI
   		byte = (byte << 1);           // shift next bit into MSB..
   		SCK = 1;                      // Set SCK high..
   		byte |= MISO;       		  // capture current MISO bit
   		SCK = 0;            		  // ..then set SCK low again
   	}
    return(byte);           		  // return read byte
}
/**************************************************/

/**************************************************
Function: SPI_RW_Reg();

Description:
  Writes value 'value' to register 'reg'
/**************************************************/
uchar SPI_RW_Reg(BYTE reg, BYTE value)
{
	uchar status;

  	CSN = 0;                   // CSN low, init SPI transaction
  	status = SPI_RW(reg);      // select register
  	SPI_RW(value);             // ..and write value to it..
  	CSN = 1;                   // CSN high again

  	return(status);            // return nRF24L01 status byte
}
/**************************************************/

/**************************************************
Function: SPI_Read();

Description:
  Read one byte from nRF24L01 register, 'reg'
/**************************************************/
BYTE SPI_Read(BYTE reg)
{
	BYTE reg_val;

  	CSN = 0;                // CSN low, initialize SPI communication...
  	SPI_RW(reg);            // Select register to read from..
  	reg_val = SPI_RW(0);    // ..then read registervalue
  	CSN = 1;                // CSN high, terminate SPI communication

  	return(reg_val);        // return register value
}
/**************************************************/

/**************************************************
Function: SPI_Read_Buf();

Description:
  Reads 'bytes' #of bytes from register 'reg'
  Typically used to read RX payload, Rx/Tx address
/**************************************************/
uchar SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)
{
	uchar status,byte_ctr;

  	CSN = 0;                    		// Set CSN low, init SPI tranaction
  	status = SPI_RW(reg);       		// Select register to write to and read status byte

  	for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)
    	pBuf[byte_ctr] = SPI_RW(0);    // Perform SPI_RW to read byte from nRF24L01

  	CSN = 1;                           // Set CSN high again

  	return(status);                    // return nRF24L01 status byte
}
/**************************************************/

/**************************************************
Function: SPI_Write_Buf();

Description:
  Writes contents of buffer '*pBuf' to nRF24L01
  Typically used to write TX payload, Rx/Tx address
/**************************************************/
uchar SPI_Write_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)
{
	uchar status,byte_ctr;

  	CSN = 0;                   // Set CSN low, init SPI tranaction
  	status = SPI_RW(reg);    // Select register to write to and read status byte
  	for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) // then write all byte in buffer(*pBuf)
    	SPI_RW(*pBuf++);
  	CSN = 1;                 // Set CSN high again
  	return(status);          // return nRF24L01 status byte
}
/**************************************************/
void config()
{
	CE=0;

  	SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Use the same address on the RX device as the TX device

  	SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // disable Auto.Ack:Pipe0
  	SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Enable Pipe0
  	SPI_RW_Reg(WRITE_REG + RF_CH, 40);        // Select RF channel 40
  	SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
  	SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);   // TX_PWR:0dBm, Datarate:1Mbps, LNA:HCURR
	SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); //disable the auto retransmit functionality
  	CE = 1;                // Set CE pin high to enable RX device
}

/**************************************************
Function: RX_Mode();

Description:
  This function initializes one nRF24L01 device to
  RX Mode, set RX address, writes RX payload width,
  select RF channel, datarate & LNA HCURR.
  After init, CE is toggled high, which means that
  this device is now ready to receive a datapacket.
/**************************************************/
void RX_Mode(void)
{
	CE=0;
	//SPI_RW_Reg(WRITE_REG + SETUP_AW, 0x02); 

  	SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_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 bytes) & Prim:RX. RX_DR enabled..

  	CE = 1; // Set CE pin high to enable RX device
}
/**************************************************/

/**************************************************
Function: TX_Mode();

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 TX_Mode(void)
{
	CE=0;
	
  	SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Writes TX_Address to nRF24L01
  	SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // Writes data to TX payload

  	SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     // Set PWR_UP bit, enable CRC(2 bytes) & Prim:TX. MAX_RT & TX_DS enabled..
	CE=1;

}

/**************************************************/

/**************************************************
Function: TxData();

Description:
  write data x to SBUF
/**************************************************/
void TxData (uchar x)
{
	SBUF=x;			// write data x to SBUF
	while(TI==0);
		TI=0;
}
/**************************************************/

/**************************************************
Function: CheckButtons();

Description:
  check buttons ,if have press,read the key values,
  turn on led and transmit it;  after transmition,
  if received ACK, clear TX_DS interrupt and enter RX Mode;
  turn off the led
/**************************************************/
void CheckButtons()
{
	uchar Temp,xx,Tempi;

	P0=0xff;
	Temp=P0&0x0f;			         //read key value from port P0
	if (Temp!=0x0f)
	{	
		delay_ms(10);
		Temp=P0&0x0f;				// read key value from port P0
		if (Temp!=0x0f)
		{
				xx=Temp;
				Tempi=Temp<<4;		// Left shift 4 bits
				P0=Tempi;		    // Turn On the led
				tx_buf[0]=Tempi;	// Save to tx_buf[0]
				TX_Mode();			// set TX Mode and transmitting
				TxData(xx);			// send data to uart
				delay_ms(200);
				P0=0xff;			// Turn off the led				
				RX_Mode();			// set receive mode

				while((P0&0x0f)!=0x0f);
		}
	}
}
/**************************************************/

/**************************************************
Function: main();

Description:
  control all subprogrammes;
/**************************************************/
void main(void)
{
	uchar xx;
	TX_DS_flag=0;
	init_io();		// Initialize IO port
	Inituart();		// initialize 232 uart
	init_int0();	// enable int0 interrupt
	config();
	RX_Mode();		// set RX mode
	while(1)
	{
		CheckButtons(); // scan key value and transmit 
		if(flag)		// finish received
		{
			flag=0;		//	set flag=0
			P0=rx_buf[0];	// turn on led
			delay_ms(100);
  			P0=0xff;		// turn off led
			xx=rx_buf[0]>>4;// right shift 4 bits
			TxData(xx);		// send data to uart
		}
		if(TX_DS_flag)
		{
			TX_DS_flag=0;
			P0=0x00;					// turn on all led
	    		delay_ms(100);					// delay 100ms
			P0=0xff;
		}
	}
}
/**************************************************/

/**************************************************
Function: ISR_int0() interrupt 0;

Description:
  if RX_DR=1 or TX_DS or MAX_RT=1,enter this subprogram;
  if RX_DR=1,read the payload from RX_FIFO and set flag;
/**************************************************/
void ISR_int0(void) interrupt 0
{
	uchar temp;
	CE=0;
 	temp = SPI_RW_Reg(WRITE_REG + STATUS, 0x70);	// read register STATUS's value

   	if(temp & RX_DR) // if receive data ready (RX_DR) interrupt
	{
		SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
		flag=1;
	}
   	if(temp & TX_DS) // if receive data ready (RX_DR) interrupt
	{
		TX_DS_flag=1;
	}
	if(temp & MAX_RT)
	{
		SPI_RW_Reg(FLUSH_TX,0);
	}
	CE=1;
}
/**************************************************/