//----------------------------------------------------
//   F342 Test Program
//----------------------------------------------------

#include <C8051F340.h>                 // SFR declarations
#include <intrins.h>
#include "LT8900.h"

#define _HIGHSPEED_SPI_  1 //Debug SPI Interface
#define MAX_BUFFER_SIZE    8           // Maximum buffer Master will send
#define SYSCLK					12000000    // SYSCLK frequency in Hz
#define SPI_CLOCK				6000000

#define BAUDRATE        115200         // Baud rate of UART in bps
#define DELAY						5
#define BUFLEN					24
#define EBUFLEN					200

// SPI Instruction Set
#define  SLAVE_LED_ON      0x01        // Turn the Slave LED on
#define  SLAVE_LED_OFF     0x02        // Turn the Slave LED off
#define  SPI_WRITE         0x04        // Send a byte from the Master to the
                                       // Slave
#define  SPI_READ          0x08        // Send a byte from the Slave to the
                                       // Master
#define  SPI_WRITE_BUFFER  0x10        // Send a series of bytes from the
                                       // Master to the Slave
#define  SPI_READ_BUFFER   0x20        // Send a series of bytes from the Slave
                                       // to the Master
#define  ERROR_OCCURRED    0x40        // Indicator for the Slave to tell the

unsigned char SPI_Data = 0xA5;

unsigned char SPI_Data_Array[MAX_BUFFER_SIZE] = {0};

bit Error_Flag = 0;

unsigned char Command = 0x00;

//---------------------------------------------------------------------
// Glabal Definition
//---------------------------------------------------------------------
sbit  LED      = P2^2;                 // LED='1' means ON
sbit  SW       = P2^0;                 // SW = '0' means button is pressed
sbit  SIG      = P2^7;

unsigned char RBUF[BUFLEN];
unsigned char TBUF[BUFLEN];
unsigned char xdata EBUF[EBUFLEN];
unsigned char tlen=0, channel=0x20;
signed char dlen;

unsigned char bdata R,RegH, RegL;
sbit	H0 = RegH^0;
sbit	H1 = RegH^1;
sbit	H2 = RegH^2;
sbit	H3 = RegH^3;
sbit	H4 = RegH^4;
sbit	H5 = RegH^5;
sbit	H6 = RegH^6;
sbit	H7 = RegH^7;

sbit	L0 = RegL^0;
sbit	L1 = RegL^1;
sbit	L2 = RegL^2;
sbit	L3 = RegL^3;
sbit	L4 = RegL^4;
sbit	L5 = RegL^5;
sbit	L6 = RegL^6;
sbit	L7 = RegL^7;

//subrouting
void putchar (char c);
void print_string (char pstring[]);
void delay_us (unsigned int us);
void Init_Device(void);
void UART0_Init (void);
void LT8900_Init(void);
void SPI0_Init (void);  //new added by yfwen 2010.8

// SPI Related 
#if (!_HIGHSPEED_SPI_)
extern unsigned char SPI_SendByte (unsigned char tbyte);
#else
unsigned char SPI_SendByte(unsigned char buf);
#endif
void SPI_SendFrame (void);
void SPI_CleanBuffer (void);

void LT_ReadReg(unsigned char reg);
void LT_WriteReg(unsigned char reg, unsigned char H, unsigned char L);
void LT_SetSyncWord (void);
void LT_StartTX(void);
void LT_StartRX(void);
void LT_StopRTX(void);
void LT_SetRFPower(unsigned char power);
unsigned char LT_GetRFPower(void);
void LT_DisableRSSI(void);
void LT_EnableRSSI(void);
void LT_ReadAllReg(void);
void LT_SetChannel(unsigned channel);
unsigned char LT_GetChannel(void);
void LT_CleanWFIFO(void);
void LT_RSSI_SCAN(unsigned char start_ch, unsigned char ch_no);
void LT_SendPacket(void);


//--------------------------------------------------
//Main Routing
//--------------------------------------------------
void main(void)
{
	unsigned int i=0;
	unsigned char j=0;
	
	//Initialize F342
	Init_Device();
	SPI0_Init();
	//UART0_Init();
	LT8900_Init();
	//Wait internal HF oscillator stable and set LED light to indicate.

	RESET_N = 1; 		//Enable 8900
	delay_us(5000); //delay 5ms to let LT8900 stable	
	
	SPI_CleanBuffer();
	//	LT_WriteReg(35, 0x83, 0x20);
	//===================================================
	// Test Code start
	//===================================================
	while(1)
	{

#if 0   //Send out 64 bytes

//		LT_WriteReg(7, 0x010, 0x20);
		LT_CleanWFIFO();

		LT_WriteReg(50, 64, 0);
		while(j<31) 
		{
			LT_WriteReg(50, j, 0x1e);
			j++;
		}
		
//		LT_StartTX(); 
		LT_WriteReg(7, 0x01, 0x20);
		while (PKT_FLAG == 0);
#if SLEEP_MODE		
		LT_WriteReg(35,0x63,0x88);
        SS = 1;
        delay_us(2000);
		SS = 0;
#endif

		LT_WriteReg(7, 0x00, 0x20);
#endif

#if 1 //Send out 11 Byte

		LT_CleanWFIFO();

		LT_WriteReg(50, 11, 0);

		LT_WriteReg(50, j, 0x1e);
		LT_WriteReg(50, j, 0x1e);
		LT_WriteReg(50, j, 0x1e);
		LT_WriteReg(50, j, 0x1e);
		LT_WriteReg(50, j, 0x1e);


//		LT_StartTX 

		LT_WriteReg(7, 0x01, 0x20);
		while (PKT_FLAG == 0);
         delay_us(10000);
#if SLEEP_MODE		
		LT_WriteReg(35,0x63,0x88);
        SS = 1;
        delay_us(2000);
		SS = 0;
#endif
		LT_WriteReg(7, 0x00, 0x20);
		j++;
		i++;
#endif
	}
//===================================================
// Test Code Finish
//===================================================
}

//-------------------------------------------------------------
// Delay some micro second
//-------------------------------------------------------------
void delay_us (unsigned int us)
{
	for (; us>0; us--);
}

//-------------------------------------------------------------
// Output a character to the UART
//-------------------------------------------------------------
void putchar (char c)
{
	while (!TI0); //Wait until last transmit finish
	TI0 = 0; //clean TX signal
	if (c == '\n') //If is return, send LF/RT
	{
		SBUF0 = 0x0D;
		while (!TI0);
		SBUF0 = 0x0A;
	}
	else
		SBUF0 = c;
}

//-------------------------------------------------------------
// Output a string to the UART
// return is supported
//-------------------------------------------------------------
void print_string (char pstring[])
{
   unsigned char i = 0;
   XBR0 = 0x01; //disable SPI
   while (pstring[i])
   {
      putchar(pstring[i++]);
   }
   XBR0 = 0x03; //enable SPI
}

//=======================================================================
//--------------------------------------------------------------
// Initialization fuctions
//-------------------------------------------------------------
void Init_Device(void)
{
	//Close watchdog
	PCA0MD &= ~0x40; //disable watchdog

	//Port IO Init
  //P0MDOUT   = 0x10; //P0.4 are push-pull, others are open-drain
	P0MDOUT   = 0x1D;
  PKT_FLAG = 1;//
  FIFO_FLAG = 1;
//	P0SKIP		= 0x00; //P0 skip P0.6 and P0.7
	P1MDOUT		= 0x1E; //P1.1~P1.4 is push-pull, P1.0 is open-drain for input
	P1SKIP		= 0xE0; //P1.0 ~ P1.4 are used, P1.5 ~ P1.7 skip
	RESET_N   = 0; //disable LT8900
	P2MDIN		&=	~0x20; //P2.5 is analog input
	P2MDOUT	  = 0x04; //P2.2 is push-pull
  P2SKIP    = 0x03; //P2.0 and P2.1 are skip
  
  //XBR0      = 0x01; //Enable UART
  XBR0      = 0x03;
  XBR1      = 0x40; //Enable Crossbar and weak pull-up

	//Oscillator Init
  OSCICN    = 0x83; //internal HF clock, 12MHz
  LED = 0;
	while ( (OSCICN & 0x40) == 0);
	LED = 1;
}

//-----------------------------------------------------------------------------
// SPI0_Init
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters   : None
//
// Configures SPI0 to use 4-wire Single Master mode. The SPI timing is
// configured for Mode 0,0 (data centered on first edge of clock phase and
// SCK line low in idle state).
//
//-----------------------------------------------------------------------------
void SPI0_Init()
{
   SPI0CFG   = 0x60;                   // Enable the SPI as a Master
                                       // CKPHA = '0', CKPOL = '0'
   SPI0CN    = 0x0D;                   // 4-wire Single Master, SPI enabled

   // SPI clock frequency equation from the datasheet
   SPI0CKR   = (SYSCLK/(2*SPI_CLOCK))-1;

   //ESPI0 = 1;                          // Enable SPI interrupts
}

void UART0_Init (void)
{
	// SCON0: 8-bit variable bit rate
	//        level of STOP bit is ignored
	//        RX enabled
	//        ninth bits are zeros
	//        clear RI0 and TI0 bits
  SCON0 = 0x10;                       
	CKCON     = 0x08;
	TH1       = 0xCC;  //Using sysclk 12MHz and buad rate is 115200
	TL1 = TH1;                          // Init Timer1
	TMOD &= ~0xf0;                      // TMOD: timer 1 in 8-bit autoreload
	TMOD |=  0x20;
	TR1 = 1;                            // START Timer1
	TI0 = 1;                            // Indicate TX0 ready
}

void LT8900_Init(void)
{
//	unsigned char i;
	RESET_N = 0; 	
	delay_us(1000);
	RESET_N = 1; 		//Enable 8900
	delay_us(5000); //delay 5ms to let LT8900 stable	
	CLK = 0; //set SPI clock to low
#if 1  //ok
	LT_WriteReg(0, 0x6F, 0xE0);
	LT_WriteReg(1, 0x56, 0x81);
	LT_WriteReg(2, 0x66, 0x17);
	LT_WriteReg(4, 0x9C, 0xC9);
	LT_WriteReg(5, 0x66, 0x37);
	LT_WriteReg(7, 0x00, 0x00);
	LT_WriteReg(8, 0x6C, 0x90);
	LT_WriteReg(9, 0x1f, 0xc0);
	LT_WriteReg(10, 0x7F, 0xFD);
	LT_WriteReg(11, 0x00, 0x08);
	LT_WriteReg(12, 0x00, 0x00);
	LT_WriteReg(13, 0x48, 0xBD);

	LT_WriteReg(22, 0x00, 0xff);
	LT_WriteReg(23, 0x80, 0x05);
	LT_WriteReg(24, 0x00, 0x67);
	LT_WriteReg(25, 0x16, 0x59);
	LT_WriteReg(26, 0x19, 0xE0);
	LT_WriteReg(27, 0x12, 0x00);
	LT_WriteReg(28, 0x18, 0x00);
	
	LT_WriteReg(32, 0x50, 0x04);
	LT_WriteReg(33, 0x3f, 0xC7);
	LT_WriteReg(34, 0x20, 0x00);
	LT_WriteReg(35, 0x03, 0x20);
	LT_WriteReg(36, 0x03, 0x80);
	LT_WriteReg(37, 0x03, 0x80);
	LT_WriteReg(38, 0x5A, 0x5A);
	LT_WriteReg(39, 0x03, 0x80);
	LT_WriteReg(40, 0x44, 0x01);
	LT_WriteReg(41, 0xe0, 0x00);
	LT_WriteReg(42, 0xFD, 0xB0);
	LT_WriteReg(43, 0x00, 0x0F);
	LT_WriteReg(50, 0x00, 0x00);
#endif
	delay_us(10000); //delay 10ms to let LT8900 for operation
}
//=======================================================================

//=======================================================================
// SPI Routing
//=======================================================================

void SPI_SendFrame (void)
{
		unsigned char i, j;

		SS = 0;
		for (j=0; j<tlen; j++)
			RBUF[j] = SPI_SendByte(TBUF[j]);
		SS = 1;
}

void SPI_CleanBuffer (void)
{
	register char i;
	for (i = 0; i<BUFLEN; i++)	RBUF[i] = 0;
}

#if _HIGHSPEED_SPI_
unsigned char SPI_SendByte(unsigned char buf)
{
	int i = 0;
	unsigned char retVal;
    while (!NSSMD0);                    // Wait until the SPI is free, in case
                                       // it's already busy

    NSSMD0 = 0;
	for(i=0;i<1;i++);
	SPI0DAT = buf;
	for(i=0;i<2;i++);
	retVal  = SPI0DAT;
	for(i=0;i<4;i++);
	NSSMD0 = 1;			
}
#endif

//==========================================================
// LT8900 Routing
//==========================================================
#if (_HIGHSPEED_SPI_)
void LT_ReadReg(unsigned char reg)
{
   int i = 0;
   while (!NSSMD0);                    // Wait until the SPI is free, in case
                                       // it's already busy

    NSSMD0 = 0;
	//for(i=0;i<4;i++);
	SPI0DAT = reg+0x80;
	for(i=0;i<1;i++);
	SPI0DAT = 0xFF;
	//for(i=0;i<2;i++);
	RegH = SPI0DAT;
	//for(i=0;i<2;i++);
	SPI0DAT = 0xFF;
	//for(i=0;i<2;i++);
	RegL = SPI0DAT;
	for(i=0;i<5;i++);
	NSSMD0 = 1;	
}
#else
void LT_ReadReg(unsigned char reg)
{
	int i=0;
	SS = 0;
	for(i=0;i<10;i++);
	reg = SPI_SendByte(reg+0x80);
	for(i=0;i<10;i++);
	RegH = SPI_SendByte(0xFF);
	for(i=0;i<10;i++);
	RegL = SPI_SendByte(0xFF);
	for(i=0;i<10;i++);
	SS = 1;
}
#endif

#if (_HIGHSPEED_SPI_)
void LT_WriteReg(unsigned char reg, unsigned char H, unsigned char L)
{
	int i = 0;
	//SPI_Byte_Write(H);
   while (!NSSMD0);                    // Wait until the SPI is free, in case
                                       // it's already busy
   NSSMD0 = 0;
   for(i=0;i<2;i++);
   SPI0DAT = reg;
   for(i=0;i<2;i++);
   SPI0DAT = H;
   for(i=0;i<2;i++);
   SPI0DAT = L;
   for(i=0;i<5;i++);
   NSSMD0 = 1;
}
#else
void LT_WriteReg(unsigned char reg, unsigned char H, unsigned char L)
{
	int i=0;
	SS = 0;
	for(i=0;i<10;i++);
	reg = SPI_SendByte(reg);
		for(i=0;i<10;i++);
	RegH = SPI_SendByte(H);
		for(i=0;i<10;i++);
	RegL = SPI_SendByte(L);
		for(i=0;i<10;i++);
	SS = 1;
}
#endif

void LT_SetSyncWord (void)
{
		TBUF[0] = 0x24; //reg36 to reg39
		TBUF[1] = SYNCWORD_0;
		TBUF[2] = SYNCWORD_1;
		TBUF[3] = SYNCWORD_2;
		TBUF[4] = SYNCWORD_3;
		TBUF[5] = SYNCWORD_4;
		TBUF[6] = SYNCWORD_5;
		TBUF[7] = SYNCWORD_6;
		TBUF[8] = SYNCWORD_7;
		tlen = 9;
		SPI_SendFrame();
}

void LT_StartTX(void)
{
	LT_ReadReg(0x07);
	H0 = 1; //enable TX;
	LT_WriteReg(0x07, RegH, channel);
	tlen = 0;
}

void LT_StartRX(void)
{
	LT_ReadReg(0x07);
	H0 = 0;
	LT_WriteReg(0x07, RegH, channel+0x80);

}

void LT_StopRTX(void)
{
	LT_ReadReg(0x07);
	H0 = 0;
	L7 = 0;
	LT_WriteReg(0x07, RegH, RegL);
}

void LT_SetRFPower(unsigned char power)
{
	LT_ReadReg(0x09);
	RegH &= 0x0F;
	power = power << 4;
	RegH |= power;
	LT_WriteReg(0x09, RegH, RegL);
}

unsigned char LT_GetRFPower(void)
{
	LT_ReadReg(0x09);
	return (RegH >> 4);
}

void LT_DisableRSSI(void)
{
	LT_ReadReg(0x0B);
	H0 = 1;
	LT_WriteReg(0x0B, RegH, RegL);
}

void LT_EnableRSSI(void)
{
	LT_ReadReg(0x0B);
	H0 = 0;
	LT_WriteReg(0x0B, RegH, RegL);
}

void LT_ReadAllReg(void)
{
	unsigned char i;
	SS = 0;
	SPI_SendByte(0x80);
	EBUF[0] = SPI_SendByte(0x80);
	for (i=1; i<107; i++)
	{
		EBUF[i] = SPI_SendByte(0xFF);
	} 
	SS = 1;
}

void LT_SetChannel(unsigned channel)
{
	LT_ReadReg(0x07);
	RegL &= 0x80;
	RegL |= channel;
	LT_WriteReg(0x07, RegH, RegL);
}

unsigned char LT_GetChannel(void)
{
	LT_ReadReg(0x07);
	return(RegL & 0x7F);
}

void LT_ReadFIFOPoint(void)
{
	LT_ReadReg(0x34);
	W_FIFO = RegH & 0x3F;
	R_FIFO = RegL & 0x3F;
}

void LT_CleanWFIFO(void)
{
	LT_ReadReg(0x34);
	H7 = 1;
	LT_WriteReg(0x34, RegH, RegL);
}	

void LT_RSSI_SCAN(unsigned char start_ch, unsigned char ch_no)
{
	TBUF[0]=0x2A;
	TBUF[1]=ch_no << 2;
	TBUF[2]=10;
	tlen=3;
	SPI_SendFrame();
	
	TBUF[0]=0x2B;
	TBUF[1]=start_ch + 0x80;;
	TBUF[2]=0x6B;
	SPI_SendFrame();
	
	delay_us(10000);
	
	LT_ReadFIFOPoint();
}

void LT_SendPacket(void)
{
	unsigned char i = 0;
	
	LT_CleanWFIFO(); //Reset writing FIFO point to 0;
	if (dlen < 1) return;
	LT_WriteReg(50, dlen, TBUF[i]);
	dlen--;
	i++;
	while (dlen > 0)
	{
		LT_WriteReg(50, TBUF[i], TBUF[i+1]);
		dlen -= 2;
		i += 2;
	}
	
	LT_StartTX();
	while (PKT_FLAG == 0);
}