lt8900_receive_main_bac.#1

LT8900

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

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


#define SYSCLK					12000000    // SYSCLK frequency in Hz
#define BAUDRATE        115200         // Baud rate of UART in bps
#define DELAY						5
#define BUFLEN					15
#define EBUFLEN					200

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

unsigned char RBUF[BUFLEN];
unsigned char TBUF[BUFLEN];
unsigned char xdata EBUF[EBUFLEN];
unsigned char tlen=0, channel=20;
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 LT6210_Init(void);

// SPI Related 
extern unsigned char SPI_SendByte (unsigned char tbyte);
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;
	
	//Initialize F342
	Init_Device();
	UART0_Init();
	LT6210_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();
	
	//===================================================
	// Test Code start
	//===================================================
	while(1)
	{
	// RX Test Program with print out. TEst RSSI
	LT_WriteReg(82, 0x80, 0x80);
		LT_WriteReg(57, 0xE0, 0x00);
		LT_WriteReg(80, 5, 'S');
		LT_WriteReg(80, 'U', 'P');
		LT_WriteReg(80, 'E', i);
		LT_WriteReg(7, 0x01, 0x00+20);
		LT_ReadReg(3);
		delay_us(1000);
		while (PKT_FLAG == 0)
		{
			i++;

		}

	
	}

	//===================================================
	// 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
  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
  XBR1      = 0x40; //Enable Crossbar and weak pull-up

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

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 LT6210_Init(void)
{
	RESET_N = 1; 		//Enable 6210
	delay_us(5000); //delay 5ms to let LT6210 stable	
	CLK = 0; //set SPI clock to low
	
	LT_WriteReg(0, 0xCD, 0x51);
	LT_WriteReg(2, 0x13, 0x7B);
	LT_WriteReg(4, 0x3C, 0xD0);
	LT_WriteReg(5, 0x00, 0x81);
	LT_WriteReg(7, 0x00, 0x30);

	LT_WriteReg(8, 0x04, 0x04);
	LT_WriteReg(9, 0x30, 0x03);
	LT_WriteReg(10, 0x00, 0x04);
	LT_WriteReg(11, 0x40, 0x41);
	LT_WriteReg(12, 0x00, 0x00);

	LT_WriteReg(13, 0x00, 0x00);
	LT_WriteReg(14, 0x66, 0x97);
	LT_WriteReg(15, 0x01, 0x7B);
	LT_WriteReg(16, 0xF0, 0x00);
	LT_WriteReg(17, 0x00, 0x00);
	LT_WriteReg(18, 0xE0, 0x00);

	LT_WriteReg(19, 0x21, 0x14);
	LT_WriteReg(20, 0x81, 0x9C);
	LT_WriteReg(21, 0x69, 0x62);
	LT_WriteReg(22, 0x04, 0x02);
	LT_WriteReg(23, 0x08, 0x02);

	LT_WriteReg(24, 0xB0, 0x40);
	LT_WriteReg(25, 0x78, 0x19);
	LT_WriteReg(26, 0x67, 0x04);
	LT_WriteReg(27, 0x00, 0x00);
	LT_WriteReg(28, 0x18, 0x00);

	LT_WriteReg(48, 0x58, 0x00);
	LT_WriteReg(49, 0xC0, 0x0F);
	LT_WriteReg(50, 0x96, 0x28);
	LT_WriteReg(51, 0x83, 0x00);
	LT_WriteReg(52, 0x03, 0x80);

	LT_WriteReg(53, 0x03, 0x80);
	LT_WriteReg(54, 0x03, 0x80);
	LT_WriteReg(55, 0x03, 0x80);
	LT_WriteReg(56, 0x44, 0x07);

	LT_WriteReg(57, 0xB0, 0x00);


	delay_us(10000); //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;
}

//==========================================================
// LT8900 Routing
//==========================================================

void LT_ReadReg(unsigned char reg)
{
	SS = 0;
	reg = SPI_SendByte(reg+0x80);
	RegH = SPI_SendByte(0xFF);
	RegL = SPI_SendByte(0xFF);
	SS = 1;
}

void LT_WriteReg(unsigned char reg, unsigned char H, unsigned char L)
{
	SS = 0;
	reg = SPI_SendByte(reg);
	RegH = SPI_SendByte(H);
	RegL = SPI_SendByte(L);
	SS = 1;
}

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();
}