drv_print_gd61.c

CC1000 Rf modem C codes for philips sLpc213X ARM MCU.

#include "config_GD61.h"
#include "include_GD61.h"
#include <stdio.h>

extern uint16 PowerLine_ID;		//number of line
extern uint16 ModuleAddress;	//=0x5555;	//module address
extern uint16 Pkg_SerialNum;	//serial number of package.

extern uint16 TransferKKK;
extern uint16 ControlTime;

extern int32 ADC_IIK_Value;		// calibrate K for I
extern int32 ADC_UUK_Value;		// calibrate K for U

extern int32 StdOutput_RO;
extern int32 StdOutput_LC;
//extern int32 CurOutput_RO;
//extern int32 CurOutput_LC;

extern int32  ADC_IIK_Value;	//calibrate K for I
extern int32  ADC_UUK_Value;	//calibrate K for U
extern uint16 MaxInputLimitII;

extern ROUTETABLE UpRouteTable[MAX_BRANCH_LINE_NUM];
extern ROUTETABLE DnRouteTable[MAX_BRANCH_LINE_NUM];

extern TIMEACTION ActionTime[MAX_CONTROL_TABLE_NUM];
extern CALENDAR   CurrentTime;

char title_s1[]="self_testing program for GD60/GD60X light control modul.";
char title_s2[]="         ___copy right reserved by GDPRI. 26th Oct.2005.";
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////

void PrintTitleGD61(void);
void RFprint_title_(void);
void PrintInfoGD61(void);
void PrintAlarmInfo(void);
void RF_PrintInfoGD61(void);
void RF_PrintInfoGD61L(void);

void Rep_UnexpectedInt(void);
void TestRF_Module(void);

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
void PrintTitleGD61(void)
{
////
	Uart0SendEnter();
	Uart0SendString(title_s1);
	Uart0SendString(title_s2);
	Uart0SendString("System start...waitting for self_test.");
	Uart0SendEnter();
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
// sending it to UART0 channel

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
void PrintAlarmInfo(void)
{

}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
void RFprint_title_(void)
{
////
	RF_SendString(title_s1);
	RF_SendString(title_s2);
	RF_SendEnter();
}

//////////////////////////////////////////////////////////////////////////////////
// for RF channel test, send info via RF
void RF_PrintInfoGD61(void)
{
uint32 ix;
char dbuffer[100];

	ix=LPC_FCCLK;
	sprintf(dbuffer,"System Running...(32bits ARM Processor,Mainclock=%d MHz)",ix/1000000);
	RF_SendString(dbuffer);

	sprintf(dbuffer,"[1] Current time: %4d.%2d.%2d.%2d.%2d.%2d",CurrentTime.xYEAR,CurrentTime.xMONTH,
			    CurrentTime.xDOM,CurrentTime.xHOUR,CurrentTime.xMIN,CurrentTime.xSEC);
	RF_SendString(dbuffer);

    sprintf(dbuffer,"[2] Power Line ID = %d,  Module address = %d", PowerLine_ID,ModuleAddress);	
    RF_SendString(dbuffer);

	sprintf(dbuffer,"[3] System Reset source:");
	RF_SendString(dbuffer);

	if((RSIR & POWR_RESET) == POWR_RESET){
		sprintf(dbuffer,"    [!!] POWER_UP"); 
		RF_SendString(dbuffer);
		RSIR = (RSIR|POWR_RESET);
	}
	
	if((RSIR & EXTR_RESET) == EXTR_RESET){
		sprintf(dbuffer,"    [!!] RESET_PIN"); 
		RF_SendString(dbuffer);
		RSIR = (RSIR|EXTR_RESET);
	}
	
	if((RSIR & WDTR_RESET) == WDTR_RESET){
		sprintf(dbuffer,"    [!!] WATCH_DOG"); 
		RF_SendString(dbuffer);
		RSIR = (RSIR|WDTR_RESET);
	}
	
	if((RSIR & BODR_RESET) == BODR_RESET){
		sprintf(dbuffer,"    [!!] BOD"); 
		RF_SendString(dbuffer);
		RSIR = (RSIR|BODR_RESET);
	}
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
// sending it to UART0 channel
void RF_PrintInfoGD61L(void)
{

#ifdef INCLUDE_LAMP_CON			//>>>(1) light control function

uint16 i,index;
char dbuffer[100];

//// 
	index = 1;		
	RF_SendEnter();
	sprintf(dbuffer,"System Information:"); 
	RF_SendString(dbuffer);
    sprintf(dbuffer,"(%d) Up Routing Address:",index++);	
    RF_SendString(dbuffer);
    for(i=0;i<3;i++){
		sprintf(dbuffer," Branch_%d: %6d, %6d, %6d, %6d, %6d, Num.=%d",(i+1),UpRouteTable[i].Dest_ADDR[0],
				UpRouteTable[i].Dest_ADDR[1],UpRouteTable[i].Dest_ADDR[2],   
				UpRouteTable[i].Dest_ADDR[3],UpRouteTable[i].Dest_ADDR[4],
				UpRouteTable[i].vaildAddrItemNum);
		RF_SendString(dbuffer);
	}
	RF_SendEnter();
////
    sprintf(dbuffer,"(%d) Down Routing Address:",index++);	
    RF_SendString(dbuffer);
    for(i=0;i<3;i++){
   		sprintf(dbuffer," Branch_%d: %6d, %6d, %6d, %6d, %6d, Num.=%d",(i+1),DnRouteTable[i].Dest_ADDR[0],
				DnRouteTable[i].Dest_ADDR[1],DnRouteTable[i].Dest_ADDR[2],   
				DnRouteTable[i].Dest_ADDR[3],DnRouteTable[i].Dest_ADDR[4],
				DnRouteTable[i].vaildAddrItemNum);
		RF_SendString(dbuffer);
	}
	RF_SendEnter();	
////
    sprintf(dbuffer,"(%d) Time table for default control:",index++);	
    RF_SendString(dbuffer);
    sprintf(dbuffer,"    task  hour    minute  action_code      validity");	
    RF_SendString(dbuffer);
    
    for(i=0;i<MAX_CONTROL_TABLE_NUM;i++){
    	////
		if(ActionTime[i].Action_Value == Light_toON){
			if(ActionTime[i].ActionFlag==0x5a){		
		 		sprintf(dbuffer,"      %d.  %3d,     %3d,     TurnOn,         %s",
		 			   (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,"Enable");
			}else{
		 		sprintf(dbuffer,"      %d.  %3d,     %3d,     TurnOn,         %s",
		 			   (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,"Disable");
			}
		}
		////
		else if(ActionTime[i].Action_Value == Light_toOFF){ 								
			if(ActionTime[i].ActionFlag==0x5a){
		 		sprintf(dbuffer,"      %d.  %3d,     %3d,     TurnOff,        %s",
		 		       (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,"Enable");
		 	}else{
		 		sprintf(dbuffer,"      %d.  %3d,     %3d,     TurnOff,        %s",
		 		       (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,"Dsiable");
		 	}
		}
		////
		else{ 								 
			if(ActionTime[i].ActionFlag==0x5a){
			 	sprintf(dbuffer,"      %d.  %3d,     %3d,     %4d,           %s",
			 	       (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,ActionTime[i].Action_Value,"Enable");
			}else{
			 	sprintf(dbuffer,"      %d.  %3d,     %3d,     %4d,           %s",
			 	       (i+1),ActionTime[i].xHOUR,ActionTime[i].xMIN,ActionTime[i].Action_Value,"Disable");
			}
		}
		RF_SendString(dbuffer);
	}    

////
	RF_SendEnter();
    sprintf(dbuffer,"(%d) U_KKK = %d, I_KKK = %d, InputLimitII = %d(mA)",
                    index,ADC_UUK_Value, ADC_IIK_Value, MaxInputLimitII); 
    RF_SendString(dbuffer);

	RF_SendEnter();
	sprintf(dbuffer,"[1] Code be Compiled: %s %s",__DATE__,__TIME__);	
	RF_SendString(dbuffer);

	ReadDateTime();
    sprintf(dbuffer,"[2] Current time: %4d.%2d.%2d.%2d.%2d.%2d",CurrentTime.xYEAR,CurrentTime.xMONTH,
			    CurrentTime.xDOM,CurrentTime.xHOUR,CurrentTime.xMIN,CurrentTime.xSEC);	
	RF_SendString(dbuffer);
////	
    sprintf(dbuffer,"[3] Power Line ID = %d, Module address = %d", PowerLine_ID,ModuleAddress);	
    RF_SendString(dbuffer);
	i=3;

	i++;
	sprintf(dbuffer,"[%d] Transfer coefficient = %d, Control interval time = %d.",i,TransferKKK,ControlTime);	
	RF_SendString(dbuffer);

#ifdef EN_CLOSE_LOOP_CONTROL
	i++;
	sprintf(dbuffer,"[%d] Control mode : CLOSE LOOP.",i);	
	RF_SendString(dbuffer);
#else
	sprintf(dbuffer,"[%d] Control mode : OPEN LOOP.",i);	
	RF_SendString(dbuffer);
#endif	

////
	if(ADC_UUK_Value==ADC_UUK_DEFAULT){
	  RF_SendString("[!] Warning: Voltage measuring hasn't been calibrated.");
	}	

	if(ADC_IIK_Value==ADC_IIK_DEFAULT){
	  RF_SendString("[!] Warning: Current measuring hasn't been calibrated.");
	}

#endif
}

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
void TestRF_Module(void)
{
static uint16 RF_MODULE_SN=0;	
char databuf[TX_BUFFER_LEN];

//	Uart0SendString("Sending RF module test string.");

	RF_MODULE_SN++;
	RF_SendString("CC1000 RF TEST PROGRAM, copy right reserved by GDEPRI.");

	sprintf(databuf,"Current time: %4d.%2d.%2d.%2d.%2d.%2d",CurrentTime.xYEAR,CurrentTime.xMONTH,
			         CurrentTime.xDOM,CurrentTime.xHOUR,CurrentTime.xMIN,CurrentTime.xSEC);	
	RF_SendString(databuf);

	sprintf(databuf,"S/N: %d, Module_ADDR = %d, Pkg_SerialNum = %x, RF test OK!",
	            RF_MODULE_SN, ModuleAddress,    Pkg_SerialNum);
	RF_SendString(databuf);	RF_SendEnter();
}

///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
void Rep_UnexpectedInt(void)
{
char databuf[TX_BUFFER_LEN];
volatile uint32* addr_pt;

////
	if(PrtResetInfoFlag==ENABLE_FLAG){
		sprintf(databuf,"IRQ/FIQ or WatchDog_Reset occur:");	
		#ifdef EN_RF_COMMAND_CHANNEL
			RF_SendString(databuf);		RF_SendEnter();
		#else
			Uart0SendString(databuf);	Uart0SendEnter();
		#endif

////
		addr_pt = &PrintInf_Top;
		do{
			sprintf(databuf,"__ADDR :: %8x = [%8x]",(uint32)addr_pt,*addr_pt);	
			addr_pt++;
		#ifdef EN_RF_COMMAND_CHANNEL
			RF_SendString(databuf);	DelayMS_(80);
		#else
			Uart0SendString(databuf);
		#endif
		}while((uint32)addr_pt <= (uint32)(&PrintInf_Bot));
	}
		#ifdef EN_RF_COMMAND_CHANNEL
			RF_SendEnter();
		#else
			Uart0SendEnter();
		#endif

		PrtResetInfoFlag=DISABLE_FLAG;
}

//////////////////////////////////////////////////////////////////////////////////
// end of file