#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 CcsData				*ShmCcsData;
struct InternalComm			*ShmInternalComm;

#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 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 ShmInternalComm
   	 if ((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   IPC_CREAT|0777)) < 0) 
    	{
		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmget ShmInternalComm NG");
		#endif			
		return 0;
	}
    	else if ((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *) -1) 
    	{
    		#ifdef SystemLogMessage	
		StoreLogMsg("[main]CreatShareMemory:shmat ShmInternalComm NG");
		#endif		
		return 0;
   	 }
    	return 1;
}

/**************************************************************************************/
/****************Following functions are CSU initialization***************************/
/**************************************************************************************/
void InitGPIO()
{
	/*****************0~3, 4 bank, bank x 32+ num*********************/
	/***************************************************************/
	/*************** INPUT PIN ***************************************/
	/***************************************************************/
	/*GPIO2_0: QCA7000 interrupt */
	system("echo 64 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio64/direction");
	
	
	/***************************************************************/
	/*************** OUTPUT PIN ************************************/
	/***************************************************************/
	/*GPIO2_25: AM_IO_2, H: ?; L: ?*/
	system("echo 89 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio89/direction");
	system("echo 0 > /sys/class/gpio/gpio89/value");
	/*GPIO2_23: AM_IO_1, H: ?; L: ?*/
	system("echo 87 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio87/direction");
	system("echo 0 > /sys/class/gpio/gpio87/value");
	/*GPIO2_24: AM_QCA_PWR_RST, H: reset, L: noraml*/
	system("echo 88 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio88/direction");
	system("echo 0 > /sys/class/gpio/gpio88/value");
	/*GPIO2_22: Pilot_state E, H: state E, L: normal*/
	system("echo 86 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio86/direction");
	system("echo 0 > /sys/class/gpio/gpio86/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");
}

int Initialization()
{
	unsigned char str[256];
	
	//init GPIO
	InitGPIO();

	//init ecap0
	memset(str,0,sizeof(str));
	system("echo 0 > /sys/class/pwm/pwmchip0/export");
	system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/period");// nano seconds =>1k Hz
	system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //default 100%
	system("echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable");
	//system("echo 1 > /sys /class/pwm/pwmchip0/pwm0/polarity");

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

int SpawnTask()
{
	system("/root/EventLogging &");
	system("/root/CsuComm &");
	system("/root/EvComm &");
}


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)
	{
		sleep(5);
	}//main while
}