task_command.c

CC1000 Rf modem C codes for philips sLpc213X ARM MCU.

				MakeRelayPackage(REVS_ROUTE_DIR);	//relay the data package to host.
				Uart0SendString("Response to host");
#else	//ENABLE_RESPONSE_HOST
				RF_SendingOver();
				MakeRFstopRoutePkg();
				RF_SendAddCrc(RFSendByteCounter);		//sending data in buffer
				Uart0SendString("sending RFstopRoutingPkg");
#endif	//ENABLE_RESPONSE_HOST
			}
#endif	//PACKAGE_RELAY_PRIORITY
			result=VOLTAGE_CONTROL;
			break;

////////////////////////////////////////////////////////////////////////////////////
///////////////////////// inquire function implementation //////////////////////////
//////////////////////////////// do not support Broadcast address //////////////////
//////////////////////////////
		case INQUIRE_CALENDAR:		//inquire down_direction route table.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufCalendar();		//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("INQUIRE_CALENDAR and return Package");
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=INQUIRE_CALENDAR;
			break;

////////////////////////////////////
		case INQUIRE_ROUTE_TABLE_DN:	//inquire down_direction route table.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufDnRouteTable();	//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("INQUIRE_ROUTE_TABLE_DN and return Package");
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=INQUIRE_ROUTE_TABLE_DN;
			break;

////////////////////////////////////
		case INQUIRE_ROUTE_TABLE_UP:	//inquire up_direction route table.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufUpRouteTable();	//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("INQUIRE_ROUTE_TABLE_UP and return Package");
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=INQUIRE_ROUTE_TABLE_UP;
			break;

///////////////////////////////////
		case INQUIRE_TIMER_CONTROL:		// inquire the default control table.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufControlTable();	//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("INQUIRE_DEFAULT_CONTROL and return Package");
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=INQUIRE_TIMER_CONTROL;
			break;

///////////////////////////					
		case INQUIRE_STATE:				// inquire the working and alarm state.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufCurrentState();	//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("INQUIRE_STATE and return Package");
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=INQUIRE_STATE;
			break;

/////////////////////////////////////
		case ASK_I_U_WP_PF_UO_WO:	// inquire the working and alarm state.

			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
				RF_SendingOver();
				TbufI_U_WP_QP_SP_PF();	//fill routeData[]//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);		// if module_address!=destination address,
				Uart0SendString("INQUIRE I_U_WP_QP_SP_PF and return Package");
			}							// relay the massage(data package).

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=ASK_I_U_WP_PF_UO_WO;
			break;
			
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// RF channel implementation ///////////////////////
/////////////////////////////// support Broadcast address ///////////////////////
////////////////////////
		case HEART_BEEP:			// announce the host in line

			HeartBeat();			// print: Time I U WP QP SP PF Rld Uref Iref
			Uart0SendString("HEART_BEEP and print UIP info");	
			DelayMS_(1);

			if(DestinationAddr==RF_BROAD_CAST_ADDR){
				MakeRelayPackage(KEEP_ROUTE_DIR);	// relay the massage(data package).
				Uart0SendString("RelayPackage to others");
			}

			else if(DestinationAddr==ModuleAddress){
#ifdef ENABLE_RESPONSE_HOST
				MakeRelayPackage(REVS_ROUTE_DIR);	//relay the massage(data package) to host.
				Uart0SendString("Response to host");
#else
				RF_SendingOver();
				MakeRFstopRoutePkg();
				RF_SendAddCrc(RFSendByteCounter);		//sending data in buffer
				Uart0SendString("sending RFstopRoutingPkg");						
#endif
			}

			result=HEART_BEEP;
			break;

////////////////////////////////// master check if node in Line ////////
//////////////////////////////// do not support Broadcast address //////
/////////////////////////
		case TAP_NODE_PK:			//chat with module
				
			DelayMS_(1);
			if(DestinationAddr==ModuleAddress){
#ifdef ENABLE_RESPONSE_HOST
				MakeRelayPackage(REVS_ROUTE_DIR);			//relay the massage(data package) to host.
				Uart0SendString("Response to host");
#else			
				RF_SendingOver();
				TbufResponsePackage();			//source & destination address//set routing direction
				MakeRelayPackage(KEEP_ROUTE_DIR);
				Uart0SendString("TAP_NODE_PK and return Package");
#endif
			}

			else if(DestinationAddr==RF_BROAD_CAST_ADDR){
				Uart0SendString("don't support broad cast address.");
			}

			result=TAP_NODE_PK;
			break;

/////////////////////////////////////////////////////////////////////////
//  calibration I and U
/////////////////////////////////////////////////////////////////////////
/////////////////////
		case CALIBRATE_U:

//  no password return.
			if(PassWord != CALIBRATE_PASS_WORD){
				Uart0SendString("Invalid Pass word, Voltage calibration failed!");
				result=CALIBRATE_U;
				break;
			}

// stop RF package routing
			DelayMS_(2);
			MakeRFstopRoutePkg();
			RF_SendAddCrc(RFSendByteCounter);	RF_SendingOver();	//sending data in buffer
			Uart0SendString("sending RFstopRoutingPkg");

//  password ok
			SysRunState = CALIBRATION_STATE;	AD_ChannelSwitch();
			Uart0SendString("System enter calibration state.");
			ClearFilter();
			Uart0SendString("Clear all data in filter buffer");		

			for(i=0;i<(AD_SPEED_HIGH*(AD_FILTER_SIZE+2));i++){
				WatchDogClear();					//clr watchdog
				Calculate_IUP();					//AD_SAMPLE_NUM*AD_SPEED_HIGH*AD_FILTER_SIZE
				AD_ChannelSwitch();
				DelayMS_(AD_SAMPLE_NUM+2);			
			}
			SaveADC_UK();							//calibrate U and Save UK coefficient
			
//  deliver from UK and IK
			ADC_WPK_Value = (ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_WPK_Value==0) ADC_WPK_Value=1000;		
			ADC_QPK_Value = ADC_WPK_Value; 	//(ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_QPK_Value==0) ADC_QPK_Value=1000;
			ADC_SPK_Value = ADC_WPK_Value; 	//(ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_SPK_Value==0) ADC_SPK_Value=1000;
	
			Uart0SendString("CALIBRATE_U and Save ADC_UK");
			DelayMS_(1);

			SysRunState = NORMAL_STATE;
			Uart0SendString("Enter normal state.");
//			Uart0SendString("A/D swing on in/out channel and ADC at normal speed.");
//			RF_SendString("CALIBRATE_U, Save ADC_UK and Next start...");RF_SendEnter();
			
//	treat package relay
			if(DestinationAddr==RF_BROAD_CAST_ADDR){
				MakeRelayPackage(KEEP_ROUTE_DIR);		// relay the massage(data package) to other
				Uart0SendString("Relay the Package");

				WatchDogClear();		// relay the first package to other in priority
				RF_RelayPkgSending();	// for RF channel
				RF_SendingOver();
			}

			else if(DestinationAddr==ModuleAddress){
#ifdef ENABLE_RESPONSE_HOST
				MakeRelayPackage(REVS_ROUTE_DIR);	//relay the massage(data package) to host.
				Uart0SendString("Response to host");
/*
#else	//ENABLE_RESPONSE_HOST
				RF_SendingOver();
				MakeRFstopRoutePkg();
				RF_SendAddCrc(RFSendByteCounter);		//sending data in buffer
				Uart0SendString("sending RFstopRoutingPkg");
*/
#endif	//ENABLE_RESPONSE_HOST
			}
						
			result=CALIBRATE_U;
			break;
			
/////////////////////
		case CALIBRATE_I:

//  no password return.
			if(PassWord != CALIBRATE_PASS_WORD){
				Uart0SendString("Invalid Pass word, CURRENT calibrate failed!");
				result=CALIBRATE_I;
				break;
			}

// stop RF package routing
			DelayMS_(2);
			MakeRFstopRoutePkg();
			RF_SendAddCrc(RFSendByteCounter);	RF_SendingOver();	//sending data in buffer				
			Uart0SendString("sending RFstopRoutingPkg");
				
//  password ok				
			SysRunState = CALIBRATION_STATE;	AD_ChannelSwitch();
			Uart0SendString("Enter calibration state.");
			ClearFilter();
			Uart0SendString("Clear all data in filter buffer");		

			for(i=0;i<(AD_SPEED_HIGH*(AD_FILTER_SIZE+2));i++){
				WatchDogClear();			//clr watchdog
				Calculate_IUP();			//AD_SAMPLE_NUM*AD_SPEED_HIGH*AD_FILTER_SIZE
				AD_ChannelSwitch();
				DelayMS_(AD_SAMPLE_NUM+2);	
			}
			SaveADC_IK();					//calibrate I and Save IK coefficient
			
//  deliver from UK and IK
			ADC_WPK_Value = (ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_WPK_Value==0) ADC_WPK_Value=1000;		
			ADC_QPK_Value = ADC_WPK_Value;  //(ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_QPK_Value==0) ADC_QPK_Value=1000;
			ADC_SPK_Value = ADC_WPK_Value;  //(ADC_UUK_Value*ADC_IIK_Value)/1000;	//if(ADC_SPK_Value==0) ADC_SPK_Value=1000;
	
			Uart0SendString("CALIBRATE_I and Save ADC_IK");
			DelayMS_(1);

			SysRunState = NORMAL_STATE;
			Uart0SendString("Enter normal state.");
//			Uart0SendString("A/D swing on in/out channel and ADC at normal speed.");
//			RF_SendString("CALIBRATE_I, Save ADC_IK and Next start...");RF_SendEnter();

//	treat package relay
			if(DestinationAddr==RF_BROAD_CAST_ADDR){
				MakeRelayPackage(KEEP_ROUTE_DIR);		// relay the massage(data package) to other
				Uart0SendString("Relay the Package");

				WatchDogClear();		// relay the first package to other in priority
				RF_RelayPkgSending();	// for RF channel
				RF_SendingOver();
			}

			else if(DestinationAddr==ModuleAddress){
#ifdef ENABLE_RESPONSE_HOST
				MakeRelayPackage(REVS_ROUTE_DIR);	//relay the massage(data package) to host.
				Uart0SendString("Response to host");
/*
#else	//ENABLE_RESPONSE_HOST
				RF_SendingOver();
				MakeRFstopRoutePkg();
				RF_SendAddCrc(RFSendByteCounter);		//sending data in buffer
				Uart0SendString("sending RFstopRoutingPkg");
*/
#endif	//ENABLE_RESPONSE_HOST
			}

			result=CALIBRATE_I;
			break;

////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
		case HARD_WARE_TEST:				//only for debug or calibration

			#ifdef EN_RF_COMMAND_CHANNEL
			PrtDebugInfo=ENABLE_FLAG;
			#endif

			Uart0SendString("Perform HardWare Test.");
			switch(ActionValue){
			
				case 0x00:
//					PrtResetInfoFlag = ENABLE_FLAG;	//for watchdog reset information prt.
					Uart0SendString("WatchDog resets System.");
					Uart0SendingOver();
					WatchDog_Start(10);	//10 ms Watchdog reset time
					while(1);			//wait for watchdog reset
					break;
					
				case 0x01:
					SysRunState = TEST_STATE;
					Uart0SendString("Enter test state.");
//					Uart0SendString("A/D swing on in/out channel and ADC at high speed. ");
					break;
					
				case 0x02:
					SysRunState = PRINT_STATE;
					Uart0SendString("Enter print state.");
//					Uart0SendString("A/D swing on in/out channel and ADC at normal speed.");
					break;
					
				case 0x03:
					SysRunState = NORMAL_STATE;
					Uart0SendString("Enter normal state.");
//					Uart0SendString("A/D swing on in/out channel and ADC at normal speed.");
					break;
					
				case 0x04:
					TestRF_Module();
					break;
					
				case 0x05:
					TestEEprom();
					break;
									
				case 0x06:
					OutputPinTest();	// main board test
					break;

				case 0x07:
					Uart0SendString("Testing lamp and light");
					TestDrvState = 0;
					break;
								
				case 0x08:
					TestPowerSwitch();
					break;
					
				case 0x09:
//					Uart0SendString("Print SysInformation to RF channel");
					RF_PrintInfoGD61L();
					break;

				case 0x0a:
//					Uart0SendString("Print CurInformation to RF channel");
					RF_PrintCurState();
					break;
					
				case 0x0b:
					DL1_RelayTest();	// DL1_Relay Test
					break;	
						
				case 0x0c:
					DK_RelayTest();		// DK_Relay Test
					break;

				case 0x0d:
					U_ChannelTest();	//voltage channel selecting test				
					break;

				default:
					Uart0SendString("default CASE_1");
					break;
			}
			
			ExecutedPkgID--;		//for next test
			result=HARD_WARE_TEST;
			break;
			
///////////////////////
		default:
			Uart0SendString("default CASE_2");
			result=NOTHING_TO_DO;
			break;
	}
		return result;			//something done, return 1; otherwise return 0.
}

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