main.c

BK-4810源码

#include "bk_common.h"
#include "App.h"

extern void DisableGlobalIntr();
void command_handle(void);

//code char BK_FW_VERSION[] ="\nBK108X FW 0.0.2";

UINT8 cur_test_item = 0;


xdata UINT8 RX_Parallel_Mode;
extern UINT8 XDATA crystal_type;
extern UINT8 XDATA b_enable_ClassD;
extern UINT8 XDATA b_enable_ClassAB;

extern UINT8 XDATA b_3_CTCSS_send;



//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------

extern xdata unsigned int timer_slice_1ms;

void DelayMs(UINT16 ms)
{
//	Delay(12*ms);
	EA=1;
	timer_slice_1ms=0;
	while(timer_slice_1ms<ms);

}

//-----------------------------------------------------------------------------
// Port_Init
//-----------------------------------------------------------------------------
//
// Return Value - None
// Parameters - None
//
// - Configure the Crossbar and GPIO ports.
//
//-----------------------------------------------------------------------------
void Port_Init(void)
{
	P0MDIN	= 0xFF;		// Port 0 set as digital input
//	P1MDIN  = 0xFF;		// Port 1 set as digital input
	P2MDIN  = 0xFF;		// Port 2 set as digital input

//	P0MDOUT	= 0xff;		// Port 0
//	P1MDOUT	= 0xff;		// Port 1
	P2MDOUT	= 0xf7;		// Port 2

//	P0SKIP	= 0xFF;		// Route no peripherals to Port 0
//	P1SKIP	= 0xFF;		// Route no peripherals to Port 1
	P2SKIP	= 0xFF;		// Skip switches

	XBR1    = 0xC0;		// Enable Crossbar.
}

//-----------------------------------------------------------------------------
// Ext_Interrupt_Init
//-----------------------------------------------------------------------------
//
// Return Value : None
// Parameters   : None
//
// This function configures and enables /INT0 and /INT1 (External Interrupts)
// as negative edge-triggered.
//
//-----------------------------------------------------------------------------
void Ext_Interrupt_Init (void)
{
	//TCON = 0x02;	// /INT 0 are low ledge triggered
	TCON = 0x00;	// bit0 = 0 /INT 0 are low ledge triggered

	IT01CF = 0x04;	// /INT0 active low; /INT0 on P0.6;  //INT1(bit7-4),INT0(bit3-0)

	EX0 = 1;		// Enable /INT0 interrupts
}

//-----------------------------------------------------------------------------
// Main Routine
//-----------------------------------------------------------------------------
void main(void)
{
	sbit_spi_sen = 0;

	RX_Parallel_Mode=0x10;//default: audio on
	
	crystal_type=0;
	b_enable_ClassD=0;
	b_enable_ClassAB=1;
	b_3_CTCSS_send=0;


	System_Init ();

	sbit_spi_sen = 0;

	Usb_Init();

	Ext_Interrupt_Init();

	Delay(1000);

	BK_Analog_Init();

	/* for current chip  */
	BK_Set_Freq(DIR_RX,CHNGB_FREQ_H16, CHNGB_FREQ_L16);
	
	/* feature use */
//	BK_Set_Channel_Num(0);
//	BK_Set_Channel_Space(SPACING_12_5K);
	Delay(500);
	BK_Switch_RX_Type(SPEECH);

	EA = 1;

	DisableGlobalIntr();

	while(1)
	{
		if(OutUsbDataHit)//for debug
		{
			OutUsbDataHit = 0;
			command_handle();
		}

		if(bExtIntr0 == 1)//check interrupt
		{
			bExtIntr0 = 0;
			if(cur_test_item == STEP_IDLE)
			{
				UINT16 intr_value = 0;
				intr_value = BK_Read_Reg(REG_INTR_STATUS);
				BK_Clear_Intr(0xffff);
			}
			else
			{
				BK_Intr_Task();
				//EX0 = 1;          // Enable /INT0 interrupts
			}
		}
	}
}

#if 0
void EnableGlobalIntr(UINT16 intr_value)
{
	EX0 = 1;
	BK_Enable_Intr(intr_value);
}

void DisableGlobalIntr()
{
	EX0 = 0;
	BK_Enable_Intr(0);
}
#endif

void EnableAirMode(UINT8 dir,UINT8 air)
{

	if(dir==DIR_RX)//RX
	{
		if(air)//air mode
		{
			RX_Parallel_Mode|=0x01;
			RX_Parallel_Mode&=0xfb;
		}
		else//not air mode
		{
			RX_Parallel_Mode|=0x04;
			RX_Parallel_Mode&=0xfe;
		}

		Enable_RX_FSK_Air(air);

		Enable_RX_Parallel_Mode(RX_Parallel_Mode);
	}
	else//TX
	{
		Enable_TX_FSK_Air(air);
	}


}


/*******************************
command process
*******************************/
void command_handle(void)
{
	unsigned char  timeout = 0;
	unsigned char  vox_threshold = 0;
	unsigned char  mic_threshold = 0;
	unsigned char  volume = 0;
	unsigned char  output = 0;
	unsigned char  dir = 0;
	unsigned char  freq = 0;
	unsigned short encryption = 0;
	unsigned char  len = 0;
	unsigned char  type = 0;

	switch (OUT_BUFFER.Ptr->MessageType)
	{
		/* Speech TX */
		case BKN_DEMO_SPEECH_TX: 	//0x80:
			//BK_Speech_TX();
			BK_Switch_TX_Type(SPEECH);
			break;

		/* Speech RX */
		case BKN_DEMO_SPEECH_RX: 	//0x81:
			//BK_Speech_RX();

			if(pOutPayload[0])
			{
				BK_Switch_RX_Type(SPEECH);
				RX_Parallel_Mode|=0x10;
			}
			else
				RX_Parallel_Mode&=0xef;
			Enable_RX_Parallel_Mode(RX_Parallel_Mode);

			break;

		/* DTMF TX */
		case BKN_DEMO_DTMF_TX: 		//0x82:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;
			
			if(cur_test_item != BKN_DEMO_DTMF_TX)
				BK_Switch_TX_Type(DTMF);
				//BK_Switch_DTMF_TX();
			
			BK_DTMF_TX(pOutPayload, len);
			break;

		/* DTMF RX */
		case BKN_DEMO_DTMF_RX: 		//0x83:
			if(pOutPayload[0])
			{
				BK_DTMF_RX();
				RX_Parallel_Mode|=0x08;;
			}
			else
				RX_Parallel_Mode&=0xf7;
			Enable_RX_Parallel_Mode(RX_Parallel_Mode);
			
			break;

		/*  SELCALL TX */
		case BKN_DEMO_SELCALL_TX: 	//0x84:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;
			
			if(cur_test_item != BKN_DEMO_SELCALL_TX)
				//BK_Switch_SCLCALL_TX();
				BK_Switch_TX_Type(SELCALL);
			
			BK_SELCALL_TX(pOutPayload, len);
			break;

		/* SELCALL RX */
		case BKN_DEMO_SELCALL_RX: 	//0x85:

			if(pOutPayload[0])
			{
				BK_SELCALL_RX();
				RX_Parallel_Mode|=0x02;
			}
			else
				RX_Parallel_Mode&=0xfd;

			Enable_RX_Parallel_Mode(RX_Parallel_Mode);
			
			break;

		case BKN_DEMO_FSK_TX:
			len = OUT_BUFFER.Ptr->len;
			
			if(0 == len)
				break;
	
			if(cur_test_item != BKN_DEMO_FSK_TX)
			{
				//BK_Switch_FSK_TX();
				BK_Switch_TX_Type(FSK);
			}
			
			BK_FSK_TX_Init(FSK_TX_TYPE1, pOutPayload, len);
			BK_FSK_TX(pOutPayload, len);
			break;
			
		case BKN_DEMO_FSK_RX:
			if(pOutPayload[0])
			{
				disable_fsk_test();
				BK_FSK_RX();

				if(fsk_test_cfg.fsk_air)
				{
					RX_Parallel_Mode|=0x01;
					RX_Parallel_Mode&=0xfb;
				}
				else
				{
					RX_Parallel_Mode|=0x04;
					RX_Parallel_Mode&=0xfe;
				}

			}
			else
				RX_Parallel_Mode&=0xfa;
			Enable_RX_Parallel_Mode(RX_Parallel_Mode);

			break;

		case BKN_DEMO_CTCSS_TX:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

			freq = pOutPayload[0];

			if(cur_test_item != BKN_DEMO_CTCSS_TX)
			{
				BK_Switch_TX_Type(CTCSS);
			}

			BK_CTCSS_TX(freq);
			break;

		case BKN_DEMO_CTCSS_3_TX:			
			if(cur_test_item != BKN_DEMO_CTCSS_TX)
			{
				BK_Switch_TX_Type(CTCSS);
			}

			Send_CTCSS_Tag(pOutPayload[0],pOutPayload[1],pOutPayload[2]);
						
		case BKN_DEMO_CTCSS_RX:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

			freq = pOutPayload[0];

			if(cur_test_item != BKN_DEMO_CTCSS_RX)
			{
				BK_Switch_RX_Type(CTCSS);
			}

			BK_CTCSS_RX(freq);
			break;

		case BKN_DEMO_CDCSS_TX:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

			freq = pOutPayload[0];

			if(cur_test_item != BKN_DEMO_CDCSS_TX)
			{
				BK_Switch_TX_Type(CDCSS);
			}
			
			BK_CDCSS_TX(freq);
			break;
			
		case BKN_DEMO_CDCSS_RX:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

			freq = pOutPayload[0];

			if(cur_test_item != BKN_DEMO_CDCSS_RX)
			{
				BK_Switch_RX_Type(CDCSS);
			}

			BK_CDCSS_RX(freq);
			break;

		case BKN_DEMO_SET_TOT:
			timeout = pOutPayload[0];
			BK_Set_TOT(timeout);
			break;
			
		case BKN_DEMO_SET_VOX:
			vox_threshold = pOutPayload[0];
			BK_Set_VOX(vox_threshold);
			break;

		case BKN_DEMO_SET_MIC_THRSHLD:
			mic_threshold = pOutPayload[0];
			BK_Set_MIC_Threshold(mic_threshold);
			break;

		case BKN_DEMO_SET_RX_FREQ:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

#if 0
			if((pOutPayload[4] == FRS)||(pOutPayload[4]==GMRS) )
			{
				BK_Set_Channel_Space(SPACING_25K);			
			}
			else
			{
				BK_Set_Channel_Space(SPACING_12_5K);			
			}

#endif

			encryption = (pOutPayload[1] << 8) | pOutPayload[0];
			ttt = (pOutPayload[3] << 8) | pOutPayload[2];
			//type = pOutPayload[0];
			//freq = pOutPayload[1];
			//Freq_Type = pOutPayload[4];
			BK_Set_Freq(DIR_RX,  encryption, ttt);
			break;

			
		case BKN_DEMO_SET_TX_FREQ:
			len = OUT_BUFFER.Ptr->len;
			if(0 == len)
				break;

#if 0
			if((pOutPayload[4] == FRS)||(pOutPayload[4]==GMRS) )
			{
				BK_Set_Channel_Space(SPACING_25K);			
			}
			else
			{
				BK_Set_Channel_Space(SPACING_12_5K);			
			}

#endif

			encryption = (pOutPayload[1] << 8) | pOutPayload[0];

			ttt = (pOutPayload[3] << 8) | pOutPayload[2];
			//type = pOutPayload[0];
			//freq = pOutPayload[1];
			//Freq_Type = pOutPayload[4];
			BK_Set_Freq(DIR_TX, encryption, ttt);
			break;
			
		case BKN_DEMO_SET_CHANNEL_NUM:
			BK_Set_Channel_Num(pOutPayload[0],pOutPayload[1]);
			break;


		case BKN_DEMO_RESET:
			BK_Reset();
			break;
			
		case BKN_DEMO_POWERDOWN:
			BK_Powerdown();
			break;

		case BKN_DEMO_POWERUP:
			BK_Powerup();
			break;

		case BKN_DEMO_SET_SNR_THRSHLD:
			BK_Set_SNR_Threshold(pOutPayload[0]);
			break;
			
		case BKN_DEMO_SET_RSSI_THRSHLD:
			BK_Set_RSSI_Threshold(pOutPayload[0]);
			break;

		case BKN_DEMO_SET_MUTE:
			BK_Set_Soft_Mute(pOutPayload[0]);
			break;

		case BKN_DEMO_SET_TX_VOUME:
			volume = pOutPayload[0];
			BK_Set_TX_Volume(volume);
			break;
			
		case BKN_DEMO_SET_RX_VOUME:
			volume = pOutPayload[0];
			BK_Set_RX_Volume(volume);
			break;


		case BKN_DEMO_DISABLE_SCRAMBLING:
			dir = pOutPayload[0];
			BK_Disable_Scrambling(dir);
			break;
			
		case BKN_DEMO_SET_INVERSE_FREQUENCY:
			//freq = *((UINT8 *)(&(OUT_BUFFER.Ptr->pPayload)));
			//dir = *((UINT8 *)(&(OUT_BUFFER.Ptr->pPayload)) + 1);
			freq = pOutPayload[0];
			dir =  pOutPayload[1];
			BK_Set_Inverse_Frequency(dir, freq);
			break;
			
		case BKN_DEMO_SET_ENCRYPTION:
			encryption = (pOutPayload[1] << 8) | pOutPayload[0];
			dir = pOutPayload[2];
			BK_Set_Encryption(dir, pOutPayload[0],pOutPayload[3]);
			break;

		case BKN_DEMO_QUERY_SIGNAL:
			pInPayload[0] = BK_Read_RSSI(); /* RSSI 7bit */
			pInPayload[1] = BK_Read_SNR(); /* SNR 7bit */
			pInPayload[2] = BK_Read_Audio_RSSI(); /* Audio RSSi 8bit */
			USBPrint32B(BKN_DEMO_READ_SIGNAL, 3);
			break;
			
		case BK_CMD_WRITE_REG:
			encryption = (UINT16)(pOutPayload[1]);
			encryption = encryption << 8;
			encryption |= pOutPayload[2];

			BK_Write_Reg(pOutPayload[0], encryption);
			break;
			
		case BK_CMD_READ_REG:
			encryption = BK_Read_Reg(pOutPayload[0]);
			USBPrintWord(BK_CMD_READ_REG, encryption);
			break;
			
		case BKN_DEMO_ENABLE_AGC:
			Enable_AGC(pOutPayload[0]);
			break;			
			
		case BKN_DEMO_FSK_AIR_MODE:
			if(pOutPayload[0]==DIR_RX)//RX
			{
				if(pOutPayload[1])//air mode
				{
					RX_Parallel_Mode|=0x01;
					RX_Parallel_Mode&=0xfb;
				}
				else//not air mode
				{
					RX_Parallel_Mode|=0x04;
					RX_Parallel_Mode&=0xfe;
				}

				Enable_RX_FSK_Air(pOutPayload[1]);

				Enable_RX_Parallel_Mode(RX_Parallel_Mode);
			}
			else//TX
			{
				Enable_TX_FSK_Air(pOutPayload[1]);
			}

			break;
			
		case BKN_DEMO_CRYSTAL_SEL:
			SelectCrystal(pOutPayload[0]);
			break;

		case BKN_DEMO_CLASS_D_SEL:
			Enable_Class_D(pOutPayload[0]);
			break;

		case BKN_DEMO_CLASS_AB_SEL:
			Enable_Class_AB(pOutPayload[0]);
			break;
		case BKN_DEMO_AUDIO_LOOP_MODE:
			if(pOutPayload[0]==DIR_RX)
			{
				if(pOutPayload[2])//start				
					Enter_RX_Audio_LoopBack_Mode();
				else
					Exit_RX_Audio_LoopBack_Mode();

			}
			else
			{
				if(pOutPayload[2])//start				
					Enter_TX_Audio_LoopBack_Mode(pOutPayload[1]);	
				else
					Exit_TX_Audio_LoopBack_Mode();

			}

			break;

	    default :
			cur_test_item = STEP_IDLE;
			break;
	}//switch
	
	if(BKN_DEMO_AUDIO_LOOP_MODE!=message_type)
		cur_test_item = message_type;
}