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

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

#define _DEBUG_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					12

// 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

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

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 (!_DEBUG_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);

// LT8900 Related
void LT_ReadReg(unsigned char reg);
void LT_WriteReg(unsigned char reg, unsigned char H, unsigned char L);
void LT_SetSyncWord (void);

// Test program


//--------------------------------------------------
//Main Routing
//--------------------------------------------------
void main(void)
{
	unsigned int i=0;
	unsigned int j=0;
	unsigned int Cnt_CRC=0,Cnt_err=0;
	//Initialize F342
	Init_Device();
	SPI0_Init();
	//UART0_Init();
	LT8900_Init();
	while(1)
	{
	// RX Test Program with print out. TEst RSSI
		LT_WriteReg(52, 0x80, 0x80);
		LT_WriteReg(7, 0x00, 0x80 + 0x20);

		while (PKT_FLAG == 0);
		i++;
		#if 0
		{
		//Ready to read Packets from FIFO
			LT_ReadReg(50);
			RBUF[0]=RegH;
			RBUF[1]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[2]=RegH;
			RBUF[3]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[4]=RegH;
			RBUF[5]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[6]=RegH;
			RBUF[7]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[8]=RegH;
			RBUF[9]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[10]=RegH;
			RBUF[11]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[12]=RegH;
			RBUF[13]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[14]=RegH;
			RBUF[15]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[16]=RegH;
			RBUF[17]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[18]=RegH;
			RBUF[19]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[20]=RegH;
			RBUF[21]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[22]=RegH;
			RBUF[23]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[10]=RegH;
			RBUF[11]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[12]=RegH;
			RBUF[13]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[14]=RegH;
			RBUF[15]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[16]=RegH;
			RBUF[17]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[18]=RegH;
			RBUF[19]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[20]=RegH;
			RBUF[21]=RegL;
			delay_us(1);
			LT_ReadReg(50);
			RBUF[22]=RegH;
			RBUF[23]=RegL;
			delay_us(1);
		}
		#endif
	}
}

//-------------------------------------------------------------
// 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;                     // New added by yfwen Doing Make SCK, MOSI, and NSS push-pull
    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 = 0x03;                        // Enable the SPI on the XBAR
    //XBR0      = 0x01; //Enable UART
    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)
{
	RESET_N = 0; 	
	delay_us(1000);
	RESET_N = 1; 		//Enable 6210
	CLK = 0; //set SPI clock to low
	delay_us(50000); //delay 5ms to let LT6210 stable
	
#if 1  //test
	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, 0x18, 0x40);
	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, 0x00);
	LT_WriteReg(33, 0x3f, 0xC7);
	LT_WriteReg(34, 0x30, 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(2000); //delay 10ms to let LT6210 for operation	

}
//=======================================================================

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

void SPI_SendFrame (void)
{
		unsigned char 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 _DEBUG_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<10;i++);
	SPI0DAT = buf;
	for(i=0;i<10;i++);
	retVal  = SPI0DAT;
	for(i=0;i<10;i++);
	NSSMD0 = 1;			
}
#endif
//==========================================================
// LT8900 Routing
//==========================================================
#if 0
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 _DEBUG_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<10;i++);
	SPI0DAT = reg+0x80;
	for(i=0;i<10;i++);
	SPI0DAT = 0xFF;
	for(i=0;i<10;i++);
	RegH = SPI0DAT;
	for(i=0;i<10;i++);
	SPI0DAT = 0xFF;
	for(i=0;i<10;i++);
	RegL = SPI0DAT;
	for(i=0;i<10;i++);
	NSSMD0 = 1;	
}
#endif

#if 0
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

#if _DEBUG_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<10;i++);
   SPI0DAT = reg;
   for(i=0;i<10;i++);
   SPI0DAT = H;
   for(i=0;i<10;i++);
   SPI0DAT = L;
   for(i=0;i<10;i++);
   NSSMD0 = 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();
}