2020-02-15 /Kathy Yeh

1. add Smart Charging struct
2. add Smart Charging flag
3. add Smart Charging function

EVSE/Modularization/ocppfiles/MessageHandler.c

@@ -44,6 +44,8 @@
 
 
 
+
+
 #define PASS				1
 #define FAIL				-1
 
@@ -1254,9 +1256,8 @@ void CheckSystemValue(void)
 
 	//DEBUG_INFO("\n gunTotalNumber=%d\n",gunTotalNumber);
 
-	for(int gun_index=0;gun_index < gunTotalNumber /*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY )*/ ;gun_index++)
+	for(int gun_index=0;gun_index < gunTotalNumber ;gun_index++)
 	{
-
 		//===============================
 		// CSU Trigger Reset Conf
 		//===============================
@@ -1294,6 +1295,16 @@ void CheckSystemValue(void)
 			server_sign = FALSE;
 		}
 
+		//===============================
+		// CSU Trigger Smart Charging Profilw
+	   //===============================
+	   if((server_sign == TRUE) && (ShmOCPP16Data->CSUMsg.bits[gun_index].ChargingProfileReq == 1))
+	   {
+		   ShmOCPP16Data->CSUMsg.bits[gun_index].ChargingProfileReq = 0;
+		   GetChargingProfileRequest(gun_index);
+		   ShmOCPP16Data->CSUMsg.bits[gun_index].ChargingProfileConf = 1;
+	   }
+
 		//==============================================
 		// Charger start transaction
 		//==============================================
@@ -12941,6 +12952,1427 @@ int InternetDisconnect(void)
 	return (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi && ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet && ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi	);
 }
 
+void GetChargingProfileRequest(int gunindex)
+{
+	mtrace();
+
+	//int connectorIdInt, durationInt;
+	//char chargingRateUnitStr[4]={0};
+	int tempdurationInt = 0;
+	int tempchargingProfileId = 0;
+	int tempstackLevel = 0;
+	int temptransactionId = 0;
+	float tempminChargingRateFloat = 0.0;
+	char tempchargingProfilePurposeStr[24]={0};
+	char tempchargingProfileKindStr[12]={0};
+	char temprecurrencyKindStr[8]={0};
+	char tempvalidFromStr[28]={0},tempchargingRateUnitStr[4]={0}, tempstartScheduleStr[30]={0};
+	char tempvalidToStr[28]={0};
+	int tempStartPeriodInt = 0;
+	float tempLimitInt = 0.0;//0.1;
+	int tempNumberPhasesInt=0;
+	char fname[200];
+	//char comfirmstr[20];
+	float MinChargingRate =0.0;
+    double diff_t;
+    struct tm tp;
+	FILE *fptr1;//, *fptr2;
+	int c = 0;
+	char * pch;
+	char *loc;
+	char sstr[200]={ 0 };
+	int n_chargingProfile = 0;
+	int n_SchedulePeriods = 0;
+    char SchedulePeriodList[10][200]={0};
+	char sLineWord[800]={0};
+	char word[1000]={0};
+	int confirmPeriods = 0;
+    struct StructProfile ChargePointMaxProfile;
+	struct StructProfile TxDefaultProfile;
+	struct StructProfile TxProfile;
+	struct StructProfile TxDefaultProfiletemp[2]={0};
+
+	struct StructChargingProfile ChargePointMaxProfile_TEMP={0};
+	struct StructChargingProfile TxDefaultProfile_TEMP={0};
+	struct StructChargingProfile TxProfile_TEMP={0};
+	int TxDefaultProfileFileIsNull=FALSE;
+	int ChargePointMaxProfileIsNull=FALSE;
+	int	TxProfileIsNull=FALSE;
+//	int CompositeSceduleIndex = 0;
+	char ChargePointMaxProfileScheduleStr[30]={0};
+	char TxDefaultProfileScheduleStr[30]={0};
+	char TxProfileScheduleStr[30]={0};
+
+	memset(&ChargePointMaxProfile,0,sizeof(struct StructProfile));
+	memset(&TxDefaultProfile,0,sizeof(struct StructProfile));
+	memset(&TxProfile,0,sizeof(struct StructProfile));
+
+	DEBUG_INFO("GetChargingProfileRequest\n");
+
+	//*****************************ChargePointMaxProfile******************************************/
+	strcpy(fname, ChargePointMaxProfile_JSON);
+	ChargePointMaxProfileIsNull=TRUE;
+	if((access(ChargePointMaxProfile_JSON,F_OK))!=-1)
+	{
+	  		fptr1 = fopen(fname, "r");
+
+	  		int c;
+	  		c = fgetc(fptr1);
+	  		//DEBUG_INFO("c:%d\n",c);
+	  		rewind(fptr1);
+
+	  		if(c == EOF)
+	  		{
+	  			DEBUG_INFO("\n End of file reached.");
+	  			ChargePointMaxProfileIsNull=TRUE;
+	  			fclose(fptr1);
+
+	  		}
+	  		else
+	  		{
+	  			ChargePointMaxProfileIsNull=FALSE;
+	  			while(fscanf(fptr1, "%s", word) != EOF)
+	  			{
+	  				if(strcmp(word, "chargingProfileId") == 0)
+	  				{
+	  					n_chargingProfile = n_chargingProfile + 1;
+	  				}
+	  			}
+	  			rewind(fptr1);
+
+	  			//search Charging Profile Element
+	  			int i = 0;
+	  			int j = 0;
+	  			while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {
+
+
+	  			//***********chargingProfileId**************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "chargingProfileId");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				while (loc[2+strlen("chargingProfileId")+c] != '\"')
+	  				{
+	  				  	sstr[c] = loc[2+strlen("chargingProfileId")+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				DEBUG_INFO("chargingProfileId=%s\n",sstr);
+	  				tempchargingProfileId = atoi(sstr);
+	  			}
+	  			else
+	  			{
+	  				tempchargingProfileId = 0;
+	  			}
+
+
+	  			//***********stackLevel**************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "stackLevel");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				while (loc[2+strlen("stackLevel")+c] != '\"')
+	  				{
+	  				  	sstr[c] = loc[2+strlen("stackLevel")+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				DEBUG_INFO("stackLevel=%s\n",sstr);
+	  				             tempstackLevel = atoi(sstr);
+
+	  			}
+	  			else
+	  			{
+	  				tempstackLevel = 0;
+	  			}
+
+	  			//***********chargingProfilePurpose **************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "chargingProfilePurpose");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				  while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
+	  				  {
+	  					  sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
+	  					  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  c++;
+	  				  }
+	  				  sstr[c] = '\0';
+	  				  DEBUG_INFO("chargingProfilePurpose =%s\n",sstr);
+	  				  strcpy(tempchargingProfilePurposeStr,sstr);
+	  			}
+	  			else
+	  			{
+	  				  strcpy(tempchargingProfilePurposeStr,"");
+	  			}
+
+
+	  			//***********chargingProfileKind  **************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "chargingProfileKind");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				while (loc[3+strlen("chargingProfileKind")+c] != '\"')
+	  				{
+	  				  	sstr[c] = loc[3+strlen("chargingProfileKind")+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				DEBUG_INFO("chargingProfileKind =%s\n",sstr);
+	  				strcpy(tempchargingProfileKindStr,sstr);
+	  			}
+	  			else
+	  			{
+	  				 strcpy(tempchargingProfileKindStr,"");
+	  			}
+
+
+	  			//***********recurrencyKind  **************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "recurrencyKind");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				while (loc[3+strlen("recurrencyKind")+c] != '\"')
+	  				{
+	  				  	sstr[c] = loc[3+strlen("recurrencyKind")+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				DEBUG_INFO("recurrencyKind =%s\n",sstr);
+	  				strcpy(temprecurrencyKindStr,sstr);
+	  			}
+	  			else
+	  			{
+	  				 strcpy(temprecurrencyKindStr,"");
+	  			}
+
+
+	  			//***********validFrom**************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "validFrom");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				 while (loc[3+strlen("validFrom")+c] != '\"')
+	  				 {
+	  				  	  sstr[c] = loc[3+strlen("validFrom")+c];
+	  				  	  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	  c++;
+	  				 }
+	  				 sstr[c] = '\0';
+	  				 DEBUG_INFO("validFrom=%s\n",sstr);
+	  				 strcpy(tempvalidFromStr,sstr);
+
+	  			}
+	  			else
+	  			{
+	  				strcpy(tempvalidFromStr,"");
+	  			}
+
+	  			//***********validTo **************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "validTo");
+	  			//DEBUG_INFO("loc=%s\n",loc);
+	  			memset(sstr ,0, sizeof(sstr) );
+
+	  			if(loc != NULL)
+	  			{
+	  				while (loc[3+strlen("validTo")+c] != '\"')
+	  				{
+	  				  	sstr[c] = loc[3+strlen("validTo")+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				DEBUG_INFO("validTo =%s\n",sstr);
+	  				strcpy(tempvalidToStr,sstr);
+
+	  			}
+	  			else
+	  			{
+	  				strcpy(tempvalidToStr,"");
+	  			}
+
+
+	  			//***********validFrom**************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "validFrom");
+	  			if(loc != NULL)
+	  			{
+	  				 memset(sstr ,0, sizeof(sstr) );
+	  				 while (loc[3+strlen("validFrom")+c] != '\"')
+	  				 {
+	  				  	sstr[c] = loc[3+strlen("validFrom")+c];
+	  				  	c++;
+	  				 }
+	  				 sstr[c] = '\0';
+	  				 strcpy(tempvalidFromStr,sstr);
+	  			}
+	  			else
+	  			{
+	  				  strcpy(tempvalidFromStr,"");
+	  			}
+
+	  			//***********duration**************/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "duration");
+	  			if(loc != NULL)
+	  			{
+	  				memset(sstr ,0, sizeof(sstr) );
+	  				while (loc[2+strlen("duration")+c] != ',')
+	  				{
+	  				  	sstr[c] = loc[2+strlen("duration")+c];
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				tempdurationInt = atoi(sstr);
+	  			}
+	  			else
+	  			{
+	  				tempdurationInt = 0;
+	  			}
+
+	  			//**********startSchedule**********/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "startSchedule");
+	  			memset(sstr ,0, sizeof(sstr) );
+	  			while (loc[3+strlen("startSchedule")+c] != '\"')
+	  			{
+	  				sstr[c] = loc[3+strlen("startSchedule")+c];
+	  				c++;
+	  			}
+	  			sstr[c] = '\0';
+	  			strcpy(tempstartScheduleStr, sstr);
+	  			strcpy(ChargePointMaxProfileScheduleStr, sstr);
+
+
+	  			//**********chargingRateUnit**********/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "chargingRateUnit");
+	  			memset(sstr ,0, sizeof(sstr) );
+	  			while (loc[3+strlen("chargingRateUnit")+c] != '\"')
+	  			{
+	  				sstr[c] = loc[3+strlen("chargingRateUnit")+c];
+	  				c++;
+	  			}
+	  			sstr[c] = '\0';
+	  			strcpy(tempchargingRateUnitStr, sstr);
+
+	  			//**********minChargingRate*******/
+	  			c = 0;
+	  			loc = strstr(sLineWord, "minChargingRate");
+	  			if(loc != NULL)
+	  			{
+	  				 memset(sstr ,0, sizeof(sstr) );
+	  				 while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
+	  				 {
+	  				  	sstr[c] = loc[2+strlen("minChargingRate")+c];
+	  				  	c++;
+	  				 }
+	  				 sstr[c] = '\0';
+	  				 tempminChargingRateFloat = atof(sstr);
+	  			}
+	  			else
+	  			{
+	  				 tempminChargingRateFloat = 0.0;
+	  			}
+
+	  			//
+	  			strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
+	  			tp.tm_isdst = -1;
+	  			time_t utc = mktime(&tp);
+	  			time_t t = time(NULL);
+	  			diff_t = difftime(t, utc);
+
+	  			DEBUG_INFO("diff_t=%f\n",diff_t);
+	  			DEBUG_INFO(" debug  5 -1\n");
+	  			//parsing strings to words
+	  			i = 0;
+	  			loc = strstr(sLineWord, "chargingSchedulePeriod");
+	  			loc = loc+3+strlen("chargingSchedulePeriod");
+	  			pch = strtok(loc ,"{");
+	  			while (pch != NULL)
+	  			{
+	  				strcpy(SchedulePeriodList[i], pch);
+	  				pch = strtok (NULL, "{");
+	  				i = i + 1;
+	  			}
+	  			n_SchedulePeriods = i;
+
+	  			for(int i=0;i<n_SchedulePeriods;i++)
+	  			{
+	  				//*************startPeriod****************/
+	  				c = 0;
+	  				loc = strstr(SchedulePeriodList[i], "startPeriod");
+	  				memset(sstr ,0, sizeof(sstr) );
+	  				while (loc[strlen("startPeriod")+2+c] != ',')
+	  				{
+	  					sstr[c] = loc[strlen("startPeriod")+2+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				}
+	  				sstr[c] = '\0';
+	  				tempStartPeriodInt = atoi(sstr);
+
+	  				 //*************limit****************/
+	  				 c = 0;
+	  				 loc = strstr(SchedulePeriodList[i], "limit");
+	  				 memset(sstr ,0, sizeof(sstr) );
+	  				 while (loc[strlen("limit")+2+c] != ',')
+	  				 {
+	  				  	sstr[c] = loc[strlen("limit")+2+c];
+	  				  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	c++;
+	  				 }
+	  				 sstr[c] = '\0';
+	  				 tempLimitInt = atof(sstr);
+
+	  				  //*************numberPhases****************/
+	  				  c = 0;
+	  				  loc = strstr(SchedulePeriodList[i], "numberPhases");
+	  				  memset(sstr ,0, sizeof(sstr) );
+	  				  while (loc[strlen("numberPhases")+2+c] != '}')
+	  				  {
+	  					  sstr[c] = loc[strlen("numberPhases")+2+c];
+	  					  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  c++;
+	  				  }
+	  				  sstr[c] = '\0';
+	  				  tempNumberPhasesInt = atoi(sstr);
+
+	  				  if(j == 0)
+	  				  {
+	  					  ChargePointMaxProfile.Duration = tempdurationInt;
+	  					  ChargePointMaxProfile.TotalPeriod = n_SchedulePeriods;
+	  					  ChargePointMaxProfile.Period[i].Limit = tempLimitInt;
+	  					  ChargePointMaxProfile.Period[i].NumberPhases = tempNumberPhasesInt;
+	  					  ChargePointMaxProfile.Period[i].StartPeriod = tempStartPeriodInt;
+
+	  					  ChargePointMaxProfile_TEMP.ChargingProfileId = tempchargingProfileId;
+	  					  ChargePointMaxProfile_TEMP.StackLevel = tempstackLevel;
+	  					  ChargePointMaxProfile_TEMP.TransactionId = 0;
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.ChargingProfileKind, (const char *)tempchargingProfileKindStr);
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.ChargingProfilePurpose,  (const char *)tempchargingProfilePurposeStr);
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.RecurrencyKind,  (const char *)temprecurrencyKindStr);
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.ChargingSchedule.StartSchedule,  (const char *)tempstartScheduleStr);
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.ValidFrom,  (const char *)tempvalidFromStr);
+	  					  strcpy((char *)ChargePointMaxProfile_TEMP.ValidTo,  (const char *)tempvalidToStr);
+
+	  				  }
+
+	  			}
+
+	  			if(MinChargingRate < tempminChargingRateFloat)
+	  			{
+	  				MinChargingRate = tempminChargingRateFloat;
+	  			}
+
+	  			if(confirmPeriods < n_SchedulePeriods)
+	  			{
+	  				confirmPeriods = n_SchedulePeriods;
+	  			}
+
+
+	  			j = j + 1;
+	  		  }
+
+	  		  fclose(fptr1);
+	  		}
+
+	  	  }// the end of access file ChargePointMaxProfile
+
+
+	  	//****************************TxDefaultProfile************************************************/
+
+	  	switch(gunindex + 1)
+	  	{
+	  		case 0:
+	  			  break;
+
+	  		case 1:
+	  			  strcpy(fname, TxDefaultProfile_1_JSON );
+	  			  break;
+
+	  		case 2:
+	  			  strcpy(fname, TxDefaultProfile_2_JSON );
+	  			  break;
+
+	  		default:
+	  			  strcpy(fname, TxDefaultProfile_1_JSON );
+	  			  break;
+	  	}
+
+	  	TxDefaultProfileFileIsNull=TRUE;
+	  	if((access(fname,F_OK))!=-1)
+	  	{
+	  	  	fptr1 = fopen(fname, "r");
+
+	  	  	c = 0;
+	  	  	c = fgetc(fptr1);
+	  	  	//DEBUG_INFO("c:%d\n",c);
+	  	  	rewind(fptr1);
+
+	  	  	if(c == EOF)
+	  	  	{
+	  	  		DEBUG_INFO("\n End of file reached.");
+	  	  		TxDefaultProfileFileIsNull=TRUE;
+	  	  		fclose(fptr1);
+
+	  	  	}
+	  	  	else
+	  	  	{
+	  	  		TxDefaultProfileFileIsNull=FALSE;
+
+	  	  		while(fscanf(fptr1, "%s", word) != EOF)
+	  	  		{
+	  	  			if(strcmp(word, "chargingProfileId") == 0)
+	  	  			{
+	  	  			  	n_chargingProfile = n_chargingProfile + 1;
+	  	  			}
+	  	  		}
+	  	  		rewind(fptr1);
+
+	  	  		//search Charging Profile Element
+	  	  		int i = 0;
+	  	  		int j = 0;
+	  	  		while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {
+	#if 0
+	  	  			  	/***********connectorId****************/
+	  	  			  	c = 0;
+	  	  			  	loc = strstr(sLineWord, "connectorId");
+	  	  			  	memset(sstr ,0, sizeof(sstr) );
+	  	  			  	while (loc[strlen("connectorId")+2+c] != ',')
+	  	  			  	{
+	  	  			  	  	sstr[c] = loc[strlen("connectorId")+2+c];
+	  	  			  	  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  			  	  	c++;
+	  	  			  	}
+	  	  			  	sstr[c] = '\0';
+	  	  			  	tempconnectorIdInt = atoi(sstr);
+	#endif
+
+	  	  		//***********chargingProfileId**************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "chargingProfileId");
+	  	  		//DEBUG_INFO("loc=%s\n",loc);
+	  	  		memset(sstr ,0, sizeof(sstr) );
+
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			while (loc[2+strlen("chargingProfileId")+c] != '\"')
+	  	  			{
+	  	  				sstr[c] = loc[2+strlen("chargingProfileId")+c];
+	  	  				//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  				c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			DEBUG_INFO("chargingProfileId=%s\n",sstr);
+	  	  			tempchargingProfileId = atoi(sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			tempchargingProfileId = 0;
+	  	  		}
+
+
+	  	  		//***********stackLevel**************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "stackLevel");
+	  	  		//DEBUG_INFO("loc=%s\n",loc);
+	  	  		memset(sstr ,0, sizeof(sstr) );
+
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			while (loc[2+strlen("stackLevel")+c] != '\"')
+	  	  			{
+	  	  				sstr[c] = loc[2+strlen("stackLevel")+c];
+	  	  				//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  				c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			DEBUG_INFO("stackLevel=%s\n",sstr);
+	  	  			tempstackLevel = atoi(sstr);
+
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			tempstackLevel = 0;
+	  	  		}
+
+	  	  		//***********chargingProfilePurpose **************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "chargingProfilePurpose");
+	  	  		//DEBUG_INFO("loc=%s\n",loc);
+	  	  		memset(sstr ,0, sizeof(sstr) );
+
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
+	  	  			{
+	  	  				sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
+	  	  				//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  				c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			DEBUG_INFO("chargingProfilePurpose =%s\n",sstr);
+	  	  			strcpy(tempchargingProfilePurposeStr,sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			strcpy(tempchargingProfilePurposeStr,"");
+	  	  		}
+
+
+	  	  		//***********chargingProfileKind  **************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "chargingProfileKind");
+	  	  		//DEBUG_INFO("loc=%s\n",loc);
+	  	  		memset(sstr ,0, sizeof(sstr) );
+
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			while (loc[3+strlen("chargingProfileKind")+c] != '\"')
+	  	  			{
+	  	  				sstr[c] = loc[3+strlen("chargingProfileKind")+c];
+	  	  				//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  				c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			DEBUG_INFO("chargingProfileKind =%s\n",sstr);
+	  	  			strcpy(tempchargingProfileKindStr,sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			strcpy(tempchargingProfileKindStr,"");
+	  	  		}
+
+
+	  	  		//***********recurrencyKind  **************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "recurrencyKind");
+	  	  		//DEBUG_INFO("loc=%s\n",loc);
+	  	  		memset(sstr ,0, sizeof(sstr) );
+
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			while (loc[3+strlen("recurrencyKind")+c] != '\"')
+	  	  			{
+	  	  				 sstr[c] = loc[3+strlen("recurrencyKind")+c];
+	  	  				 //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  				 c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			DEBUG_INFO("recurrencyKind =%s\n",sstr);
+	  	  			strcpy(temprecurrencyKindStr,sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			strcpy(temprecurrencyKindStr,"");
+	  	  		}
+
+	  	  		//***********validFrom**************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "validFrom");
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			memset(sstr ,0, sizeof(sstr) );
+	  	  			while (loc[3+strlen("validFrom")+c] != '\"')
+	  	  			{
+	  	  			  	sstr[c] = loc[3+strlen("validFrom")+c];
+	  	  			  	c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			strcpy(tempvalidFromStr,sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			strcpy(tempvalidFromStr,"");
+	  	  		}
+
+	  	  		//***********validFrom**************/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "duration");
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			 memset(sstr ,0, sizeof(sstr) );
+	  	  			 while (loc[2+strlen("duration")+c] != ',')
+	  	  			 {
+	  	  			  	sstr[c] = loc[2+strlen("duration")+c];
+	  	  			  	c++;
+	  	  			 }
+	  	  			 sstr[c] = '\0';
+	  	  			 tempdurationInt = atoi(sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			 tempdurationInt = 0;
+	  	  		}
+
+	  	  		//**********startSchedule**********/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "startSchedule");
+	  	  		memset(sstr ,0, sizeof(sstr) );
+	  	  		while (loc[3+strlen("startSchedule")+c] != '\"')
+	  	  		{
+	  	  			sstr[c] = loc[3+strlen("startSchedule")+c];
+	  	  			c++;
+	  	  		}
+	  	  		sstr[c] = '\0';
+	  	  		strcpy(tempstartScheduleStr, sstr);
+	  	  		strcpy(TxDefaultProfileScheduleStr, sstr);
+
+
+	  	  		//**********chargingRateUnit**********/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "chargingRateUnit");
+	  	  		memset(sstr ,0, sizeof(sstr) );
+	  	  		while (loc[3+strlen("chargingRateUnit")+c] != '\"')
+	  	  		{
+	  	  			  		sstr[c] = loc[3+strlen("chargingRateUnit")+c];
+	  	  			  		c++;
+	  	  		}
+	  	  		sstr[c] = '\0';
+	  	  		strcpy(tempchargingRateUnitStr, sstr);
+
+	  	  		//**********minChargingRate*******/
+	  	  		c = 0;
+	  	  		loc = strstr(sLineWord, "minChargingRate");
+	  	  		if(loc != NULL)
+	  	  		{
+	  	  			memset(sstr ,0, sizeof(sstr) );
+	  	  			while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
+	  	  			{
+	  	  				sstr[c] = loc[2+strlen("minChargingRate")+c];
+	  	  			  	c++;
+	  	  			}
+	  	  			sstr[c] = '\0';
+	  	  			tempminChargingRateFloat = atof(sstr);
+	  	  		}
+	  	  		else
+	  	  		{
+	  	  			tempminChargingRateFloat = 0.0;
+	  	  		}
+
+	  	  		//
+	  	  		strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
+	  	  		tp.tm_isdst = -1;
+	  	  		time_t utc = mktime(&tp);
+	  	  		time_t t = time(NULL);
+	  	  		diff_t = difftime(t, utc);
+
+	  	  		DEBUG_INFO("diff_t=%f\n",diff_t);
+
+	  	  		//parsing strings to words
+	  	  		i = 0;
+	  	  		loc = strstr(sLineWord, "chargingSchedulePeriod");
+	  	  		loc = loc+3+strlen("chargingSchedulePeriod");
+	  	  		pch = strtok(loc ,"{");
+	  	  		while (pch != NULL)
+	  	  		{
+	  	  			strcpy(SchedulePeriodList[i], pch);
+	  	  			pch = strtok (NULL, "{");
+	  	  			i = i + 1;
+	  	  		}
+	  	  		n_SchedulePeriods = i;
+
+	  	  		for(int i=0;i<n_SchedulePeriods;i++)
+	  	  		{
+	  	  			 //*************startPeriod****************/
+	  	  			 c = 0;
+	  	  			 loc = strstr(SchedulePeriodList[i], "startPeriod");
+	  	  			 memset(sstr ,0, sizeof(sstr) );
+	  	  			 while (loc[strlen("startPeriod")+2+c] != ',')
+	  	  			 {
+	  	  			  	  		sstr[c] = loc[strlen("startPeriod")+2+c];
+	  	  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  			  	  		c++;
+	  	  			 }
+	  	  			 sstr[c] = '\0';
+	  	  			 tempStartPeriodInt = atoi(sstr);
+
+	  	  			 //*************limit****************/
+	  	  			 c = 0;
+	  	  			 loc = strstr(SchedulePeriodList[i], "limit");
+	  	  			 memset(sstr ,0, sizeof(sstr) );
+	  	  			 while (loc[strlen("limit")+2+c] != ',')
+	  	  			 {
+	  	  			  	sstr[c] = loc[strlen("limit")+2+c];
+	  	  			  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  			  	c++;
+	  	  			 }
+	  	  			 sstr[c] = '\0';
+	  	  			 tempLimitInt = atof(sstr);
+
+	  	  			 //*************numberPhases****************/
+	  	  			 c = 0;
+	  	  			 loc = strstr(SchedulePeriodList[i], "numberPhases");
+	  	  			 memset(sstr ,0, sizeof(sstr) );
+	  	  			 while (loc[strlen("numberPhases")+2+c] != '}')
+	  	  			 {
+	  	  			  	 sstr[c] = loc[strlen("numberPhases")+2+c];
+	  	  			  	 //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  	  			  	 c++;
+	  	  			 }
+	  	  			 sstr[c] = '\0';
+	  	  			 tempNumberPhasesInt = atoi(sstr);
+
+	  	  			 if(j == 0)
+	  	  			 {
+	  	  			  	  TxDefaultProfile.Duration = tempdurationInt;
+	  	  			  	  TxDefaultProfile.TotalPeriod = n_SchedulePeriods;
+	  	  			  	  TxDefaultProfile.Period[i].Limit = tempLimitInt;
+	  	  			  	  TxDefaultProfile.Period[i].NumberPhases = tempNumberPhasesInt;
+	  	  			  	  TxDefaultProfile.Period[i].StartPeriod = tempStartPeriodInt;
+
+	  	  			  	  TxDefaultProfile_TEMP.ChargingProfileId = tempchargingProfileId;
+	  	  			  	  TxDefaultProfile_TEMP.StackLevel = tempstackLevel;
+	  	  			  	  TxDefaultProfile_TEMP.TransactionId = 0;
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.ChargingProfileKind, (const char *)tempchargingProfileKindStr);
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.ChargingProfilePurpose, (const char *)tempchargingProfilePurposeStr);
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.RecurrencyKind, (const char *)temprecurrencyKindStr);
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.ChargingSchedule.StartSchedule, (const char *)tempstartScheduleStr);
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.ValidFrom, (const char *)tempvalidFromStr);
+	  	  			  	  strcpy((char *)TxDefaultProfile_TEMP.ValidTo, (const char *)tempvalidToStr);
+	  	  			 }
+	  	  			 else
+	  	  			 {
+	  	  			  	  //other stack level charging Profile
+	  	  			  	  TxDefaultProfiletemp[j-1].Period[i].Limit = tempLimitInt;
+	  	  			  	  TxDefaultProfiletemp[j-1].Period[i].NumberPhases = tempNumberPhasesInt;
+	  	  			  	  TxDefaultProfiletemp[j-1].Period[i].StartPeriod = tempStartPeriodInt;
+	  	  			  	  TxDefaultProfiletemp[j-1].Duration = tempdurationInt;
+	  	  			  	  TxDefaultProfiletemp[j-1].TotalPeriod = n_SchedulePeriods;
+
+	  	  			 }
+
+	  	  			}
+
+	  	  			  	  if(MinChargingRate < tempminChargingRateFloat)
+	  	  			  	  	MinChargingRate = tempminChargingRateFloat;
+
+
+	  	  			  	  if(confirmPeriods < n_SchedulePeriods)
+	  	  			  	  	confirmPeriods = n_SchedulePeriods;
+
+	  	  			  	  j = j + 1;
+	  	  		  }
+
+	  	  		  fclose(fptr1);
+
+	  	  		  //Stacking Charging Profiles
+	  	  		  for(int l=0; l <(j-1) ;l++)
+	  	  		  {
+	  	  			  		for(int k=0; k < TxDefaultProfiletemp[l].TotalPeriod; k++)
+	  	  			  		{
+	  	  			  			if(TxDefaultProfiletemp[l].Period[k].StartPeriod > TxDefaultProfile.Duration)
+	  	  			  		  	{
+	  	  			  				if((k >0) && ((TxDefaultProfiletemp[l].Period[k-1].StartPeriod < TxDefaultProfile.Duration) &&(TxDefaultProfiletemp[l].Period[k-1].StartPeriod >= TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod-1].StartPeriod )))
+	  	  			  				{
+	  	  			  					TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k-1].Limit;
+	  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k-1].NumberPhases;
+	  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfile.Duration;
+	  	  			  				  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
+	  	  			  				  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;
+
+	  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k].Limit;
+	  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k].NumberPhases;
+	  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfiletemp[l].Period[k].StartPeriod;
+	  	  			  				  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
+	  	  			  				  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;
+
+
+	  	  			  				}
+	  	  			  				else
+	  	  			  			  	{
+	  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k].Limit;
+	  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k].NumberPhases;
+	  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfiletemp[l].Period[k].StartPeriod;
+	  	  			  			  	  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
+	  	  			  			  	  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;
+
+	  	  			  			  	 }
+
+
+	  	  			  		  	}
+
+	  	  			  		}
+
+	  	  			  	}
+	  	  			  	//end of Stacking Charging Profiles
+
+	  	  			 }
+
+	  			}// the end of ACCESS TxDefaultProfile
+
+	  			//****************************TxProfile************************************************/
+	  			switch(gunindex + 1)
+	  			{
+	  			  	case 0:
+	  			  		break;
+
+	  			  	case 1:
+	  			  		strcpy(fname, TxProfile_1_JSON );
+	  			  		break;
+
+	  			  	case 2:
+	  			  		strcpy(fname, TxProfile_2_JSON );
+	  			  		break;
+
+	  			  	default:
+	  			  		strcpy(fname, TxProfile_1_JSON );
+	  			  		break;
+	  			}
+
+	  			TxProfileIsNull=TRUE;
+	  			if((access(fname,F_OK))!=-1)
+	  			{
+	  				fptr1 = fopen(fname, "r");
+	  				c = 0;
+	  				c = fgetc(fptr1);
+	  				//DEBUG_INFO("c:%d\n",c);
+	  				rewind(fptr1);
+
+	  				if(c == EOF)
+	  				{
+	  				  	DEBUG_INFO("\n End of file reached.");
+	  				  	TxProfileIsNull=TRUE;
+	  				  	fclose(fptr1);
+
+	  				}
+	  				else
+	  				{
+	  				  	TxProfileIsNull=FALSE;
+
+	  				  	while(fscanf(fptr1, "%s", word) != EOF)
+	  				  	{
+	  				  	  	if(strcmp(word, "chargingProfileId") == 0)
+	  				  	  	{
+	  				  	  		n_chargingProfile = n_chargingProfile + 1;
+	  				  	  	}
+	  				  	}
+	  				  	rewind(fptr1);
+
+	  					//search Charging Profile Element
+	  				  	int i= 0;
+	  				  	int j= 0;
+	  				  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {
+
+	#if 0
+	  				  	  	/***********connectorId****************/
+	  				  	  	c = 0;
+	  				  	  	loc = strstr(sLineWord, "connectorId");
+	  				  	  	memset(sstr ,0, sizeof(sstr) );
+	  				  	  	while (loc[strlen("connectorId")+2+c] != ',')
+	  				  	  	{
+	  				  	  		sstr[c] = loc[strlen("connectorId")+2+c];
+	  				  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	  		c++;
+	  				  	  	}
+	  				  	  	sstr[c] = '\0';
+	  				  	  	tempconnectorIdInt = atoi(sstr);
+	#endif
+
+	  				   //***********chargingProfileId**************/
+	  				   c = 0;
+	  				   loc = strstr(sLineWord, "chargingProfileId");
+	  				   //DEBUG_INFO("loc=%s\n",loc);
+	  				   memset(sstr ,0, sizeof(sstr) );
+
+	  					if(loc != NULL)
+	  					{
+	  					  	while (loc[2+strlen("chargingProfileId")+c] != '\"')
+	  					  	{
+	  					  	  sstr[c] = loc[2+strlen("chargingProfileId")+c];
+	  					  	  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  	  c++;
+	  					  	}
+	  					  	sstr[c] = '\0';
+	  					  	DEBUG_INFO("chargingProfileId=%s\n",sstr);
+	  					  	tempchargingProfileId = atoi(sstr);
+	  					}
+	  					else
+	  					{
+	  					  	tempchargingProfileId = 0;
+	  					}
+
+
+	  					//***********transactionId **************/
+	  					c = 0;
+	  					loc = strstr(sLineWord, "transactionId");
+	  					//DEBUG_INFO("loc=%s\n",loc);
+	  					memset(sstr ,0, sizeof(sstr) );
+
+	  					if(loc != NULL)
+	  					{
+	  						while (loc[2+strlen("transactionId")+c] != '\"')
+	  						{
+	  						  	sstr[c] = loc[2+strlen("transactionId")+c];
+	  						  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  						    c++;
+	  						}
+	  						sstr[c] = '\0';
+	  						DEBUG_INFO("transactionId=%s\n",sstr);
+	  						temptransactionId = atoi(sstr);
+	  					}
+	  					else
+	  					{
+	  						temptransactionId = 0;
+	  					}
+
+
+	  					//***********stackLevel**************/
+	  					c = 0;
+	  					loc = strstr(sLineWord, "stackLevel");
+	  					//DEBUG_INFO("loc=%s\n",loc);
+	  					memset(sstr ,0, sizeof(sstr) );
+
+	  					if(loc != NULL)
+	  					{
+	  						while (loc[2+strlen("stackLevel")+c] != '\"')
+	  					  	{
+	  							sstr[c] = loc[2+strlen("stackLevel")+c];
+	  					  		//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  	  	c++;
+	  					  	}
+	  					  	sstr[c] = '\0';
+	  					  	DEBUG_INFO("stackLevel=%s\n",sstr);
+	  					  	tempstackLevel = atoi(sstr);
+
+	  					}
+	  					else
+	  					{
+	  						tempstackLevel = 0;
+	  					}
+
+	  				  //***********chargingProfilePurpose **************/
+	  				   c = 0;
+	  				   loc = strstr(sLineWord, "chargingProfilePurpose");
+	  				   //DEBUG_INFO("loc=%s\n",loc);
+	  				   memset(sstr ,0, sizeof(sstr) );
+
+	  				   if(loc != NULL)
+	  				   {
+	  					  while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
+	  					  {
+	  					  	  sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
+	  					  	  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  	  c++;
+	  					  }
+	  					  sstr[c] = '\0';
+	  					  DEBUG_INFO("chargingProfilePurpose =%s\n",sstr);
+	  					  strcpy(tempchargingProfilePurposeStr,sstr);
+	  				   }
+	  				   else
+	  				   {
+	  					  strcpy(tempchargingProfilePurposeStr,"");
+	  				   }
+
+
+	  				  //***********chargingProfileKind  **************/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "chargingProfileKind");
+	  				  //DEBUG_INFO("loc=%s\n",loc);
+	  				  memset(sstr ,0, sizeof(sstr) );
+
+	  				  if(loc != NULL)
+	  				  {
+	  					  while (loc[3+strlen("chargingProfileKind")+c] != '\"')
+	  					  {
+	  					  	  sstr[c] = loc[3+strlen("chargingProfileKind")+c];
+	  					  	  //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  	  c++;
+	  					  }
+	  					  sstr[c] = '\0';
+	  					  DEBUG_INFO("chargingProfileKind =%s\n",sstr);
+	  					  strcpy(tempchargingProfileKindStr,sstr);
+	  				  }
+	  				  else
+	  				  {
+	  					  strcpy(tempchargingProfileKindStr,"");
+	  				  }
+
+
+	  				  //***********recurrencyKind  **************/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "recurrencyKind");
+	  				  //DEBUG_INFO("loc=%s\n",loc);
+	  				  memset(sstr ,0, sizeof(sstr) );
+
+	  				  if(loc != NULL)
+	  			      {
+	  					while (loc[3+strlen("recurrencyKind")+c] != '\"')
+	  					{
+	  					  	sstr[c] = loc[3+strlen("recurrencyKind")+c];
+	  					  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  					  	c++;
+	  					}
+	  					sstr[c] = '\0';
+	  					DEBUG_INFO("recurrencyKind =%s\n",sstr);
+	  					strcpy(temprecurrencyKindStr,sstr);
+	  				  }
+	  				  else
+	  				  {
+	  					strcpy(temprecurrencyKindStr,"");
+	  				  }
+
+
+	  				  //***********validFrom**************/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "validFrom");
+	  				  if(loc != NULL)
+	  				  {
+	  					  memset(sstr ,0, sizeof(sstr) );
+	  				  	  while (loc[3+strlen("validFrom")+c] != '\"')
+	  				  	  {
+	  				  		  sstr[c] = loc[3+strlen("validFrom")+c];
+	  				  		  c++;
+	  				  	  }
+	  				  	  sstr[c] = '\0';
+	  				  	  strcpy(tempvalidFromStr,sstr);
+	  				  }
+	  				  else
+	  				  {
+	  				  	  strcpy(tempvalidFromStr,"");
+	  				  }
+
+	  				  //**********startSchedule**********/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "startSchedule");
+	  				  memset(sstr ,0, sizeof(sstr) );
+	  				  while (loc[3+strlen("startSchedule")+c] != '\"')
+	  				  {
+	  				  	  sstr[c] = loc[3+strlen("startSchedule")+c];
+	  				  	  c++;
+	  				  }
+	  				  sstr[c] = '\0';
+	  				  strcpy(tempstartScheduleStr, sstr);
+	  				  strcpy(TxProfileScheduleStr, sstr);
+
+	  				  //**********chargingRateUnit**********/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "chargingRateUnit");
+	  				  memset(sstr ,0, sizeof(sstr) );
+	  				  while (loc[3+strlen("chargingRateUnit")+c] != '\"')
+	  				  {
+	  				  	  sstr[c] = loc[3+strlen("chargingRateUnit")+c];
+	  				  	  c++;
+	  				  }
+	  				  sstr[c] = '\0';
+	  				  strcpy(tempchargingRateUnitStr, sstr);
+
+	  				  //**********minChargingRate*******/
+	  				  c = 0;
+	  				  loc = strstr(sLineWord, "minChargingRate");
+	  				  if(loc != NULL)
+	  				  {
+	  				  	 memset(sstr ,0, sizeof(sstr) );
+	  				  	 while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
+	  				  	 {
+	  				  	  	sstr[c] = loc[2+strlen("minChargingRate")+c];
+	  				  	  	c++;
+	  				  	 }
+	  				  	 sstr[c] = '\0';
+	  				  	 tempminChargingRateFloat = atof(sstr);
+	  				  }
+	  				  else
+	  				  {
+	  				  	 tempminChargingRateFloat = 0.0;
+	  				  }
+
+	  				  //
+	  				  strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
+	  				  tp.tm_isdst = -1;
+	  				  time_t utc = mktime(&tp);
+	  				  time_t t = time(NULL);
+	  				  diff_t = difftime(t, utc);
+
+	  				  DEBUG_INFO("diff_t=%f\n",diff_t);
+	  				  //parsing strings to words
+	  				  i = 0;
+	  				  loc = strstr(sLineWord, "chargingSchedulePeriod");
+	  				  loc = loc+3+strlen("chargingSchedulePeriod");
+	  				  pch = strtok(loc ,"{");
+	  				  while (pch != NULL)
+	  				  {
+	  				  	  strcpy(SchedulePeriodList[i], pch);
+	  				  	  pch = strtok (NULL, "{");
+	  				  	  i = i + 1;
+	  				  }
+	  				  n_SchedulePeriods = i;
+
+	  				  for(int i=0;i<n_SchedulePeriods;i++)
+	  				  {
+	  				  	 //*************startPeriod****************/
+	  				  	 c = 0;
+	  				  	 loc = strstr(SchedulePeriodList[i], "startPeriod");
+	  				  	 memset(sstr ,0, sizeof(sstr) );
+	  				  	 while (loc[strlen("startPeriod")+2+c] != ',')
+	  				  	 {
+	  				  	  	sstr[c] = loc[strlen("startPeriod")+2+c];
+	  				  	    //printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	  	c++;
+	  				  	 }
+	  				  	 sstr[c] = '\0';
+	  				  	 tempStartPeriodInt = atoi(sstr);
+
+	  				  	 //*************limit****************/
+	  				  	 c = 0;
+	  				  	 loc = strstr(SchedulePeriodList[i], "limit");
+	  				  	 memset(sstr ,0, sizeof(sstr) );
+	  				  	 while (loc[strlen("limit")+2+c] != ',')
+	  				  	 {
+	  				  	  	sstr[c] = loc[strlen("limit")+2+c];
+	  				  	  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	  	c++;
+	  				  	 }
+	  				  	 sstr[c] = '\0';
+	  				  	 tempLimitInt = atof(sstr);
+
+	  				  	 //*************numberPhases****************/
+	  				  	 c = 0;
+	  				  	 loc = strstr(SchedulePeriodList[i], "numberPhases");
+	  				  	 memset(sstr ,0, sizeof(sstr) );
+	  				  	 while (loc[strlen("numberPhases")+2+c] != '}')
+	  				  	 {
+	  				  	  	sstr[c] = loc[strlen("numberPhases")+2+c];
+	  				  	  	//printf("i=%d sstr=%c\n",c, sstr[c]);
+	  				  	  	c++;
+	  				  	 }
+	  				  	 sstr[c] = '\0';
+	  				  	 tempNumberPhasesInt = atoi(sstr);
+
+
+	  				  	 //TxProfile.Duration = durationInt;
+	  				  	 TxProfile.TotalPeriod = n_SchedulePeriods;
+	  				  	 TxProfile.Period[i].Limit = tempLimitInt;
+	  				  	 TxProfile.Period[i].NumberPhases = tempNumberPhasesInt;
+	  				  	 TxProfile.Period[i].StartPeriod = tempStartPeriodInt;
+	  				  }
+
+	  				  if(MinChargingRate < tempminChargingRateFloat)
+	  				  	  MinChargingRate = tempminChargingRateFloat;
+
+	  				  if(confirmPeriods < n_SchedulePeriods)
+	  				  	  confirmPeriods = n_SchedulePeriods;
+
+	  				  if(j == 0)
+	  				  {
+	  					  TxProfile_TEMP.ChargingProfileId = tempchargingProfileId;
+	  					  TxProfile_TEMP.StackLevel = tempstackLevel;
+	  					  TxProfile_TEMP.TransactionId = 0;
+	  					  strcpy((char *)TxProfile_TEMP.ChargingProfileKind, (const char *)tempchargingProfileKindStr);
+	  					  strcpy((char *)TxProfile_TEMP.ChargingProfilePurpose, (const char *)tempchargingProfilePurposeStr);
+	  					  strcpy((char *)TxProfile_TEMP.RecurrencyKind, (const char *)temprecurrencyKindStr);
+	  					  strcpy((char *)TxProfile_TEMP.ChargingSchedule.StartSchedule, (const char *)tempstartScheduleStr);
+	  					  strcpy((char *)TxProfile_TEMP.ValidFrom, (const char *)tempvalidFromStr);
+	  					  strcpy((char *)TxProfile_TEMP.ValidTo, (const char *)tempvalidToStr);
+
+	  				  }
+	  				}
+
+	  				fclose(fptr1);
+
+	  			   }
+
+	  			}// the end of ACCESS TxProfile
+
+	  			//CompositeSchedule
+	  			int period=0;
+	  			if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==FALSE) && (TxProfileIsNull==FALSE) )
+	  			{
+	  				strcpy(CurrentChargingProfileScheduleStr,TxProfileScheduleStr);
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileId = TxProfile_TEMP.ChargingProfileId;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].TransactionId = temptransactionId;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].StackLevel = TxProfile_TEMP.StackLevel;
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileKind, (const char *)TxProfile_TEMP.ChargingProfileKind );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfilePurpose, (const char *)TxProfile_TEMP.ChargingProfilePurpose );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.StartSchedule,(const char *)TxProfile_TEMP.ChargingSchedule.StartSchedule);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].RecurrencyKind, (const char *)TxProfile_TEMP.RecurrencyKind);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidFrom, (const char *)TxProfile_TEMP.ValidFrom);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidTo, (const char *)TxProfile_TEMP.ValidTo);
+
+
+	  				for(int k=0; k < TxProfile.TotalPeriod;k++)
+	  				{
+	  					if(TxProfile.Period[k].Limit < ChargePointMaxProfile.Period[0].Limit)
+	  					{
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].Limit =  TxProfile.Period[k].Limit;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].NumberPhases =  TxProfile.Period[k].NumberPhases;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
+	  						//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = TxProfile.Period[k].Limit;
+	  			  			//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxProfile.Period[k].NumberPhases;
+	  			  			//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
+	  			  			period = period + 1;
+	  					}
+	  					else
+	  					{
+	  						if( (TxProfile.Period[k-1].Limit >= ChargePointMaxProfile.Period[0].Limit) && (TxProfile.Period[k].Limit >= ChargePointMaxProfile.Period[0].Limit))
+	  						{
+
+	  						}
+	  						else
+	  						{
+	  							ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].Limit =  ChargePointMaxProfile.Period[0].Limit;
+	  							ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].NumberPhases =   TxProfile.Period[k].NumberPhases;
+	  							ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
+
+
+	  							//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;
+	  							//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxProfile.Period[k].NumberPhases;
+	  							//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
+	  							period = period + 1;
+	  						}
+
+	  					}
+	  				}
+
+	  				for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
+	  				{
+	  					if((TxDefaultProfile.Period[l].StartPeriod < 86400)&&(TxDefaultProfile.Period[l].StartPeriod > ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period-1].StartPeriod))
+	  					{
+	  						if(TxDefaultProfile.Period[l].Limit < ChargePointMaxProfile.Period[0].Limit)
+	  						{
+	  							ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].Limit = TxDefaultProfile.Period[l].Limit;
+	  						  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = TxDefaultProfile.Period[l].Limit;
+	  						}
+	  						else
+	  						{
+	  							ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;
+	  							//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;
+
+	  						}
+
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  						//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  					  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+
+	  						period = period + 1;
+	  				   }
+
+
+	  			    }
+
+	  			}
+	  			else if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==FALSE) && (TxProfileIsNull==TRUE) )
+	  			{
+	  				strcpy(CurrentChargingProfileScheduleStr,TxDefaultProfileScheduleStr);
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileId = TxDefaultProfile_TEMP.ChargingProfileId;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].TransactionId = 0;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].StackLevel = TxDefaultProfile_TEMP.StackLevel;
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileKind, (const char *)TxDefaultProfile_TEMP.ChargingProfileKind );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfilePurpose, (const char *)TxDefaultProfile_TEMP.ChargingProfilePurpose );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.StartSchedule,(const char *)TxDefaultProfile_TEMP.ChargingSchedule.StartSchedule);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].RecurrencyKind, (const char *)TxDefaultProfile_TEMP.RecurrencyKind);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidFrom, (const char *)TxDefaultProfile_TEMP.ValidFrom);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidTo, (const char *)TxDefaultProfile_TEMP.ValidTo);
+
+
+	  				for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
+	  				{
+	  					if(TxProfile.Period[l].Limit < ChargePointMaxProfile.Period[0].Limit)
+	  					{
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  					  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
+	  					  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  					  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  					  	period = period + 1;
+	  					}
+	  					else
+	  					{
+
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].Limit = ChargePointMaxProfile.Period[0].Limit;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  	  				  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = ChargePointMaxProfile.Period[0].Limit;
+	  	  				  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  	  				  	//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  	  				  	period = period + 1;
+	  					}
+	  				}
+
+	  			}
+	  			else if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==TRUE) && (TxProfileIsNull==TRUE) )
+	  		  	{
+	  				strcpy(CurrentChargingProfileScheduleStr,TxDefaultProfileScheduleStr);
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileId = TxDefaultProfile_TEMP.ChargingProfileId;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].TransactionId = 0;
+	  				ShmOCPP16Data->SmartChargingProfile[gunindex].StackLevel = TxDefaultProfile_TEMP.StackLevel;
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfileKind, (const char *)TxDefaultProfile_TEMP.ChargingProfileKind );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingProfilePurpose, (const char *)TxDefaultProfile_TEMP.ChargingProfilePurpose );
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.StartSchedule, (const char *)TxDefaultProfile_TEMP.ChargingSchedule.StartSchedule);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].RecurrencyKind, (const char *)TxDefaultProfile_TEMP.RecurrencyKind);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidFrom, (const char *)TxDefaultProfile_TEMP.ValidFrom);
+	  				strcpy((char *)ShmOCPP16Data->SmartChargingProfile[gunindex].ValidTo, (const char *)TxDefaultProfile_TEMP.ValidTo);
+
+
+	  		  		for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
+	  		  		{
+  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
+  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].NumberPhases =  TxDefaultProfile.Period[l].NumberPhases;
+  						ShmOCPP16Data->SmartChargingProfile[gunindex].ChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  		  	  		//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
+	  		  	  		//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
+	  		  	  		//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
+	  		  	  		period = period + 1;
+	  		  		}
+
+	  		  	}
+
+	  			confirmPeriods = period;
+	  			//DEBUG_INFO("confirmPeriods=%d\n",confirmPeriods);
+
+
+
+
+#if 0
+	  			//* Define temporary variables */
+	  			struct tm *gtime;
+	  			time_t now;
+	  			char buf[28];
+	  			//* Read the current system time */
+	  			time(&now);
+	  			//* Convert the system time to GMT (now UTC) */
+	  			gtime = gmtime(&now);
+	  			strftime(buf, 28, "%Y-%m-%dT%H:%M:%SZ", gtime);
+
+	  			// make .conf
+	  			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.StartSchedule,buf);
+	  			//ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.Duration = durationInt;
+	  			//DEBUG_INFO(" debug  11\n");
+
+	  			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingRateUnit, tempchargingRateUnitStr );
+
+	  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.MinChargingRate = MinChargingRate;
+	  			sprintf(comfirmstr, "%s", GetCompositeScheduleStatusStr[GetCompositeScheduleStatus_Accepted] );
+#endif
+
+
+}
+
 #if 0
 void Send(struct json_object *message)
 {

EVSE/Modularization/ocppfiles/MessageHandler.h

@@ -1,138 +1,138 @@
-#ifndef MessageHandler_H
-#define MessageHandler_H
-
-struct StructPeriod
-{
-	int		StartPeriod;
-	float 	Limit;//0.1;
-	int		NumberPhases;
-};
-
-struct StructProfile
-{
-	int	Duration;
-	int TotalPeriod;
-	struct StructPeriod	Period[10];
-};
-
-
-//===============================================
-// Common routine
-//===============================================
-int initialConfigurationTable(void);
-
-//==========================================
-// send request routine
-//==========================================
-int sendAuthorizeRequest(int gun_index);
-int sendBootNotificationRequest(void);
-int sendDataTransferRequest(int gun_index);
-int sendDiagnosticsStatusNotificationRequest(char *status);
-int sendFirmwareStatusNotificationRequest(char *status);
-int sendHeartbeatRequest(int gun_index);
-int sendStartTransactionRequest(int gun_index);
-int sendStatusNotificationRequest(int gun_index);
-int sendStopTransactionRequest(int gun_index);
-int sendMeterValuesRequest(int gun_index);
-
-
-//==========================================
-// send confirm routine
-//==========================================
-int sendCancelReservationConfirmation(char *uuid,char *payload);
-int sendChangeAvailabilityConfirmation(char *uuid,char *payload);
-int sendChangeConfigurationConfirmation(char *uuid,char *payload);
-int sendClearCacheConfirmation(char *uuid,char *payload);
-int sendClearChargingProfileConfirmation(char *uuid,char *payload);
-int sendDataTransferConfirmation(char *uuid,char *payload);
-int sendGetCompositeScheduleConfirmation(char *uuid,char *payload, int connectorIdInt,int nPeriod);
-int sendGetConfigurationConfirmation(char *uuid);
-int sendGetDiagnosticsConfirmation(char *uuid,char *payload);
-int sendGetLocalListVersionConfirmation(char *uuid,char *payload);
-int sendRemoteStartConfirmation(char *uuid,char *payload);
-int sendRemoteStopTransactionConfirmation(char *uuid,char *payload);
-int sendReserveNowTransactionConfirmation(char *uuid,char *payload);
-int sendResetConfirmation(char *uuid,char *payload);
-int sendSendLocalListConfirmation(char *uuid,char *payload);
-int sendSetChargingProfileConfirmation(char *uuid,char *payload);
-int sendTriggerMessageConfirmation(char *uuid,char *payload);
-int sendUnlockConnectorConfirmation(char *uuid,char *payload);
-int sendUpdateFirmwareConfirmation(char *uuid);
-//==========================================
-// send CallError routine
-//==========================================
-void SendCallError(char *uniqueId, char *action, char *errorCode, char *errorDescription);
-
-//==========================================
-// Handle server request routine  Start
-//==========================================
-int handleCancelReservationRequest(char *uuid, char *payload);
-int handleChangeAvailabilityRequest(char *uuid, char *payload);
-int handleChangeConfigurationRequest(char *uuid, char *payload);
-int handleClearCacheRequest(char *uuid, char *payload);
-int handleClearChargingProfileRequest(char *uuid, char *payload);
-int handleDataTransferRequest(char *uuid, char *payload);
-//long long diff_tm(struct tm *a, struct tm *b);
-int handleGetCompositeScheduleRequest(char *uuid, char *payload);
-int handleGetConfigurationRequest(char *uuid, char *payload);
-int handleGetDiagnosticsRequest(char *uuid, char *payload);
-int handleGetLocalListVersionRequest(char *uuid, char *payload);
-int handleRemoteStartRequest(char *uuid, char *payload);
-int handleRemoteStopTransactionRequest(char *uuid, char *payload);
-int handleReserveNowTransactionRequest(char *uuid, char *payload);
-int handleResetRequest(char *uuid, char *payload);
-int handleSendLocalListRequest(char *uuid, char *payload);
-int handleSetChargingProfileRequest(char *uuid, char *payload);
-int handleTriggerMessageRequest(char *uuid, char *payload);
-int handleUnlockConnectorRequest(char *uuid, char *payload);
-int handleUpdateFirmwareRequest(char *uuid, char *payload);
-void handleAuthorizeResponse(char *payload, int gun_index);
-void handleBootNotificationResponse(char *payload, int gun_index);
-void handleDataTransferResponse(char *payload, int gun_index);
-void handleDiagnosticsStatusNotificationResponse(char *payload, int gun_index);
-void handleFirmwareStatusNotificationResponse(char *payload, int gun_index);
-void handleHeartbeatResponse(char *payload, int gun_index);
-void handleMeterValuesResponse(char *payload, int gun_index);
-void handleStartTransactionResponse(char *payload, int gun_index);
-void handleStatusNotificationResponse(char *payload, int gun_index);
-void handleStopTransactionnResponse(char *payload, int gun_index);
-
-//==========================================
-// Handle Error routine
-//==========================================
-void handleError(char *id, char *errorCode, char *errorDescription,char *payload);
-
-//===============================================
-// Common routine
-//===============================================
- void getKeyValue(char *keyReq);
- int  setKeyValue(char *key, char *value);
- int updateSetting(char *key, char *value);
-#if 0
- json_object * getJSONfromFile(char *filename);
-#endif
- int httpDownLoadFile(char *location, char *path, char *filename,char *url);
- int ftpDownLoadFile(char *location, char *user, char *password, int port, char *path, char *filename,char *url);
- void *UpdateFirmwareProcess(void* data);
- void* GetDiagnosticsProcess(void* data);
- int ftpFile(char *location, char *user, char *password, int port, char *path, char *fnamePlusPath,char *filename);
- int get_file_contents(const char* filename, char** outbuffer);
- //void Send(struct json_object *message);
- void LWS_Send(char * str);
-extern int queue_operation(int type, char *frontUUID, char *frontData);
-char *GetOcppServerURL();
-char *GetOcppPath();
-int GetOcppPort();
- //===============================================
- // sqlite related routine
- //===============================================
- int SettingChargingRecord(int target, int transactionId);
- int addBuff(int gun_idx, int user_id, int cmd_sn);
- void OCPP_getListVerion();
- int OCPP_cleanLocalList();
- int OCPP_addLocalList(int version, char *idTag, char *parentTage, char *expiryDate, char *status);
- int OCPP_addLocalList_1(int version, char *idTag, char *parentTage, char *expiryDate, char *status);
- void OCPP_getIdTag(char *idTag);
- void OCPP_deleteIdTag(char *idTag);
-
-#endif
+#ifndef MessageHandler_H
+#define MessageHandler_H
+
+struct StructPeriod
+{
+	int		StartPeriod;
+	float 	Limit;//0.1;
+	int		NumberPhases;
+};
+
+struct StructProfile
+{
+	int	Duration;
+	int TotalPeriod;
+	struct StructPeriod	Period[10];
+};
+
+
+//===============================================
+// Common routine
+//===============================================
+int initialConfigurationTable(void);
+
+//==========================================
+// send request routine
+//==========================================
+int sendAuthorizeRequest(int gun_index);
+int sendBootNotificationRequest(void);
+int sendDataTransferRequest(int gun_index);
+int sendDiagnosticsStatusNotificationRequest(char *status);
+int sendFirmwareStatusNotificationRequest(char *status);
+int sendHeartbeatRequest(int gun_index);
+int sendStartTransactionRequest(int gun_index);
+int sendStatusNotificationRequest(int gun_index);
+int sendStopTransactionRequest(int gun_index);
+int sendMeterValuesRequest(int gun_index);
+
+
+//==========================================
+// send confirm routine
+//==========================================
+int sendCancelReservationConfirmation(char *uuid,char *payload);
+int sendChangeAvailabilityConfirmation(char *uuid,char *payload);
+int sendChangeConfigurationConfirmation(char *uuid,char *payload);
+int sendClearCacheConfirmation(char *uuid,char *payload);
+int sendClearChargingProfileConfirmation(char *uuid,char *payload);
+int sendDataTransferConfirmation(char *uuid,char *payload);
+int sendGetCompositeScheduleConfirmation(char *uuid,char *payload, int connectorIdInt,int nPeriod);
+int sendGetConfigurationConfirmation(char *uuid);
+int sendGetDiagnosticsConfirmation(char *uuid,char *payload);
+int sendGetLocalListVersionConfirmation(char *uuid,char *payload);
+int sendRemoteStartConfirmation(char *uuid,char *payload);
+int sendRemoteStopTransactionConfirmation(char *uuid,char *payload);
+int sendReserveNowTransactionConfirmation(char *uuid,char *payload);
+int sendResetConfirmation(char *uuid,char *payload);
+int sendSendLocalListConfirmation(char *uuid,char *payload);
+int sendSetChargingProfileConfirmation(char *uuid,char *payload);
+int sendTriggerMessageConfirmation(char *uuid,char *payload);
+int sendUnlockConnectorConfirmation(char *uuid,char *payload);
+int sendUpdateFirmwareConfirmation(char *uuid);
+//==========================================
+// send CallError routine
+//==========================================
+void SendCallError(char *uniqueId, char *action, char *errorCode, char *errorDescription);
+
+//==========================================
+// Handle server request routine  Start
+//==========================================
+int handleCancelReservationRequest(char *uuid, char *payload);
+int handleChangeAvailabilityRequest(char *uuid, char *payload);
+int handleChangeConfigurationRequest(char *uuid, char *payload);
+int handleClearCacheRequest(char *uuid, char *payload);
+int handleClearChargingProfileRequest(char *uuid, char *payload);
+int handleDataTransferRequest(char *uuid, char *payload);
+//long long diff_tm(struct tm *a, struct tm *b);
+int handleGetCompositeScheduleRequest(char *uuid, char *payload);
+int handleGetConfigurationRequest(char *uuid, char *payload);
+int handleGetDiagnosticsRequest(char *uuid, char *payload);
+int handleGetLocalListVersionRequest(char *uuid, char *payload);
+int handleRemoteStartRequest(char *uuid, char *payload);
+int handleRemoteStopTransactionRequest(char *uuid, char *payload);
+int handleReserveNowTransactionRequest(char *uuid, char *payload);
+int handleResetRequest(char *uuid, char *payload);
+int handleSendLocalListRequest(char *uuid, char *payload);
+int handleSetChargingProfileRequest(char *uuid, char *payload);
+int handleTriggerMessageRequest(char *uuid, char *payload);
+int handleUnlockConnectorRequest(char *uuid, char *payload);
+int handleUpdateFirmwareRequest(char *uuid, char *payload);
+void handleAuthorizeResponse(char *payload, int gun_index);
+void handleBootNotificationResponse(char *payload, int gun_index);
+void handleDataTransferResponse(char *payload, int gun_index);
+void handleDiagnosticsStatusNotificationResponse(char *payload, int gun_index);
+void handleFirmwareStatusNotificationResponse(char *payload, int gun_index);
+void handleHeartbeatResponse(char *payload, int gun_index);
+void handleMeterValuesResponse(char *payload, int gun_index);
+void handleStartTransactionResponse(char *payload, int gun_index);
+void handleStatusNotificationResponse(char *payload, int gun_index);
+void handleStopTransactionnResponse(char *payload, int gun_index);
+
+//==========================================
+// Handle Error routine
+//==========================================
+void handleError(char *id, char *errorCode, char *errorDescription,char *payload);
+
+//===============================================
+// Common routine
+//===============================================
+ void getKeyValue(char *keyReq);
+ int  setKeyValue(char *key, char *value);
+ int updateSetting(char *key, char *value);
+#if 0
+ json_object * getJSONfromFile(char *filename);
+#endif
+ int httpDownLoadFile(char *location, char *path, char *filename,char *url);
+ int ftpDownLoadFile(char *location, char *user, char *password, int port, char *path, char *filename,char *url);
+ void *UpdateFirmwareProcess(void* data);
+ void* GetDiagnosticsProcess(void* data);
+ int ftpFile(char *location, char *user, char *password, int port, char *path, char *fnamePlusPath,char *filename);
+ int get_file_contents(const char* filename, char** outbuffer);
+ //void Send(struct json_object *message);
+ void LWS_Send(char * str);
+extern int queue_operation(int type, char *frontUUID, char *frontData);
+char *GetOcppServerURL();
+char *GetOcppPath();
+int GetOcppPort();
+ //===============================================
+ // sqlite related routine
+ //===============================================
+ int SettingChargingRecord(int target, int transactionId);
+ int addBuff(int gun_idx, int user_id, int cmd_sn);
+ void OCPP_getListVerion();
+ int OCPP_cleanLocalList();
+ int OCPP_addLocalList(int version, char *idTag, char *parentTage, char *expiryDate, char *status);
+ int OCPP_addLocalList_1(int version, char *idTag, char *parentTage, char *expiryDate, char *status);
+ void OCPP_getIdTag(char *idTag);
+ void OCPP_deleteIdTag(char *idTag);
+ void GetChargingProfileRequest(int gunindex);
+#endif

EVSE/Projects/define.h

@@ -3392,6 +3392,19 @@ struct OCPP16Data
 			} bits;
 		} MsMsg;
 
+		union
+		{
+			//Operations triggered by CSU
+			unsigned char CSUMsgValue[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+			struct
+			{
+				//CSUMsgValue[0]
+				unsigned char ChargingProfileReq:1;	//bit 0,
+				unsigned char ChargingProfileConf:1;	//bit 0,
+				unsigned char :6;	//bit 1,2,3,4,5,6,7 , reserved
+			} bits[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+		}CSUMsg;
+
 		struct StructBootNotification 				BootNotification;
 		struct StructHeartbeat					Heartbeat;
 		struct StructAuthorize		 			Authorize;
@@ -3421,8 +3434,7 @@ struct OCPP16Data
 		struct StructUnlockConnector			UnlockConnector[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
 		struct StructUpdateFirmware				UpdateFirmware;
 		struct OCPP16ConfigurationTable			ConfigurationTable;
-		struct StructChargingProfile			CHAdeMOChargingProfile[CHAdeMO_QUANTITY];
-		struct StructChargingProfile		    CcsChargingProfile[CCS_QUANTITY];
+		struct StructChargingProfile		    SmartChargingProfile[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];		
 };
 
 #endif // DEFINE_H_