#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/termios.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/sockios.h> 
#include <linux/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h> 
#include <sys/timeb.h> 
#include <math.h>//for pow
#include <unistd.h>
#include "../../define.h"


//#define Debug

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct PsuData 				*ShmPsuData ;
struct CHAdeMOData			*ShmCHAdeMOData;
struct CcsData				*ShmCcsData;
struct PrimaryMcuData			*ShmPrimaryMcuData;
struct FanModuleData			*ShmFanModuleData;
struct RelayModuleData			*ShmRelayModuleData;
struct OCPP16Data				*ShmOCPP16Data;

#ifdef SystemLogMessage
int StoreLogMsg(unsigned char *DataString)
{
	unsigned char Buf[256];
	time_t CurrentTime;
	struct tm *tm;
			
	memset(Buf,0,sizeof(Buf));
	CurrentTime = time(NULL);
	tm=localtime(&CurrentTime);
	sprintf(Buf,"echo \"%04d.%02d.%02d %02d:%02d:%02d - %s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
			tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,
			DataString,
			tm->tm_year+1900,tm->tm_mon+1);
	system(Buf);
	#ifdef Debug
	printf("%s \n",DataString);
	#endif
}		
#endif

int DiffTimeb(struct timeb ST, struct timeb ET)
{
	//return milli-second
	unsigned int StartTime,StopTime;
	
	StartTime=(unsigned int)ST.time;
	StopTime=(unsigned int)ET.time;
	return (StopTime-StartTime)*1000+ET.millitm-ST.millitm;
}	

/**************************************************************************************/
/**************************Create all share memory *********************************/
/**************************************************************************************/
int CreatShareMemory()
{
	int MeterSMId;
	
	//creat ShmSysConfigAndInfo
	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmSysConfigAndInfo NG");
		#endif			
		return 0;
	}
    	else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmSysConfigAndInfo NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmSysConfigAndInfo,0,sizeof(struct SysConfigAndInfo));
   	 //creat ShmStatusCodeData
   	 if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmStatusCodeData NG");
		#endif		
		return 0;	
	}
    	else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmStatusCodeData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmStatusCodeData,0,sizeof(struct StatusCodeData));
   	 //creat ShmPsuData
   	 if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmPsuData NG");
		#endif			
		return 0;
	}
    	else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmPsuData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmPsuData,0,sizeof(struct PsuData));
   	 //creat ShmCHAdeMOData
   	 if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmCHAdeMOData NG");
		#endif			
		return 0;
	}
    	else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmCHAdeMOData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmCHAdeMOData,0,sizeof(struct CHAdeMOData));
   	 //creat ShmCcsData
   	 if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmCcsData NG");
		#endif			
		return 0;
	}
    	else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmCcsData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmCcsData,0,sizeof(struct CcsData));
   	//creat ShmPrimaryMcuData
   	 if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmPrimaryMcuData NG");
		#endif			
		return 0;
	}
    	else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmPrimaryMcuData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmPrimaryMcuData,0,sizeof(struct PrimaryMcuData));
   	 //creat ShmFanModuleData
   	 if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmFanModuleData NG");
		#endif			
		return 0;
	}
    	else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmFanModuleData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmFanModuleData,0,sizeof(struct FanModuleData));
   	 //creat ShmRelayModuleData
   	 if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmRelayModuleData NG");
		#endif			
		return 0;
	}
    	else if ((ShmRelayModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmRelayModuleData NG");
		#endif		
		return 0;
   	 }
   	 memset(ShmRelayModuleData,0,sizeof(struct RelayModuleData));
   	  //creat ShmOCPP16Data
   	 if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), IPC_CREAT | 0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmOCPP16Data NG");
		#endif			
		return 0;
	}
    	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmOCPP16Data NG");
		#endif		
		return 0;
   	 }
   	// memset(ShmOCPP16Data,0,sizeof(struct OCPP16Data));
    	return 1;
}

/**************************************************************************************/
/****************Following functions are CSU initialization***************************/
/**************************************************************************************/
void InitGPIO()
{
	/*****************0~3, 4 bank, bank x 32+ num*********************/
	/***************************************************************/
	/*************** INPUT PIN ***************************************/
	/***************************************************************/
	/*SECOND_BREAKER_feedback.:GPIO0_28:input => H:OFF; L: ON*/
	system("echo 28 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio28/direction");
	/*GFD Alarm1:GPIO2_20:input => H: Normal operation; L: GFD alarm*/
	system("echo 84 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio84/direction");
	/*GFD Alarm2:GPIO2_19:input => H: Normal operation; L: GFD alarm*/
	system("echo 83 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio83/direction");
	/*AC Drop:GPIO2_18:input => H: Normal operation; L: AC drop*/
	system("echo 82 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio82/direction");
	/*Emergency Stop:GPIO2_7:input => H: Normal operation; L: Emergency stop*/
	system("echo 71 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio71/direction");
	/*Main breaker SPD:GPIO0_27:input => H: Normal SPD operation; L: Interrupt from SPD*/
	system("echo 27 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio27/direction");
	/*MAIN_BREAKER_feedback:GPIO1_15:input =>H: OFF; L: ON*/
	system("echo 47 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio47/direction");
	/*GUN1 Permission (signal J):GPIO0_29:input => H: No EV permission; L: Permitted */
	system("echo 29 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio29/direction");
	/*GUN1 Proximity detection:GPIO1_28:input => H: Gun unconnected; L: Gun connected*/
	system("echo 60 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio60/direction");
	/*GUN1 LOCK CHECK - CHAdeMO :GPIO2_23:input => H: Gun unlock; L: Gun locked*/
	system("echo 87 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio87/direction");
	/*Input contactor feedback.:GPIO3_20:input:H: ON; L: OFF*/
	system("echo 116 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio116/direction");
	/*DOOR_Sensor: GPIO1_14:input:H: Door close; L: Door open */
	system("echo 46 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio46/direction");
	
	/***************************************************************/
	/*************** OUTPUT PIN ************************************/
	/***************************************************************/
	/*all system module power switch:GPIO0_16:output => H: power off all modules; L: power on all module*/
	system("echo 16 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio16/direction");
	system("echo 0 > /sys/class/gpio/gpio16/value");
	/*Input contactor Drive: GPIO2_9:output =>H: ON; L: OFF*/
	system("echo 73 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio73/direction");
	system("echo 0 > /sys/class/gpio/gpio73/value");
	/*EV1 12V Enable (CHAdeMO1 D1): GPIO0_19:output=>H: Enable 12V for EV (ON); L: Disable 12V for EV (OFF)*/
	system("echo 19 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio19/direction");
	system("echo 0 > /sys/class/gpio/gpio19/value");
	/*EV1 GND Enable (CHAdeMO1 D2): GPIO2_12:output=>H: Enable GND for EV(ON); L: Disable GND for EV(OFF) */
	system("echo 76 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio76/direction");
	system("echo 0 > /sys/class/gpio/gpio76/value");
	/*GUN1_MPU_Permission :GPIO0_11:output => Low: CHAdeMO1 signal J be controled by EV, High:signal J always low (charging permitted)*/
	system("echo 11 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio11/direction");
	system("echo 0 > /sys/class/gpio/gpio11/value");
	/*CHAdeMO GUN1 lock:GPIO2_10:output => H: Lock gun; L: Unlock gun*/
	system("echo 74 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio74/direction");
	system("echo 0 > /sys/class/gpio/gpio74/value");
	/*CHILLER ENABLE:GPIO1_31:output => H: Enable chiller; L: Disable chiller*/
	system("echo 63 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio63/direction");
	system("echo 0 > /sys/class/gpio/gpio63/value");
	/*Buzzer:GPIO3_18:output => H: buzz; L:silent*/
	system("echo 114 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio114/direction");
	system("echo 0 > /sys/class/gpio/gpio114/value");
	/*RS485_DE	GPIO2_13:output=>H: Transmit RS485 data; L: Receive RS485 data*/
	system("echo 77 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio77/direction");
	system("echo 0 > /sys/class/gpio/gpio77/value");
	
	#ifdef SystemLogMessage	
	StoreLogMsg("[main]InitGPIO: Initial GPIO OK");
	#endif	

}

int LoadSysConfigAndInfo(struct SysConfigData *ptr)
{
	int fd,wrd;
	struct SysConfigData *buf;
	unsigned char *PtrBuf;
	unsigned int ChkSum,ChkSumOrg;
	
	if((buf=malloc(sizeof(struct SysConfigData)))==NULL)
	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]LoadSysConfigAndInfo:malloc buffer NG,rebooting..");
		#endif	
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}	
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}	
	memset(buf, 0, sizeof(struct SysConfigData));
	fd = open("/dev/mtdblock10", O_RDWR);
	if (fd < 0) 
	{
		free(buf);
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]LoadSysConfigAndInfo:open mtdblock10 NG,rebooting..");
		#endif	
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}	
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
    	wrd=read(fd, buf,sizeof(struct SysConfigData));
	close(fd);
	if(wrd!=(sizeof(struct SysConfigData)))
	{
		free(buf);
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]LoadSysConfigAndInfo: read SysConfigData data NG,rebooting..");
		#endif	
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}	
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}	
	PtrBuf=(unsigned char *)buf;
	ChkSum=0;
	for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
	{
		ChkSum+=PtrBuf[wrd];
	}
	ChkSumOrg=buf->Checksum;
	
	if(ChkSum!=ChkSumOrg)
	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]LoadSysConfigAndInfo: Primary SysConfigData checksum NG, read backup");
		#endif	
		fd = open("/dev/mtdblock11", O_RDWR);
		if (fd < 0) 
		{
			free(buf);
			#ifdef SystemLogMessage	
			StoreLogMsg("[main]LoadSysConfigAndInfo: open mtdblock11 (backup) NG,rebooting..");
			#endif	
			if(ShmStatusCodeData!=NULL)
			{
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
			}	
			sleep(5);
			system("reboot -f");
			sleep(5);
			system("reboot -f");
	    	}
	    	memset(buf, 0, sizeof(struct SysConfigData));
   		wrd=read(fd, buf,sizeof(struct SysConfigData));
    		close(fd);
		if(wrd!=sizeof(struct SysConfigData))
		{
			free(buf);
			#ifdef SystemLogMessage	
			StoreLogMsg("[main]LoadSysConfigAndInfo: read backup SysConfigData data NG,rebooting..");
			#endif	
			if(ShmStatusCodeData!=NULL)
			{
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
			}	
			sleep(5);
			system("reboot -f");
			sleep(5);
			system("reboot -f");
		}	
		PtrBuf=(unsigned char *)buf;
		ChkSum=0;
		for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
		{
			ChkSum+=PtrBuf[wrd];
		}
		ChkSumOrg=buf->Checksum;
		if(ChkSum!=ChkSumOrg)
		{
			#ifdef SystemLogMessage	
			StoreLogMsg("[main]LoadSysConfigAndInfo: backup SysConfigData checksum NG, read Factory default");
			#endif	
			fd = open("/dev/mtdblock12", O_RDWR);
			if (fd < 0) 
			{
				free(buf);
				#ifdef SystemLogMessage	
				StoreLogMsg("[main]LoadSysConfigAndInfo: open mtdblock12 (Factory default) NG,rebooting..");
				#endif	
				if(ShmStatusCodeData!=NULL)
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
				}	
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");
	    		}
	    		memset(buf, 0, sizeof(struct SysConfigData));
   			wrd=read(fd, buf,sizeof(struct SysConfigData));
    			close(fd);
			if(wrd!=sizeof(struct SysConfigData))
			{
				free(buf);
				#ifdef SystemLogMessage	
				StoreLogMsg("[main]LoadSysConfigAndInfo: read factory default  SysConfigData data NG,rebooting..");
				#endif	
				if(ShmStatusCodeData!=NULL)
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
				}	
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");
			}	
			PtrBuf=(unsigned char *)buf;
			ChkSum=0;
			for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
			{
				ChkSum+=PtrBuf[wrd];
			}
			ChkSumOrg=buf->Checksum;
			if(ChkSum!=ChkSumOrg)
			{
				#ifdef SystemLogMessage	
				StoreLogMsg("[main]LoadSysConfigAndInfo: factory default  SysConfigData checksum NG, restore factory default");
				#endif	
				goto DefaultShm;
			}	
		}	
	}	
	//load OK
	memcpy((struct SysConfigData *)ptr,(struct SysConfigData *)buf,sizeof(struct SysConfigData));	
	free(buf);
	#ifdef SystemLogMessage	
	StoreLogMsg("[main]LoadSysConfigAndInfo: Load SysConfigData OK");
	#endif	
	return 1;
    
DefaultShm:
	system("cd /root;./FactoryConfig");
	system("sync");
	sleep(5);
	system("reboot -f");
	sleep(5);
	system("reboot -f");
}

void InitEthernet()
{
	char tmpbuf[256];
	unsigned int address;
	
	//Init Eth0 for internet 
	memset(tmpbuf,0,256);
	sprintf(tmpbuf,"/sbin/ifconfig eth0 %s netmask %s up",
	ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
	ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress);
	system(tmpbuf);
	memset(tmpbuf,0,256);
	sprintf(tmpbuf,"route add default gw %s eth0 ",
	ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);
    	system(tmpbuf);		
    	
    	//Init Eth1 for administrator tool 
	memset(tmpbuf,0,256);
	sprintf(tmpbuf,"/sbin/ifconfig eth1 %s netmask %s up",
	ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthIpAddress,
	ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthSubmaskAddress);
	system(tmpbuf);
    	
    	//Run DHCP client if enabled
	system("killall udhcpc");
	system("rm -rf /etc/resolv.conf");	
	system("echo nameserver 8.8.8.8 > /etc/resolv.conf");		//Google DNS server
	system("echo nameserver 180.76.76.76 > /etc/resolv.conf");	//Baidu DNS server 
	if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient==0)
		system("/sbin/udhcpc -i eth0 -s /root/simple.script > /dev/null &");	
		
	#ifdef SystemLogMessage	
	StoreLogMsg("[main]InitEthernet: Initial Ethernet OK");
	#endif		
}	

int Initialization()
{
	InitGPIO();
	LoadSysConfigAndInfo(&ShmSysConfigAndInfo->SysConfig);
	InitEthernet();
	
	#ifdef SystemLogMessage	
	StoreLogMsg("[main]Initialization: Initialization OK");
	#endif		
}

int SpawnTask()
{
	system("/root/EventLogging &");
	system("/root/LcmControl &");
	system("/root/InternalComm &");
	system("/root/PrimaryComm &");
	system("/root/EvComm &");
	system("/root/OcppBackend &");
	/*
	if 4G model 
		system("/root/4gModem &");
	else if WiFi model 
		system("/root/WiFiModem &");
	*/
	
}


int StoreUsrConfigData(struct SysConfigData *UsrData)
{
	int fd,wrd;
	unsigned int i,Chk;
	unsigned char *ptr; 
	
	Chk=0;
	ptr=(unsigned char *)UsrData;
	for(i=0;i<sizeof(struct SysConfigData)-4;i++)
	{
		Chk+=*(ptr+i);
	}
	UsrData->Checksum=Chk;
	
	fd = open("/dev/mtdblock10", O_RDWR);
	if (fd < 0) 
	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]StoreUsrConfigData: open /dev/mtdblock10 NG");
		#endif		
		return 0;
	}
   	wrd=write(fd, UsrData, sizeof(struct SysConfigData));   
    	close(fd);
    	if(wrd!=(sizeof(struct SysConfigData)))
	{	
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]StoreUsrConfigData: write /dev/mtdblock10 NG");
		#endif	
		return 0;
	}	
	
	fd = open("/dev/mtdblock11", O_RDWR);
	if (fd < 0) 
	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]StoreUsrConfigData: open /dev/mtdblock11(backup) NG");
		#endif	
		return 0;
    	}
    	wrd=write(fd, UsrData, sizeof(struct SysConfigData));   
    	close(fd);
   	if(wrd!=(sizeof(struct SysConfigData)))
	{	
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]StoreUsrConfigData: write /dev/mtdblock11(backup) NG");
		#endif	
		return 0;
	}	
	return 1;
}

/**************************************************************/
/************** main function********************************/
/*************************************************************/	

int main(int argc,char *argv[])
{
	int Rtn=0;
	unsigned int StartTime;	
	struct timeb StartChargingTime,CurrentChargingTime,ChargingLoopTime;
	float ChargingPower,ChargingEnergy;
	
	//Create all share memory
	if(CreatShareMemory()==0)
	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]main:CreatShareMemory NG");
		#endif		
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
		}	
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}	
	
	//CSU Initialization 
	Initialization();
	
	//task spawn
	//SpawnTask();

	/**************************************************************/
	/************** main Loop********************************/
	/*****************************************************************/
	
	while(1)
	{
		
	}//main while
}