/*
* Module_LcmControl.c
*
* Created on : 2020-10-20
* Update on : 2022-05-27
* Author : Folus Wen, Eason Yang
* Version : V0.29
*
*/
#include <sys/time.h>
#include "define.h"
#include "main.h"
#include "lcmComm_dgus.h"
#include "cbmp.h"
//=======================================
// Declare share memory
//=======================================
struct SysConfigAndInfo *ShmSysConfigAndInfo;
struct StatusCodeData *ShmStatusCodeData;
struct OCPP16Data *ShmOCPP16Data;
struct OCPP20Data *ShmOCPP20Data;
struct Charger *ShmCharger;
//=======================================
// Declare Basic function
//=======================================
void trim(char *s);
int mystrcmp(char *p1,char *p2);
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt);
uint8_t split(char **arr, char *str, const char *del);
void string2ByteArray(uint8_t *input, uint8_t *output);
//=======================================
// Declare Control panel function
//=======================================
void setRTC();
void setRfidIcon();
void setWifi4GIcon();
void setQRCodeIcon();
void setBackendIcon();
void setQRCodeAlarm();
void setEthernetIcon();
void setCsuRootFsFwRev();
uint8_t getCurrentPage();
void setAlarmCodeAndIcon();
void setPresentSessionFee();
void setPresentParkingFee();
void setBillingFromWebsite();
int isEthConnected(char *eth);
void setUserPrice(uint8_t type);
void setTimeTitle(uint8_t isOn);
void setEnergyTitle(uint8_t isOn);
void setCurrentPage(uint8_t page);
void setPresentFinalCost(float cost);
void setFinalCostTitle(uint8_t isOn);
void setSessionFeeTitle(uint8_t isOn);
void setParkingFeeTitle(uint8_t isOn);
void setTextToEmpty(uint8_t gun_index);
void setWarningStatus(uint8_t gun_index);
void setQRCodeReceipt(uint8_t gun_index);
void setCurrencyFromWebsite(uint8_t unit);
void setPriceFromWebsite(float monry_rate);
void setAuthorizationPage(uint8_t gun_index);
float getPresentFinalCost(uint8_t gun_index);
void setGunPluginAnimation(uint8_t gun_index);
void setPresentChargedgPower(uint8_t gun_index);
void setPlugAndChargeAnimation(uint8_t gun_index);
void setPresentChargedDuration(uint8_t gun_index);
void setPresentPowerConsumption(uint8_t gun_index);
void setFinalCost(uint8_t gun_index, uint8_t type);
void setPresentConnectionTimeout(uint8_t gun_index);
void setRunningCost(uint8_t gun_index, uint8_t type);
void setPressStartButtonAnimation(uint8_t gun_index);
void setDisplayValue(uint16_t address, uint8_t value);
void setDisplayValue2(uint16_t address, uint8_t value);
void setDefaultValue(uint8_t gun_index, uint8_t system_mode);
void setQRcodeContent(char *input, uint8_t length, uint8_t mode);
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode);
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode);
void setPresentChargedEnergy(uint8_t gun_index, uint8_t system_mode);
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type);
void setPrechargingTimerToDefault();
void setPrechargingEnergyToDefault();
void setPrechargingSessionFeeToDefault();
void setPrechargingParkingFeeToDefault();
void setPrechargingCostToDefault();
void setPrechargingPowerToDefault();
void setClearPrechargingValueToEmpty();
//=======================================
// Declare Timer
//=======================================
enum TMR_IDX
{
TMR_IDX_0=0,
TMR_IDX_CONNECTION,
TMR_IDX_PLUGIN,
TMR_IDX_ALARM,
TMR_IDX_PRICE,
TMR_IDX_REFRESH_INFO,
TMR_IDX_STARTBUTTON,
TMR_IDX_7,
TMR_IDX_8,
TMR_IDX_SHOW_AUTH_RESULT
};
struct timespec startTime[AC_QUANTITY][TMR_IDX_SHOW_AUTH_RESULT];
#define TIME_ANIMATION_PLUGIN 1 // Unit: Second
#define TIME_ANIMATION_BATTERY 1 // Unit: Second
#define TIME_ANIMATION_CONNECTION 1 // Unit: Second
#define TIME_ANIMATION_START_PRESS 1 // Unit: Second
#define TIME_ANIMATION_ALARM 5 // Unit: Second
#define TIME_REFRESH_TIME 5 // Unit: Second
#define TIME_AUTH_RESULT_TIME 5 // Unit: Second
#define TIME_REFRESH_INFO 3 // Unit: Second
#define is_error(ptr) ((unsigned long)ptr > (unsigned long)-4000L)
//=======================================
// Declare Variable
//=======================================
uint8_t CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
uint8_t GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
uint8_t START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_0;
uint8_t WarningCount = 255;
int Uart1Fd;
//=======================================
// Record version and date
//=======================================
char *FIRMWARE_UPDATE_IMAGE[3] = {"V0.29", "2022-05-27", "REV.03.00"};
//=======================================
// Common routine
//=======================================
int StoreLogMsg(const char *fmt, ...)
{
char Buf[4096+256];
char buffer[4096];
time_t CurrentTime;
struct tm *tm;
struct timeval tv;
va_list args;
va_start(args, fmt);
int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
va_end(args);
memset(Buf,0,sizeof(Buf));
CurrentTime = time(NULL);
tm=localtime(&CurrentTime);
gettimeofday(&tv, NULL); // get microseconds, 10^-6
sprintf(Buf,"echo -n \'[%04d.%02d.%02d %02d:%02d:%02d.%06ld]%s\' >> /Storage/SystemLog/[%04d.%02d]Module_LcmControlLog",
tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,tv.tv_usec,
buffer,
tm->tm_year+1900,tm->tm_mon+1);
#ifdef SystemLogMessage
system(Buf);
#endif
#ifdef ConsloePrintLog
printf("[%04d.%02d.%02d %02d:%02d:%02d.%06ld]%s", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,tv.tv_usec, buffer);
#endif
return rc;
}
void refreshStartTimer(struct timespec *timer)
{
clock_gettime(CLOCK_MONOTONIC, timer);
}
int getDiffSecNow(struct timespec timer)
{
struct timespec timerNow;
clock_gettime(CLOCK_MONOTONIC, &timerNow);
return (int)((((unsigned long)(timerNow.tv_sec - timer.tv_sec) * 1000) + ((unsigned long)((timerNow.tv_nsec / 1000000) - (timer.tv_nsec / 1000000))))/1000);
}
int getDiffSecBetween(struct timespec start, struct timespec end)
{
return (int)((((unsigned long)(end.tv_sec - start.tv_sec) * 1000) + ((unsigned long)((end.tv_nsec / 1000000) - (start.tv_nsec / 1000000))))/1000);
}
long long DiffTimebWithNow(struct timeb ST)
{
//return milli-second
struct timeb ET;
long long StartTime,StopTime;
ftime(&ET);
StartTime=(long long)ST.time;
StopTime=(long long)ET.time;
return ((StopTime-StartTime)*1000) + (ET.millitm-ST.millitm);
}
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;
}
void trim(char *s)
{
int i=0, j, k, l=0;
while((s[i]==' ')||(s[i]=='\t')||(s[i]=='\n'))
i++;
j = strlen(s)-1;
while((s[j]==' ')||(s[j]=='\t')||(s[j]=='\n'))
j--;
if(i==0 && j==strlen(s)-1) { }
else if(i==0) s[j+1] = '\0';
else {
for(k=i; k<=j; k++) s[l++] = s[k];
s[l] = '\0';
}
}
void trim_string(char *s, unsigned char len)
{
for(unsigned char i = 0 ; i < len; i++)
{
if (!(s[i] =='.')&& !((s[i]>='0') && (s[i]<='9')))
{
s[i] = s[i + 1];
strncpy(s + i, s + i + 1, len);
i -= 1;
len -= 1;
}
}
s[len + 1] = '\0';
}
int mystrcmp(char *p1,char *p2)
{
while(*p1==*p2)
{
if(*p1=='\0' || *p2=='\0')
break;
p1++;
p2++;
}
if(*p1=='\0' && *p2=='\0')
return(PASS);
else
return(FAIL);
}
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt)
{
strncpy(dest, src + start, cnt);
dest[cnt] = 0;
}
uint8_t split(char **arr, char *str, const char *del)
{
uint8_t result = 0;
char *s = strtok(str, del);
while(s != NULL)
{
*arr++ = s;
result += 1;
s = strtok(NULL, del);
}
return result;
}
void getDateTimeString(char* result)
{
struct ParsingResult
{
int scanedElement;
int tz_hour;
int tz_min;
}timeOffset;
time_t CurrentTime;
struct tm *tmOrg;
struct tm *tmTarget;
struct timeb tbTarget;
CurrentTime = time(NULL);
tmOrg=localtime(&CurrentTime);
tmOrg->tm_gmtoff = 0;
tbTarget.time = mktime(tmOrg);
tbTarget.timezone = 0;
if((timeOffset.scanedElement = sscanf((char*)ShmOCPP16Data->ConfigurationTable.CoreProfile[TimeOffset].ItemData, "%d:%d", &timeOffset.tz_hour, &timeOffset.tz_min)) == 2)
{
tbTarget.time += (timeOffset.tz_hour*3600) + (timeOffset.tz_min*60*(timeOffset.tz_hour>=0?1:-1));
}
tmTarget = gmtime(&tbTarget.time);
//sprintf(result, "%04d/%02d/%02d %02d:%02d", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min);
//sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,(tmTarget->tm_hour%12),tmTarget->tm_min,((tmTarget->tm_hour/12)>0?"p.m":"a.m"));
if((tmTarget->tm_hour%12) == 0)
sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,((tmTarget->tm_hour%12)==0?12:(tmTarget->tm_hour%12)),tmTarget->tm_min,((tmTarget->tm_hour/12)==1?"p.m.":"a.m."));
else
sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,(tmTarget->tm_hour%12),tmTarget->tm_min,((tmTarget->tm_hour/12)>0?"p.m.":"a.m."));
}
//======================================================
// OCPP routine
//======================================================
uint8_t ocpp_get_isRemoteStartWait()
{
uint8_t result = OFF;
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
result = ShmOCPP16Data->MsMsg.bits.isRemoteStartWaitReq;
}
else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
{
result = ShmOCPP20Data->MsMsg.bits.isRemoteStartWaitReq;
}
return result;
}
//=======================================
// Function to page routine
//=======================================
void page_booting()
{
if(getCurrentPage() != SYSTEM_SCREEN_BOOTING)
{
setCurrentPage(SYSTEM_SCREEN_BOOTING);
DEBUG_INFO("Setting page to booting.\n");
}
else
{
setClearPrechargingValueToEmpty();
}
}
void page_idle(uint8_t gun_index, uint8_t system_mode)
{
setPrechargingTimerToDefault();
setPrechargingEnergyToDefault();
setPrechargingSessionFeeToDefault();
setPrechargingParkingFeeToDefault();
setPrechargingCostToDefault();
setPrechargingPowerToDefault();
if(ocpp_get_isRemoteStartWait())
{
if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
{
setCurrentPage(SYSTEM_SCREEN_PREPARING);
DEBUG_INFO("Setting page to preparing.\n");
DEBUG_INFO("Remote Start Transaction without connector Id.\n");
}
else
{
setPresentConnectionTimeout(gun_index);
setConnectionAnimation(gun_index, system_mode);
setGunPluginAnimation(gun_index);
}
}
else
{
if(ShmCharger->gun_info[gun_index].isSleepOn == YES)
{
if((getCurrentPage() != SYSTEM_SCREEN_SLEEP))
{
setCurrentPage(SYSTEM_SCREEN_SLEEP);
setPressStartButtonAnimation(gun_index);
START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_0;
}
else
{
setPressStartButtonAnimation(gun_index);
}
}
else
{
if(ShmCharger->gun_info[gun_index].isCheckPowerConsumption == YES)
{
setCurrentPage(SYSTEM_SCREEN_POWER_CONSUMPTION);
setDisplayValue(ICON_POWER_CONSUMPTION, APPEAR);
setPresentPowerConsumption(gun_index);
setCsuRootFsFwRev();
}
else
{
if(ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
{
if((getCurrentPage() != SYSTEM_SCREEN_PLUG_AND_CHARGE))
{
setCurrentPage(SYSTEM_SCREEN_PLUG_AND_CHARGE);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to plug and charge.\n");
}
else
{
setPlugAndChargeAnimation(gun_index);
}
}
else
{
if((ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID && (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)) &&
(ShmCharger->isCcsEnable) &&
(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) &&
(ShmCharger->gun_info[gun_index].isGetEvCCIDTimeout == OFF) &&
(ShmCharger->gun_info[gun_index].resultAuthorization != VALIDATED_RFID) &&
(ShmCharger->gun_info[gun_index].isRemoteStartWait != ON) &&
(ShmCharger->gun_info[gun_index].isEvCCIDAuthorizeFail != YES))
{
if((getCurrentPage() != SYSTEM_SCREEN_PREPARE_FOR_EVSE))
{
setCurrentPage(SYSTEM_SCREEN_PREPARE_FOR_EVSE);
DEBUG_INFO("Setting page to EVCCID. \n");
}
else
{
setConnectionAnimation(gun_index, system_mode);
}
}
else
{
if((getCurrentPage() != SYSTEM_SCREEN_IDLE) && (ShmCharger->gun_info[gun_index].resultAuthorization != VALIDATED_RFID))
{
setCurrentPage(SYSTEM_SCREEN_IDLE);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to idle.\n");
}
else
{
setRfidIcon();
setQRCodeIcon();
setConnectionAnimation(gun_index, system_mode);
}
}
}
}
}
}
}
void page_authorizing(uint8_t gun_index)
{
setAuthorizationPage(gun_index);
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
{
setUserPrice(ACCOUNT_BALANCE);
}
else
{
setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
}
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
}
}
void page_preparing(uint8_t gun_index, uint8_t system_mode)
{
if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
{
if((getCurrentPage() != SYSTEM_SCREEN_PREPARE_FOR_EVSE))
{
setCurrentPage(SYSTEM_SCREEN_PREPARE_FOR_EVSE);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to prepare for EVSE.\n");
}
else
{
setPrechargingTimerToDefault();
setPrechargingEnergyToDefault();
setPrechargingSessionFeeToDefault();
setPrechargingParkingFeeToDefault();
setPrechargingCostToDefault();
setPrechargingPowerToDefault();
setConnectionAnimation(gun_index, system_mode);
setPresentChargedEnergy(gun_index, system_mode);
}
}
else
{
if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
{
setCurrentPage(SYSTEM_SCREEN_PREPARING);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to preparing.\n");
}
else
{
setPresentConnectionTimeout(gun_index);
setConnectionAnimation(gun_index, system_mode);
setGunPluginAnimation(gun_index);
setPresentChargedEnergy(gun_index, system_mode);
}
}
}
void page_charging(uint8_t gun_index, uint8_t system_mode)
{
static char runningCost[1024] = {0};
if((getCurrentPage() != SYSTEM_SCREEN_CHARGING) && (!ShmCharger->isAuthrizing && !ShmCharger->isGetAuthResult))
{
setCurrentPage(SYSTEM_SCREEN_CHARGING);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to charging.\n");
}
else
{
setConnectionAnimation(gun_index, system_mode);
setPresentChargedDuration(gun_index);
setPresentChargedgPower(gun_index);
setTimeTitle(ON);
setEnergyTitle(ON);
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
{
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// Title disappear
setSessionFeeTitle(OFF);
setParkingFeeTitle(OFF);
setFinalCostTitle(OFF);
}
}
if((getDiffSecNow(startTime[gun_index][TMR_IDX_REFRESH_INFO]) >= TIME_REFRESH_INFO) || (strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description, runningCost) != 0))
{
setPresentChargedEnergy(gun_index, system_mode);
memcpy((char*) runningCost,(char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description,ARRAY_SIZE(ShmOCPP16Data->Cost.RunningCost[gun_index].description));
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
setRunningCost(gun_index, TOTAL_COST);
setRunningCost(gun_index, SESSION_FEE);
setRunningCost(gun_index, OCCUPANCY_FEE);
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
{
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
setPresentFinalCost(getPresentFinalCost(gun_index));
//setPresentSessionFee();
setPresentParkingFee();
}
else
{
// Total cost disappear
setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);
// Session fee disappear
setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);
// Parking fee disappear
setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);
// User account balance disappear
setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
}
}
refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
}
}
}
void page_complete(uint8_t gun_index, uint8_t system_mode)
{
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON))
{
if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
{
setCurrentPage(SYSTEM_SCREEN_COMPLETE);
DEBUG_INFO("Setting page to complete.\n");
}
else
{}
}
else
{
if((strcmp((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL,"") == 0))
{
if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
{
setCurrentPage(SYSTEM_SCREEN_COMPLETE);
DEBUG_INFO("Setting page to complete.\n");
}
else
{}
}
else
{
if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE_WITH_QRCODE)
{
setCurrentPage(SYSTEM_SCREEN_COMPLETE_WITH_QRCODE);
setQRCodeReceipt(gun_index);
DEBUG_INFO("Setting page to complete with receipt qr code.\n");
}
else
{
setQRCodeReceipt(gun_index);
}
}
}
setPresentChargedDuration(gun_index);
setPresentChargedEnergy(gun_index, system_mode);
setTimeTitle(ON);
setEnergyTitle(ON);
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
setFinalCost(gun_index, TOTAL_COST);
setFinalCost(gun_index, SESSION_FEE);
setFinalCost(gun_index, OCCUPANCY_FEE);
setFinalCost(gun_index, ACCOUNT_BALANCE);
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
{
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
setPresentFinalCost(getPresentFinalCost(gun_index));
//setPresentSessionFee();
setPresentParkingFee();
setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// Total cost disappear
setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);
// Session fee disappear
setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);
// Parking fee disappear
setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);
// User account balance disappear
setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
// Title disappear
setSessionFeeTitle(OFF);
setParkingFeeTitle(OFF);
setFinalCostTitle(OFF);
}
}
}
void page_terminating(uint8_t gun_index, uint8_t system_mode)
{
if((getCurrentPage() != SYSTEM_SCREEN_TERMINATING) && (!ShmCharger->isAuthrizing && !ShmCharger->isGetAuthResult))
{
setCurrentPage(SYSTEM_SCREEN_TERMINATING);
setDefaultValue(gun_index, system_mode);
DEBUG_INFO("Setting page to terminating.\n");
}
else
{
setPresentChargedDuration(gun_index);
setPresentChargedEnergy(gun_index, system_mode);
setPresentChargedgPower(gun_index);
setTimeTitle(ON);
setEnergyTitle(ON);
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
setRunningCost(gun_index, TOTAL_COST);
setRunningCost(gun_index, SESSION_FEE);
setRunningCost(gun_index, OCCUPANCY_FEE);
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
{
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
setPresentFinalCost(getPresentFinalCost(gun_index));
//setPresentSessionFee();
setPresentParkingFee();
// Title appear
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
}
else
{
// Total cost disappear
setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);
// Session fee disappear
setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);
// Parking fee disappear
setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);
// User account balance disappear
setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
// Title disappear
setSessionFeeTitle(OFF);
setParkingFeeTitle(OFF);
setFinalCostTitle(OFF);
}
}
}
}
void page_alarm()
{
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip != ON)
{
if(getCurrentPage() != SYSTEM_SCREEN_ALARM)
{
setCurrentPage(SYSTEM_SCREEN_ALARM);
setQRCodeAlarm();
DEBUG_INFO("Setting page to alarm.\n");
}
else
{
setQRCodeAlarm();
}
}
else
{
if(getCurrentPage() != SYSTEM_SCREEN_EMERGENCY)
{
setCurrentPage(SYSTEM_SCREEN_EMERGENCY);
DEBUG_INFO("Setting page to emergency.\n");
}
else
{}
}
}
void page_fault()
{
//DEBUG_INFO("Page fault.\n");
}
void page_maintain()
{
if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
{
setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
DEBUG_INFO("Setting page to maintain.\n");
}
else
{}
}
void page_update()
{
if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
{
setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
DEBUG_INFO("Setting page to update.\n");
}
else
{}
}
void page_reservation()
{
//DEBUG_INFO("Page reservation.\n");
}
void page_booking()
{
//DEBUG_INFO("Page booking.\n");
}
void page_debug()
{
if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
{
setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
DEBUG_INFO("Setting page to debug.\n");
}
else
{}
}
void page_unknown()
{
//DEBUG_INFO("Page unknown.\n");
}
void page_header(uint8_t gun_index, uint8_t system_mode)
{
setEthernetIcon();
setBackendIcon();
setWifi4GIcon();
setWarningStatus(gun_index);
// CHANGE LCD BRIGHNESS ( POWER SAVING MODE )
if((ShmCharger->isLcdOn == ON))
setDisplayValue(REG_ADDRESS_WRITE_BRIGHTNESS,BRIGHTNESS_100);
else
setDisplayValue(REG_ADDRESS_WRITE_BRIGHTNESS,BRIGHTNESS_10);
// SET BILLING
if((ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON) && (ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON))
{
setBillingFromWebsite();
setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
}
else
{
// EVERY 5 SECONDS TO UPDATE PRICE
if(getDiffSecNow(startTime[gun_index][TMR_IDX_PRICE]) > (TIME_REFRESH_TIME))
{
refreshStartTimer(&startTime[gun_index][TMR_IDX_PRICE]);
setBillingFromBackend(gun_index, system_mode);
}
}
}
void page_footer()
{
setRTC();
}
//=======================================
// Setting icon display value
//=======================================
void setDisplayValue(uint16_t address, uint8_t value)
{
uint8_t data[2];
data[0] = value >> 8;
data[1] = value & 0X00FF;
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, address, data, ARRAY_SIZE(data));
}
void setDisplayValue2(uint16_t address, uint8_t value)
{
uint8_t data[4];
data[0] = value >> 8;
data[1] = value & 0X00FF;
data[2] = 0xFF;
data[3] = 0xFF;
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), data, ARRAY_SIZE(data));
}
//=======================================
// Getting current page
//=======================================
uint8_t getCurrentPage()
{
uint8_t currentPage[2];
uint8_t result = 255;
if(lcdRegisterRead(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_READ_PAGE_ID, currentPage, ARRAY_SIZE(currentPage)))
{
result = currentPage[1];
// DEBUG_INFO("currentPage[0] : %X\n", currentPage[0]);
// DEBUG_INFO("currentPage[1] : %X\n", currentPage[1]);
// DEBUG_INFO("Getting current page : [%d] \n", result);
}
else
{
DEBUG_INFO("Getting current page fail! \n");
}
return result;
}
//=======================================
// Setting current page
//=======================================
void setCurrentPage(uint8_t page)
{
uint8_t settingPage[2] = {0x00, page};
if(lcdRegisterWrite(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_SET_PAGE_ID, settingPage, ARRAY_SIZE(settingPage)))
{
if((ShmCharger->gun_info[0].isSleepOn == YES) || (ShmCharger->gun_info[1].isSleepOn == YES))
{
}
else
{
DEBUG_INFO("Setting current page to : [%d] \n", page);
}
}
else
{
DEBUG_INFO("Setting current page fail! \n");
}
}
//=======================================
// Convert string to byte array
//=======================================
void string2ByteArray(unsigned char *input, uint8_t *output)
{
int loop;
int i;
loop = 0;
i = 0;
while(input[loop] != '\0')
{
output[i++] = input[loop++];
}
output[loop] = '\0';
}
//=======================================
// Setting [ RFID ] Icon Status
//=======================================
void setRfidIcon()
{
if(ShmSysConfigAndInfo->SysConfig.isRFID == ON)
setDisplayValue(ICON_RFID, RFID_ENABLE);
else
setDisplayValue(ICON_RFID, RFID_DISABLE);
}
//========================================
// Setting [ BACKEND ] Icon Status
//========================================
void setBackendIcon()
{
if(ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON)
setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_OFFLINE);
else
setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_ONLINE);
}
//========================================
// Setting [ ETHERNET ] Icon Status
//========================================
void setEthernetIcon()
{
char ethernet [16];
strcpy((char*)ethernet, "eth0");
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet == ON)
{
if(isEthConnected(ethernet) == YES)
setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_CONNECTED_WITHOUT_INTERNET);
else
setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_DISCONNECTED_INTERNET);
}
else
{
setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_CONNECTED_INTERNET);
}
}
//=======================================
// Setting [ WIFI / 4G] icon status
//=======================================
void setWifi4GIcon()
{
// SET WIFI + 4G ICON STATUS ( ONLINE OR OFFLINE )
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
{
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == DISABLE_WIFI)
{
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
{
setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
}
else
{
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
// 4G Internet connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
{
// 4G APN connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
else
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
}
else
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_INTERNET);
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_STATION)
{
// Wifi Internet connection status: Connected = OFF / Disconnected = ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
{
// Wifi Access point connection status: Connected = OFF / Disconnected = ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApDisconnectViaWiFi == ON)
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_DISCONNECTED_INTERNET);
else
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
}
else
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_INTERNET);
}
else if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_ACCESS_POINT)
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
else
setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
else
{
// 4G Internet connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
{
// 4G APN connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
setDisplayValue(ICON_4G_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
else
setDisplayValue(ICON_4G_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
}
else
setDisplayValue(ICON_4G_CONNECTION, TELECOM_CONNECTED_INTERNET);
}
}
}
else if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'E')
{
setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
}
else
{
// SET 4G ICON STATUS ( ONLINE OR OFFLINE )
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T')
{
switch(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled)
{
case DISABLE_4G:
setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
break;
case ENABLE_4G:
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
// 4G Internet connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
{
// 4G APN connection status: Connected: OFF / Disconnected: ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
else
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
}
else
setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_INTERNET);
break;
default:
break;
}
}
// SET WIFI ICON STATUS ( ONLINE OR OFFLINE)
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
{
switch(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode)
{
case DISABLE_WIFI:
setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
break;
case WIFI_STATION:
setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
// Wifi Internet connection status: Connected = OFF / Disconnected = ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
{
// Wifi Access point connection status: Connected = OFF / Disconnected = ON
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApDisconnectViaWiFi == ON)
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_DISCONNECTED_INTERNET);
else
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
}
else
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_INTERNET);
break;
case WIFI_ACCESS_POINT:
setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
break;
default:
break;
}
}
}
}
//========================================
// Setting [ RTC ] value
//========================================
void setRTC()
{
uint8_t data[32];
uint8_t rtc[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(rtc, 0x00, ARRAY_SIZE(rtc));
getDateTimeString((char*)rtc);
string2ByteArray(rtc, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_RTC, data, ARRAY_SIZE(data));
}
//=======================================
// Setting [ Billing ] ( WEB PAGE )
//=======================================
void setBillingFromWebsite()
{
struct timeb csuTime;
struct tm *tmCSU;
ftime(&csuTime);
tmCSU = localtime(&csuTime.time);
setDisplayValue(ICON_PRICE, APPEAR);
if(tmCSU->tm_hour <= 23)
{
ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = ShmSysConfigAndInfo->SysConfig.BillingData.Fee[tmCSU->tm_hour];
setPriceFromWebsite(ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee);
}
// CURRENCY UNIT ( 53 COUNTRIES )
if(ShmSysConfigAndInfo->SysConfig.BillingData.Currency <= 53)
{
setCurrencyFromWebsite(ShmSysConfigAndInfo->SysConfig.BillingData.Currency);
}
}
//=======================================
// Setting [ Currency ] ( WEB PAGE )
//=======================================
void setCurrencyFromWebsite(uint8_t unit)
{
uint8_t data[16];
uint8_t currency[16];
unsigned char kWh [16];
uint8_t final_currency[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(currency, 0x00, ARRAY_SIZE(currency));
memset(final_currency, 0x00, ARRAY_SIZE(final_currency));
strcpy((char*)kWh, "/kWh");
memcpy((char*)currency, Currency[unit], 3);
sprintf((char *)final_currency, "%s%s", currency,kWh);
string2ByteArray(final_currency, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CURRENCY_UNIT, data, ARRAY_SIZE(data));
}
//=======================================
// Setting [ Price ] ( WEB PAGE )
//=======================================
void setPriceFromWebsite(float monry_rate)
{
uint8_t data[16];
uint8_t price[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(price, 0x00, ARRAY_SIZE(price));
sprintf((char *)price, "%.2f", monry_rate);
string2ByteArray(price, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRICE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting [ Final Cost ] ( WEB PAGE )
//=======================================
void setPresentFinalCost(float cost)
{
uint8_t data[32];
uint8_t finalCost[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(finalCost, 0x00, ARRAY_SIZE(finalCost));
sprintf((char *)finalCost, "$ %.2f", cost);
string2ByteArray(finalCost, data);
// Total Cost
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, data, ARRAY_SIZE(data));
// Session Fee
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting [ Session Fee ] ( WEB PAGE )
//=======================================
void setPresentSessionFee()
{
uint8_t data[32];
uint8_t sessionFee[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(sessionFee, 0x00, ARRAY_SIZE(sessionFee));
strcpy((char*)sessionFee, "$ -----");
string2ByteArray(sessionFee, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting [ Parking Fee ] ( WEB PAGE )
//=======================================
void setPresentParkingFee()
{
uint8_t data[32];
uint8_t parkingFee[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(parkingFee, 0x00, ARRAY_SIZE(parkingFee));
strcpy((char*)parkingFee, "$ -----");
string2ByteArray(parkingFee, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, data, ARRAY_SIZE(data));
}
//=======================================
// Getting [ Final cost ] ( WEB PAGE )
//=======================================
float getPresentFinalCost(uint8_t gun_index)
{
float result = 0.0f;
for(int idx=0;idx<ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].presentChargedEnergyPeriod);idx++)
{
result += ((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].presentChargedEnergyPeriod[idx]) * ShmSysConfigAndInfo->SysConfig.BillingData.Fee[idx]);
}
return result;
}
//=======================================
// Setting [ Billing ] ( BACKEND )
//=======================================
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode)
{
if((system("pidof -s OcppBackend > /dev/null") != 0))
{
setDisplayValue(ICON_PRICE, DISAPPEAR);
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
}
else
{
if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if((strcmp((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData,"") != 0))
{
if(system_mode == SYS_MODE_IDLE)
{
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue(ICON_PRICE, APPEAR);
setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, DEFAULE_PRICE);
}
else
{
/*
* 1. IF STARTUSERID IS NOT MATCH WITH IDTOKEN ALSO VALUE CAN'T BE NULL, OTHERWISE THE SYSTEM MUST USE DEFAULT PRICE
*/
if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
{
setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, SET_USER_PRICE);
}
else
{
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue(ICON_PRICE, APPEAR);
setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, DEFAULE_PRICE);
}
}
}
else
{
if(system_mode == SYS_MODE_IDLE)
{
setDisplayValue(ICON_PRICE, DISAPPEAR);
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
}
else
{
if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
{
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue(ICON_PRICE, APPEAR);
setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, SET_USER_PRICE);
}
else
{
setDisplayValue(ICON_PRICE, DISAPPEAR);
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
}
}
}
}
else
{
// DISPLAY BY OCPP 2.0.1
}
}
else
{
setDisplayValue(ICON_PRICE, DISAPPEAR);
setDisplayValue(TEXT_PRICE, DISAPPEAR);
setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
}
}
}
//=======================================
// Setting [ UserPrice ] ( BACKEND )
//=======================================
void setUserPrice(uint8_t type)
{
uint8_t length;
uint8_t output_data[32];
char input_data[32];
char tmp[256];
char *splitString[10];
const char *Symbol = ";";
memset(tmp, 0, ARRAY_SIZE(tmp));
memset(input_data, 0x00, ARRAY_SIZE(input_data));
memset(output_data, 0x00, ARRAY_SIZE(output_data));
switch(type)
{
case CONNECTION_FEE:
break;
case CURRENT_RATE:
if(strstr((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Current Rate:") > 0)
{
// APPEAR PRICE ICON
setDisplayValue(ICON_PRICE, APPEAR);
// APPEAR PRICE TEXT
strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
split((char**)splitString, tmp, Symbol);
memcpy(input_data, splitString[1], strlen(splitString[1]));
length = strlen(input_data);
trim_string(input_data,length);
memcpy(output_data ,input_data, strlen(input_data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRICE, output_data, ARRAY_SIZE(output_data));
}
else
{
// DISAPPEAR PRICE ICON AND PRICE TEXT
setDisplayValue(ICON_PRICE, DISAPPEAR);
setDisplayValue(TEXT_PRICE, DISAPPEAR);
}
break;
case OCCUPANCY_FEE:
break;
case ACCOUNT_BALANCE:
if(strstr((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Account Balance:") > 0)
{
// APPEAR ACCOUNT BALANCE ICON
setDisplayValue(ICON_USER_ACCOUNT_BALANCE, APPEAR);
// APPEAR ACCOUNT BALANCE TEXT
strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
split((char**)splitString, tmp, Symbol);
memcpy(input_data, splitString[3], strlen(splitString[3]));
length = strlen(input_data);
trim_string(input_data,length);
memcpy(output_data ,input_data, strlen(input_data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
}
else
{
// DISAPPEAR BALANCE ICON AND BALANCE TEXT
setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
}
break;
default:
break;
}
}
//=======================================
// Setting [ FinalCost ] ( BACKEND )
//=======================================
void setFinalCost(uint8_t gun_index, uint8_t type)
{
uint8_t output_data[32];
unsigned char cost_empty[32];
unsigned char balance_empty[32];
unsigned char session_empty[32];
unsigned char occupancy_empty[32];
json_object *jsonDescription;
memset(output_data, 0x00, ARRAY_SIZE(output_data));
memset(balance_empty, 0x00, ARRAY_SIZE(balance_empty));
memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));
memset(session_empty, 0x00, ARRAY_SIZE(session_empty));
memset(occupancy_empty, 0x00, ARRAY_SIZE(occupancy_empty));
switch(type)
{
case CONNECTION_FEE:
break;
case SESSION_FEE:
if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
strcpy((char*)session_empty, "$ -----");
string2ByteArray(session_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
}
else
{
double chargingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
{
chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
}
if(chargingCost> 0)
sprintf((char*)output_data, "$ %.2f", chargingCost);
else
sprintf((char*)output_data, "$ -----");
// APPEAR COST ICON
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case OCCUPANCY_FEE:
if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
strcpy((char*)occupancy_empty, "$ -----");
string2ByteArray(occupancy_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
}
else
{
double parkingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
{
parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
}
if(parkingCost > 0)
sprintf((char*)output_data, "$ %.2f", parkingCost);
else
sprintf((char*)output_data, "$ -----");
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case TOTAL_COST:
if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
strcpy((char*)cost_empty, "$ -----");
string2ByteArray(cost_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
}
else
{
double chargingCost = 0;
double parkingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
{
chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
}
if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
{
parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
}
if((chargingCost + parkingCost) > 0)
sprintf((char*)output_data, "$ %.2f", (chargingCost + parkingCost));
else
sprintf((char*)output_data, "$ -----");
// APPEAR COST ICON
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case ACCOUNT_BALANCE:
if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
{
setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);
strcpy((char*)balance_empty, "$ -----");
string2ByteArray(balance_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
}
else
{
double accountBalance = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"accountBalance") != NULL)
{
accountBalance += json_object_get_double(json_object_object_get(jsonDescription,"accountBalance"));
}
if(accountBalance > 0)
sprintf((char*)output_data, "$ %.2f", accountBalance);
else
sprintf((char*)output_data, "$ -----");
// APPEAR COST ICON
setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
default:
break;
}
}
//=======================================
// Setting [ RunningCost ] ( BACKEND )
//=======================================
void setRunningCost(uint8_t gun_index, uint8_t type)
{
uint8_t output_data[32];
unsigned char cost_empty[32];
unsigned char session_empty[32];
unsigned char occupancy_empty[32];
json_object *jsonDescription;
memset(output_data, 0x00, ARRAY_SIZE(output_data));
memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));
memset(session_empty, 0x00, ARRAY_SIZE(session_empty));
memset(occupancy_empty, 0x00, ARRAY_SIZE(occupancy_empty));
switch(type)
{
case CONNECTION_FEE:
break;
case SESSION_FEE:
if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
strcpy((char*)session_empty, "$ -----");
string2ByteArray(session_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
}
else
{
double chargingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
{
chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
}
if(chargingCost> 0)
sprintf((char*)output_data, "$ %.2f", chargingCost);
else
sprintf((char*)output_data, "$ -----");
// APPEAR COST ICON
setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case OCCUPANCY_FEE:
if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
strcpy((char*)occupancy_empty, "$ -----");
string2ByteArray(occupancy_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
}
else
{
double parkingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
{
parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
}
if(parkingCost > 0)
sprintf((char*)output_data, "$ %.2f", parkingCost);
else
sprintf((char*)output_data, "$ -----");
setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case TOTAL_COST:
if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
{
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
strcpy((char*)cost_empty, "$ -----");
string2ByteArray(cost_empty, output_data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
}
else
{
double chargingCost = 0;
double parkingCost = 0;
jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);
if(!is_error(jsonDescription))
{
if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
{
chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
}
if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
{
parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
}
if((chargingCost + parkingCost) > 0)
sprintf((char*)output_data, "$ %.2f", (chargingCost + parkingCost));
else
sprintf((char*)output_data, "$ -----");
// APPEAR COST ICON
setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
}
json_object_put(jsonDescription);
}
break;
case ACCOUNT_BALANCE:
break;
default:
break;
}
}
//=======================================
// Setting QRCODE icon status
//=======================================
void setQRCodeIcon()
{
uint8_t length = 0;
if(ShmSysConfigAndInfo->SysConfig.isQRCode == ON)
{
setDisplayValue(ICON_QR_CODE,QRCODE_ENABLE);
if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
{
length = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.SystemId, length, QRCODE_FOR_IDLE);
}
else
{
length = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, length, QRCODE_FOR_IDLE);
}
}
else
{
setDisplayValue(TEXT_QRCODE_CONTENT, DISAPPEAR);
setDisplayValue(ICON_QR_CODE,QRCODE_DISABLE);
}
}
//=======================================
// Setting QRCODE icon for receipt
//=======================================
void setQRCodeReceipt(uint8_t gun_index)
{
uint8_t length = 0;
uint8_t data[512];
int TransactionId;
unsigned char QRCodeContent[512];
unsigned char QRCodeReceipt[512];
memset(QRCodeContent, 0x00, ARRAY_SIZE(QRCodeContent));
memset(QRCodeReceipt, 0x00, ARRAY_SIZE(QRCodeReceipt));
memset(data, 0x00, ARRAY_SIZE(data));
memcpy((char*)QRCodeContent, (char*)ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL));
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
TransactionId = ShmOCPP16Data->StopTransaction[gun_index].TransactionId;
}
else
{
// TO DO OCPP 2.0
}
sprintf((char *)QRCodeReceipt, "%s%d", QRCodeContent,TransactionId);
string2ByteArray(QRCodeReceipt, data);
length = strlen((char *)data);
setQRcodeContent((char *)data, length, QRCODE_FOR_COMPLETE);
}
//=======================================
// Setting QRCODE for alarm
//=======================================
void setQRCodeAlarm()
{
uint8_t length = 0;
uint8_t data[512];
unsigned char QRCodeAlarm[512];
memset(QRCodeAlarm, 0x00, ARRAY_SIZE(QRCodeAlarm));
memset(data, 0x00, ARRAY_SIZE(data));
sprintf((char *)QRCodeAlarm, "%s", "https://evsc.phihong.com.tw/");
string2ByteArray(QRCodeAlarm, data);
length = strlen((char *)data);
setQRcodeContent((char *)data, length, QRCODE_FOR_ALARM);
}
//=======================================
// Setting QR code content
//=======================================
void setQRcodeContent(char *input, uint8_t length, uint8_t mode)
{
uint8_t output[length];
int loop = 0;
input[length] = '\0';
output[length] = '\0';
while(input[loop] != '\0')
{
output[loop] = input[loop];
loop++;
}
switch(mode)
{
case QRCODE_FOR_IDLE:
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_CONTENT, output, ARRAY_SIZE(output)+1);
break;
case QRCODE_FOR_COMPLETE:
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_RECEIPT, output, ARRAY_SIZE(output)+1);
break;
case QRCODE_FOR_ALARM:
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_ALARM, output, ARRAY_SIZE(output)+1);
break;
default:
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_CONTENT, output, ARRAY_SIZE(output)+1);
break;
}
}
//=======================================
// Setting warning page switch
//=======================================
void setWarningStatus(uint8_t gun_index)
{
/*
* 1. WARNING COUNT IS DIFFERENT BETWEEN BEGINNING CHANGE DISPLAY
* 2. WARNING COUNT BIGGER THAN 4 AND EVERY 5 SECONDS CHANGE NEXT PAGE
*/
if(WarningCount != ShmSysConfigAndInfo->SysWarningInfo.WarningCount)
{
WarningCount = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;
setAlarmCodeAndIcon();
}
else if((ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 4) && (getDiffSecNow(startTime[gun_index][TMR_IDX_ALARM]) > (TIME_ANIMATION_ALARM)))
{
refreshStartTimer(&startTime[gun_index][TMR_IDX_ALARM]);
if(ShmSysConfigAndInfo->SysWarningInfo.PageIndex == 0)
{
ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 1;
}
else
{
ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;
}
setAlarmCodeAndIcon();
}
}
//=======================================
// Setting alarm code and icon status
//=======================================
void setAlarmCodeAndIcon()
{
uint8_t cmd[7];
uint8_t index = 0;
for(index = 0; (index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4) < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; index++)
{
memset(cmd, 0x00, sizeof(cmd));
if(index >= 4)
{
break;
}
// ALARM CODE TEXT (XXXXXX)
string2ByteArray(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4][0], cmd);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ALARM_CODE_1 + (index * 6), cmd, ARRAY_SIZE(cmd));
// ALARM CODE ICON STATUS (!)
memset(cmd, 0x00, sizeof(cmd));
cmd[0] = 0x00;
cmd[1] = 0x01;
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, ICON_ALARM_1 + index, cmd, 2);
}
memset(cmd, 0x00, sizeof(cmd));
for(; index < 4; index++)
{
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ALARM_CODE_1 + (index * 6), cmd, ARRAY_SIZE(cmd));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, ICON_ALARM_1 + index, cmd, 2);
}
}
//=======================================
// Setting connection icon animation
//=======================================
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode)
{
switch(system_mode)
{
case SYS_MODE_IDLE:
if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
{
if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
}
else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
}
else
{
if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
{
setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_1);
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
}
else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
{
setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_2);
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
}
break;
case SYS_MODE_PREPARING:
if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
{
if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
}
else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
}
else
{
if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
{
setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
}
else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
{
setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_2);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
}
break;
case SYS_MODE_CHARGING:
if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
{
setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
}
else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
{
setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_2);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
break;
case SYS_MODE_TERMINATING:
break;
default:
break;
}
}
//=======================================
// Setting [ Gun Plug-in ] Animation
//=======================================
void setGunPluginAnimation(uint8_t gun_index)
{
if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) ||
(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C) ||
(ShmCharger->gun_info[gun_index].primaryMcuState.socket_e.isSocketEPinOn == ON))
{
setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_2);
}
else
{
if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN)))
{
setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_1;
}
else if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN*2)))
{
setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_2);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
}
}
}
//=======================================
// Setting [ Plug & Charge ] Animation
//=======================================
void setPlugAndChargeAnimation(uint8_t gun_index)
{
if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN)))
{
setDisplayValue(ICON_PLUG_AND_CHARGE_ARROW, PLUGIN_ARROW_1);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_1;
}
else if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN*2)))
{
setDisplayValue(ICON_PLUG_AND_CHARGE_ARROW, PLUGIN_ARROW_2);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
}
}
//=======================================
// Setting [ Press Start ] Animation
//=======================================
void setPressStartButtonAnimation(uint8_t gun_index)
{
if((START_PRESS_LEVEL_STATIS == PRESS_START_LEVEL_0) && ((getDiffSecNow(startTime[gun_index][TMR_IDX_STARTBUTTON]))> (TIME_ANIMATION_START_PRESS)))
{
setDisplayValue(ICON_PRESS_START_BUTTON, PRESS_START_1);
START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_1;
}
else if((START_PRESS_LEVEL_STATIS == PRESS_START_LEVEL_1) && ((getDiffSecNow(startTime[gun_index][TMR_IDX_STARTBUTTON]))> (TIME_ANIMATION_START_PRESS*2)))
{
setDisplayValue(ICON_PRESS_START_BUTTON, PRESS_START_2);
START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_STARTBUTTON]);
}
}
//=======================================
// Setting Connection Timeout
//=======================================
void setPresentConnectionTimeout(uint8_t gun_index)
{
int time;
uint8_t data[16];
uint8_t conntectionTimeout[16];
unsigned char not_counting[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(conntectionTimeout, 0x00, ARRAY_SIZE(conntectionTimeout));
memset(not_counting, 0x00, ARRAY_SIZE(not_counting));
if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) ||
(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C) ||
(ShmCharger->gun_info[gun_index].primaryMcuState.socket_e.isSocketEPinOn == ON))
{
strcpy((char*)not_counting, "-----");
string2ByteArray(not_counting, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
}
else
{
if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_A))
{
time = ShmCharger->timeoutSpec.Handshake_Timeout;
if(time <= 0)
{
strcpy((char*)not_counting, "000");
string2ByteArray(not_counting, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
}
else
{
sprintf((char *)conntectionTimeout, "%03d ", time);
string2ByteArray(conntectionTimeout, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
}
}
else
{
strcpy((char*)not_counting, "-----");
string2ByteArray(not_counting, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
}
}
}
//=======================================
// Setting Present Charging [ Power ]
//=======================================
void setPresentChargedgPower(uint8_t gun_index)
{
uint8_t data[16];
uint8_t power[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(power, 0x00, ARRAY_SIZE(power));
sprintf((char *)power, "%.2f kW", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargingPower);
string2ByteArray(power, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_POWER, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Present Charging [ Energy ]
//=======================================
void setPresentChargedEnergy(uint8_t gun_index, uint8_t system_mode)
{
uint8_t data[16];
uint8_t energy[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(energy, 0x00, ARRAY_SIZE(energy));
switch(system_mode)
{
case SYS_MODE_PREPARING:
sprintf((char *)energy, "%s kWh", "0.0000");
string2ByteArray(energy, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_ENERGY, data, ARRAY_SIZE(data));
break;
case SYS_MODE_CHARGING:
case SYS_MODE_TERMINATING:
case SYS_MODE_COMPLETE:
default:
sprintf((char *)energy, "%.4f kWh", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy);
string2ByteArray(energy, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_ENERGY, data, ARRAY_SIZE(data));
break;
}
}
//=======================================
// Setting Present Charging [ Duration ]
//=======================================
void setPresentChargedDuration(uint8_t gun_index)
{
uint8_t data[16];
uint8_t time[16];
uint16_t hour;
uint16_t minute;
uint16_t second;
uint32_t PresentChargedDuration = ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration;
memset(data, 0x00, ARRAY_SIZE(data));
memset(time, 0x00, ARRAY_SIZE(time));
hour = (PresentChargedDuration / 3600);
minute = (PresentChargedDuration - (3600 * hour)) / 60;
second = (PresentChargedDuration - (3600 * hour) - (minute * 60));
sprintf((char *)time, "%02d:%02d:%02d", hour, minute, second);
string2ByteArray(time, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TIMER, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Present [ Power Consumption ]
//=======================================
void setPresentPowerConsumption(uint8_t gun_index)
{
uint8_t data[32];
uint8_t powerConsumption[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(powerConsumption, 0x00, ARRAY_SIZE(powerConsumption));
sprintf((char *)powerConsumption, "%.4f kWh", ((float)ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10000.0));
string2ByteArray(powerConsumption, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_POWER_CONSUMPTION, data, ARRAY_SIZE(data));
}
//=======================================
// Setting authorization page
//=======================================
void setAuthorizationPage(uint8_t gun_index)
{
switch(ShmCharger->gun_info[gun_index].resultAuthorization)
{
case VALIDATED_RFID:
if(getCurrentPage() != SYSTEM_SCREEN_AUTH_PASS)
{
setCurrentPage(SYSTEM_SCREEN_AUTH_PASS);
DEBUG_INFO("Setting page to authorizing : Validated RFID.\n");
}
else
{}
break;
case UNVALIDATED_RFID:
if(getCurrentPage() != SYSTEM_SCREEN_AUTH_FAIL)
{
setCurrentPage(SYSTEM_SCREEN_AUTH_FAIL);
DEBUG_INFO("Setting page to authorizing : Unvalidated RFID.\n");
}
else
{}
break;
case UNKNOW_RFID:
if(getCurrentPage() != SYSTEM_SCREEN_AUTH_UNKNOWN)
{
setCurrentPage(SYSTEM_SCREEN_AUTH_UNKNOWN);
DEBUG_INFO("Setting page to authorizing : Unknown RFID\n");
}
else
{}
break;
case DEFAULT_RFID:
break;
default:
break;
}
}
//=======================================
// Setting default values
//=======================================
void setDefaultValue(uint8_t gun_index, uint8_t system_mode)
{
switch(system_mode)
{
case SYS_MODE_BOOTING:
break;
case SYS_MODE_IDLE:
setTextToEmpty(gun_index);
setTimeTitle(ON);
setEnergyTitle(ON);
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
}
else
{
setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
}
break;
case SYS_MODE_AUTHORIZING:
setTimeTitle(ON);
setEnergyTitle(ON);
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
break;
case SYS_MODE_PREPARING:
setTimeTitle(ON);
setEnergyTitle(ON);
setSessionFeeTitle(ON);
setParkingFeeTitle(ON);
setFinalCostTitle(ON);
if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
{
setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
}
else
{
setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
}
break;
case SYS_MODE_CHARGING:
break;
case SYS_MODE_TERMINATING:
setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_1);
refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
break;
case SYS_MODE_COMPLETE:
break;
case SYS_MODE_ALARM:
break;
case SYS_MODE_FAULT:
break;
case SYS_MODE_MAINTAIN:
break;
case SYS_MODE_UPDATE:
break;
case SYS_MODE_RESERVATION:
break;
case SYS_MODE_BOOKING:
break;
case SYS_MODE_DEBUG:
break;
default:
break;
}
}
//=======================================
// Setting text to empty
//=======================================
void setTextToEmpty(uint8_t gun_index)
{
uint8_t data[16];
uint8_t text_empty[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text_empty, 0x00, ARRAY_SIZE(text_empty));
strcpy((char*)text_empty, " ");
string2ByteArray(text_empty, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_ACCOUNT_BALANCE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting marquee control
//=======================================
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type)
{
uint8_t data[250];
unsigned char Content[250];
memset(Content, 0xFF, ARRAY_SIZE(Content));
memset(data, 0xFF, ARRAY_SIZE(data));
switch(type)
{
case DEFAULE_PRICE:
sprintf((char *)Content, "%s", (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
string2ByteArray(Content,data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), data, ARRAY_SIZE(data));
break;
case SET_USER_PRICE:
sprintf((char *)Content, "%s", (char *)ShmOCPP16Data->Cost.SetUserPrice.price);
string2ByteArray(Content,data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), data, ARRAY_SIZE(data));
break;
case FINAL_COST:
break;
case RUNNING_COST:
break;
default:
break;
}
}
//=======================================
// Checking model name for setting title
//=======================================
int isAmericaType()
{
int result = NO;
if(ShmSysConfigAndInfo->SysConfig.ModelName[3] == 'U')
result = YES;
else
result = NO;
return result;
}
//=======================================
// Setting time title
//=======================================
void setTimeTitle(uint8_t isOn)
{
uint8_t data[32];
uint8_t text[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
if(isAmericaType() == YES)
{
if(isOn == ON)
{
strcpy((char*)text, "(hrs: mins: secs)");
string2ByteArray(text, data);
}
else
{
strcpy((char*)text, " ");
string2ByteArray(text, data);
}
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_TIME, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_TIME, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_TIME, data, ARRAY_SIZE(data));
}
else
{
setDisplayValue(TEXT_CHARGING_TITLE_TIME, DISAPPEAR);
setDisplayValue(TEXT_PREPARING_TITLE_TIME, DISAPPEAR);
setDisplayValue(TEXT_PRECHARGING_TITLE_TIME, DISAPPEAR);
}
}
//=======================================
// Setting Energy title
//=======================================
void setEnergyTitle(uint8_t isOn)
{
uint8_t data[32];
uint8_t text[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
if(isAmericaType() == YES)
{
if(isOn == ON)
{
strcpy((char*)text, "(Energy)");
string2ByteArray(text, data);
}
else
{
strcpy((char*)text, " ");
string2ByteArray(text, data);
}
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_ENERGY, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_ENERGY, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_ENERGY, data, ARRAY_SIZE(data));
}
else
{
setDisplayValue(TEXT_CHARGING_TITLE_ENERGY, DISAPPEAR);
setDisplayValue(TEXT_PREPARING_TITLE_ENERGY, DISAPPEAR);
setDisplayValue(TEXT_PRECHARGING_TITLE_ENERGY, DISAPPEAR);
}
}
//=======================================
// Setting session fee title
//=======================================
void setSessionFeeTitle(uint8_t isOn)
{
uint8_t data[32];
uint8_t text[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
if(isAmericaType() == YES)
{
if(isOn == ON)
{
strcpy((char*)text, "(Energy Cost)");
string2ByteArray(text, data);
}
else
{
strcpy((char*)text, " ");
string2ByteArray(text, data);
}
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_SESSION_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_SESSION_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_SESSION_FEE, data, ARRAY_SIZE(data));
}
else
{
setDisplayValue(TEXT_CHARGING_TITLE_SESSION_FEE, DISAPPEAR);
setDisplayValue(TEXT_PREPARING_TITLE_SESSION_FEE, DISAPPEAR);
setDisplayValue(TEXT_PRECHARGING_TITLE_SESSION_FEE, DISAPPEAR);
}
}
//=======================================
// Setting parking fee title
//=======================================
void setParkingFeeTitle(uint8_t isOn)
{
uint8_t data[32];
uint8_t text[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
if(isAmericaType() == YES)
{
if(isOn == ON)
{
strcpy((char*)text, "(Parking Fee)");
string2ByteArray(text, data);
}
else
{
strcpy((char*)text, " ");
string2ByteArray(text, data);
}
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_PARKING_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_PARKING_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_PARKING_FEE, data, ARRAY_SIZE(data));
}
else
{
setDisplayValue(TEXT_CHARGING_TITLE_PARKING_FEE, DISAPPEAR);
setDisplayValue(TEXT_PREPARING_TITLE_PARKING_FEE, DISAPPEAR);
setDisplayValue(TEXT_PRECHARGING_TITLE_PARKING_FEE, DISAPPEAR);
}
}
//=======================================
// Setting final cost title
//=======================================
void setFinalCostTitle(uint8_t isOn)
{
uint8_t data[32];
uint8_t text[32];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
if(isAmericaType() == YES)
{
if(isOn == ON)
{
strcpy((char*)text, "(Total Cost)");
string2ByteArray(text, data);
}
else
{
strcpy((char*)text, " ");
string2ByteArray(text, data);
}
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_FINAL_COST, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_FINAL_COST, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_FINAL_COST, data, ARRAY_SIZE(data));
}
else
{
setDisplayValue(TEXT_CHARGING_TITLE_FINAL_COST, DISAPPEAR);
setDisplayValue(TEXT_PREPARING_TITLE_FINAL_COST, DISAPPEAR);
setDisplayValue(TEXT_PRECHARGING_TITLE_FINAL_COST, DISAPPEAR);
}
}
//=======================================
// Setting CSU FIRMWARE VERSION
//=======================================
void setCsuRootFsFwRev()
{
uint8_t data[64];
uint8_t text[64];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s%s", " CSU Software Version: ",(char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CSU_ROOT_FS_FW_REV, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging initial to empty
//=======================================
void setClearPrechargingValueToEmpty()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
strcpy((char*)text, " ");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TIMER, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_ENERGY, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_PARKING_FEE, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_COST, data, ARRAY_SIZE(data));
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_POWER, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging initial to empty
//=======================================
void setPrechargingTimerToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s", "00:00:00");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TIMER, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging energy to default
//=======================================
void setPrechargingEnergyToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s kWh", "0000.0000");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_ENERGY, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging session fee to default
//=======================================
void setPrechargingSessionFeeToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s", "000.00");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging parking fee to default
//=======================================
void setPrechargingParkingFeeToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s", "000.00");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_PARKING_FEE, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging cost to default
//=======================================
void setPrechargingCostToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s", "000.00");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_COST, data, ARRAY_SIZE(data));
}
//=======================================
// Setting Precharging power to default
//=======================================
void setPrechargingPowerToDefault()
{
uint8_t data[16];
uint8_t text[16];
memset(data, 0x00, ARRAY_SIZE(data));
memset(text, 0x00, ARRAY_SIZE(text));
sprintf((char *)text, "%s kW", "0.00");
string2ByteArray(text, data);
lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_POWER, data, ARRAY_SIZE(data));
}
//=======================================
// Initial all share memory
//=======================================
int InitShareMemory()
{
int result = PASS;
int MeterSMId;
// Initial ShmSysConfigAndInfo
if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), 0777)) < 0)
{
DEBUG_ERROR("shmget ShmSysConfigAndInfo NG\n");
result = FAIL;
}
else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
DEBUG_ERROR("shmat ShmSysConfigAndInfo NG\n");
result = FAIL;
}
else
{}
// Initial ShmStatusCodeData
if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), 0777)) < 0)
{
DEBUG_ERROR("shmget ShmStatusCodeData NG\n");
result = FAIL;
}
else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
DEBUG_ERROR("shmat ShmStatusCodeData NG\n");
result = FAIL;
}
else
{}
// Initial ShmCharger
if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), 0777)) < 0)
{
DEBUG_ERROR("shmget ShmChargerKey NG\n");
result = FAIL;
}
else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
DEBUG_ERROR("shmat ShmChargerKey NG\n");
result = FAIL;
}
// Initial ShmOCPP16Data
if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), 0777)) < 0)
{
DEBUG_ERROR("shmget ShmOCPP16Data NG\n");
result = FAIL;
}
else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
DEBUG_ERROR("shmat ShmOCPP16Data NG\n");
result = FAIL;
}
// Initial ShmOCPP20Data
if ((MeterSMId = shmget(ShmOcpp20ModuleKey, sizeof(struct OCPP20Data), 0777)) < 0)
{
DEBUG_ERROR("shmget ShmOCPP20Data NG\n");
result = FAIL;
}
else if ((ShmOCPP20Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
DEBUG_ERROR("shmat ShmOCPP20Data NG\n");
result = FAIL;
}
return result;
}
//=======================================
// Initial communication port
//=======================================
int InitComPort()
{
int fd;
struct termios tios;
fd = open("/dev/ttyS3", O_RDWR);
if(fd<=0)
{
DEBUG_ERROR("open /dev/ttyS3 NG\n");
return -1;
}
ioctl (fd, TCGETS, &tios);
tios.c_cflag = B115200| CS8 | CLOCAL | CREAD;
tios.c_lflag = 0;
tios.c_iflag = 0;
tios.c_oflag = 0;
tios.c_cc[VMIN]=0;
tios.c_cc[VTIME]=(unsigned char)5; // timeout 500ms
tios.c_lflag=0;
tcflush(fd, TCIFLUSH);
ioctl (fd, TCSETS, &tios);
return fd;
}
//=======================================
// Download image
//=======================================
int downloadBMP(uint8_t picIdx, char *filename)
{
int result = PASS;
BMP *bmp;
struct stat fileSt;
uint32_t pageSize = 0xf0;
uint32_t pixelSize;
uint32_t transferedByte=0;
uint16_t bufferRamAddr = 0x8000;
uint32_t dataLen = 0;
uint32_t startAddr=0;
// Reset LCD
uint8_t cmd_reset[] = {0x55, 0xaa, 0x5a, 0xa5};
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x04, cmd_reset, ARRAY_SIZE(cmd_reset)) != PASS)
{
DEBUG_INFO("LCD reset fail.\n");
}
sleep(1);
// Get image file size
stat(filename, &fileSt);
bmp = bopen(filename);
uint8_t buf[bmp->width*bmp->height*2];
DEBUG_INFO("Target address: %d\n", picIdx);
DEBUG_INFO("Image filename: %s\n", filename);
DEBUG_INFO("Image width: %d height: %d\n", bmp->width, bmp->height);
DEBUG_INFO("Image data size: %d\n", ARRAY_SIZE(buf));
// Get bmp pixel data and convert to 16 bit color
for(uint16_t idxY=0 ; idxY<bmp->height ; idxY++)
{
for(uint16_t idxX=0 ; idxX<bmp->width ; idxX++)
{
uint8_t r, g, b;
get_pixel_rgb(bmp, idxX, (bmp->height-idxY-1), &r, &g, &b);
buf[(2*((idxY*bmp->width) + idxX)) + 0] = ((((r>>3)<<11) | ((g>>2)<<5) | (b>>3)) >> 8) & 0xff;
buf[(2*((idxY*bmp->width) + idxX)) + 1] = ((((r>>3)<<11) | ((g>>2)<<5) | (b>>3)) >> 0) & 0xff;
}
}
bclose(bmp);
// Transfer pixel to screen page
pixelSize = ARRAY_SIZE(buf);
for(uint16_t idxSrcData=0;idxSrcData<(((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1);idxSrcData++)
{
//DEBUG_INFO("Buffer start data address: 0x%08X\n", (idxSrcData*pageSize));
//DEBUG_INFO(" Image start ram address: 0x%08X\n", ((idxSrcData*pageSize) >> 1));
uint8_t display_cmd[] ={0x5a, (bufferRamAddr>>8)&0xff, (bufferRamAddr>>0)&0xff, 0x00, 0x00, 0x00, 0x00, 0x00};
if((idxSrcData+1) != (((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1))
{
// Data transfer
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (bufferRamAddr+(dataLen>>1)), &buf[(idxSrcData*pageSize)], pageSize) != PASS)
{
DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
}
transferedByte += pageSize;
dataLen += pageSize;
}
else
{
// Last data transfer
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (bufferRamAddr+(dataLen>>1)), &buf[(idxSrcData*pageSize)], (pixelSize-(idxSrcData*pageSize))) != PASS)
{
DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
}
transferedByte += (pixelSize-(idxSrcData*pageSize));
dataLen += (pixelSize-(idxSrcData*pageSize));
}
// Move data from ram to flash
if((dataLen >= (pageSize*10)) || (idxSrcData == (((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1)-1))
{
display_cmd[3] = ((dataLen>>1) >> 8) & 0xff; // Data length high byte
display_cmd[4] = ((dataLen>>1) >> 0) & 0xff; // Data length low byte
display_cmd[5] = (((startAddr)>>1) >> 16) & 0xff; // Screen on ram address 1st byte
display_cmd[6] = (((startAddr)>>1) >> 8) & 0xff; // Screen on ram address 2nd byte
display_cmd[7] = (((startAddr)>>1) >> 0) & 0xff; // Screen on ram address 3th byte
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0xa2, display_cmd, ARRAY_SIZE(display_cmd)) != PASS)
{
DEBUG_INFO("Write data to display buffer 0x%04X fail.\n", transferedByte);
}
startAddr += dataLen;
dataLen = 0;
}
}
// Save image to target address
uint8_t save_cmd[] ={0x5a, 0x02, ((picIdx>>8)&0xff), (picIdx&0xff)};
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x84, save_cmd, ARRAY_SIZE(save_cmd)) != PASS)
{
DEBUG_INFO("Save image fail.\n");
}
DEBUG_INFO("Save image success.\n");
sleep(1);
return result;
}
//=======================================
// Download image
//=======================================
int downloadBIN(uint8_t targetAddr, char *filename)
{
int result = PASS;
int fd;
struct stat fileSt;
uint32_t pageSize = 128;
uint32_t blocklSize = 32768;
uint32_t transferedByte=0;
uint16_t bufferRamAddr = 0x8000;
// Reset LCD
uint8_t cmd_reset[] = {0x55, 0xaa, 0x5a, 0xa5};
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x04, cmd_reset, ARRAY_SIZE(cmd_reset)) != PASS)
{
DEBUG_INFO("LCD reset fail.\n");
}
sleep(1);
// Get image file size
stat(filename, &fileSt);
uint8_t buf[(fileSt.st_size%32768==0?(fileSt.st_size/32768)*32768:(fileSt.st_size/32768)+1)*32768];
DEBUG_INFO("Target address: %d\n", targetAddr);
DEBUG_INFO("Bin filename: %s\n", filename);
DEBUG_INFO("Bin data size: %d\n", fileSt.st_size);
fd = open(filename, O_RDWR);
if (fd < 0)
{
DEBUG_WARN("Bin can not be open.\n");
result = FAIL;
}
else
{
// Read data from bin file
memset(buf, 0x00, ARRAY_SIZE(buf));
read(fd, buf, ARRAY_SIZE(buf));
close(fd);
for(uint8_t idxBinSrc=0;idxBinSrc<(fileSt.st_size%32768==0?fileSt.st_size/32768:(fileSt.st_size/32768)+1);idxBinSrc++)
{
// Transfer data to ram
for(uint16_t idxSrcData=0;idxSrcData<(((blocklSize%pageSize)==0)?(blocklSize/pageSize):(blocklSize/pageSize)+1);idxSrcData++)
{
//DEBUG_INFO("Buffer start data address: 0x%08X\n", (idxBinSrc*blocklSize)+(idxSrcData*pageSize));
//DEBUG_INFO(" Image start ram address: 0x%08X\n", ((idxSrcData*pageSize) >> 1));
if((idxSrcData+1) != (((blocklSize%pageSize)==0)?(blocklSize/pageSize):(blocklSize/pageSize)+1))
{
// Data transfer
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, bufferRamAddr+((idxSrcData*pageSize)>>1), &buf[(idxBinSrc*blocklSize)+(idxSrcData*pageSize)], pageSize) != PASS)
{
DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
}
transferedByte += pageSize;
}
else
{
// Last data transfer
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, bufferRamAddr+((idxSrcData*pageSize)>>1), &buf[(idxBinSrc*blocklSize)+(idxSrcData*pageSize)], (blocklSize-(idxSrcData*pageSize)))!= PASS)
{
DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
}
transferedByte += (blocklSize-(idxSrcData*pageSize));
}
}
// Move data from ram to flash
uint8_t save_cmd[] ={0x5a, 0x02, ((((targetAddr*8)+idxBinSrc)>>8)&0xff), ((((targetAddr*8)+idxBinSrc)>>0)&0xff), ((bufferRamAddr>>8)&0xff), ((bufferRamAddr>>0)&0xff), 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};
while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0xaa, save_cmd, ARRAY_SIZE(save_cmd)) != PASS)
{
DEBUG_INFO("Save bin file to 0x%04X fail.\n", ((targetAddr*8)+idxBinSrc));
}
DEBUG_INFO("Save bin file on 0x%04X success.\n", ((targetAddr*8)+idxBinSrc));
sleep(1);
}
}
return result;
}
//=======================================
// LCD upgrade
//=======================================
int lcdUpgrade(char *forlder)
{
int result = PASS;
DIR *dir;
struct dirent *file;
struct stat fileSt;
if ((dir = opendir (forlder)) != NULL)
{
/* print all the files and directories within directory */
while ((file = readdir (dir)) != NULL)
{
if((strlen(file->d_name)>2))
{
int targetAddr;
stat(file->d_name, &fileSt);
if(sscanf(file->d_name, "%d", &targetAddr) == 1)
{
char targetFile[384];
sprintf(targetFile, "/mnt/lcd/%s", file->d_name);
if(strstr(file->d_name, ".bmp") != NULL)
{
downloadBMP(targetAddr, targetFile);
}
else
{
downloadBIN(targetAddr, targetFile);
}
}
else
{
DEBUG_WARN("%s can not parse target address.\n", file->d_name);
}
}
else
{
if(strlen(file->d_name) >= 3)
{
DEBUG_ERROR("File name error.\n");
result = FAIL;
}
else
{
DEBUG_INFO("Searching file.\n");
}
}
sleep(1);
}
closedir (dir);
}
else
{
DEBUG_ERROR("%s does not valid.\n", forlder);
result = FAIL;
}
return result;
}
//=======================================
// Ethernet connection status
//=======================================
int isEthConnected(char *eth)
{
int result = NO;
FILE *fp;
char buf[512];
sprintf(buf, "/sbin/ethtool %s", eth);
fp = popen(buf, "r");
if(fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if((strstr(buf, "Link detected") != NULL) && (strstr(buf, "yes") != NULL))
{
result = YES;
}
}
}
pclose(fp);
return result;
}
//=======================================
// Main process
//=======================================
int main(void)
{
uint8_t previousMode = 0xff;
if(InitShareMemory() == FAIL)
{
#ifdef SystemLogMessage
DEBUG_ERROR("InitShareMemory NG\n");
#endif
if(ShmStatusCodeData!=NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
}
sleep(5);
return FAIL;
}
Uart1Fd=InitComPort();
if(Uart1Fd<0)
{
#ifdef SystemLogMessage
DEBUG_ERROR("InitComPort NG\n");
#endif
if(ShmStatusCodeData!=NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
return FAIL;
}
else
{}
DEBUG_INFO("Initial completed\n");
DEBUG_INFO("Latest Firmware Version : [%s] \n", FIRMWARE_UPDATE_IMAGE[0]);
DEBUG_INFO("Latest Upgrade Date : [%s]. \n", FIRMWARE_UPDATE_IMAGE[1]);
DEBUG_INFO("Latest Image Version : [%s]. \n", FIRMWARE_UPDATE_IMAGE[2]);
for(;;)
{
if(ShmCharger->isUpgradeLcmReq)
{
ShmCharger->isUpgradeLcmSuccess = ((lcdUpgrade("/mnt/lcd") == PASS) ? YES : NO);
ShmCharger->isUpgradeLcmReq = OFF;
}
else
{
if(previousMode != ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
{
previousMode = ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus;
}
if(ShmCharger->isAuthrizing || ShmCharger->isGetAuthResult)
{
if(getDiffSecNow(startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]) >= TIME_AUTH_RESULT_TIME)
ShmCharger->isGetAuthResult = FALSE;
if(getDiffSecNow(startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]) < TIME_AUTH_RESULT_TIME)
{
page_authorizing(ShmCharger->gun_selectd);
ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = YES;
}
else if(((ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_IDLE) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_RESERVATION)) && (ShmCharger->gun_info[ShmCharger->gun_selectd].resultAuthorization == VALIDATED_RFID))
{
if((ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_RESERVATION) && (strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char*)ShmOCPP16Data->ReserveNow[ShmCharger->gun_selectd].IdTag) != 0))
{
page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
}
else
{
page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
}
ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = NO;
}
}
else
{
refreshStartTimer(&startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]);
ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = NO;
switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
{
case SYS_MODE_BOOTING:
page_booting();
break;
case SYS_MODE_IDLE:
page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_AUTHORIZING:
if(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].StartMethod == START_METHOD_EVCCID)
page_authorizing(ShmCharger->gun_selectd);
break;
case SYS_MODE_PREPARING:
page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_CHARGING:
page_charging(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_TERMINATING:
page_terminating(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_COMPLETE:
page_complete(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_ALARM:
page_alarm();
break;
case SYS_MODE_FAULT:
page_fault();
break;
case SYS_MODE_MAINTAIN:
page_maintain();
break;
case SYS_MODE_UPDATE:
page_update();
break;
case SYS_MODE_RESERVATION:
//page_reservation();
page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
break;
case SYS_MODE_BOOKING:
page_booking();
break;
case SYS_MODE_DEBUG:
page_debug();
break;
default:
page_unknown();
break;
}
}
page_header(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
page_footer();
}
usleep(100000);
}
return FAIL;
}