/*
* main.c
*
* Created on: 2020年9月10日
* Author: Wendell
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/wireless.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdio.h> /*標準輸入輸出定義*/
#include <stdlib.h> /*標準函數庫定義*/
#include <unistd.h> /*Unix 標準函數定義*/
#include <fcntl.h> /*檔控制定義*/
#include <termios.h> /*PPSIX 終端控制定義*/
#include <errno.h> /*錯誤號定義*/
#include <errno.h>
#include <string.h>
#include <stdint.h>
#include <time.h>
#include <ctype.h>
#include <ifaddrs.h>
#include <math.h>
#include "../../define.h"
#include "Config.h"
#include <stdbool.h>
#include <dirent.h>
#include "timeout.h"
#include "Module_EvComm.h"
#include "Module_CabinetParallel.h"
#include "Common.h"
#define BTN_RELEASE 0
#define BTN_PRESS 1
#define MAX_BUF 64
#define MtdBlockSize 0x300000
#define SYSFS_GPIO_DIR "/sys/class/gpio"
#define UPGRADE_FAN 0x02
#define UPGRADE_RB 0x03
#define UPGRADE_PRI 0x04
#define UPGRADE_AC 0x05
#define UPGRADE_LED 0x06
#define UPGRADE_DORC1 0x07
#define UPGRADE_DORC2 0x08
#define UPGRADE_DDRB 0x09
#define SYSTEM_MIN_VOL 150
#define MIN_OUTPUT_CUR 0
#define AC_OUTPUT_VOL 220
#define NO_DEFINE 255
#define DEFAULT_AC_INDEX 2
#define PSU_MIN_CUR 100
#define DB_FILE "/Storage/ChargeLog/localCgargingRecord.db"
#define MAIN_PRIORITY_INTERVAL 5
#define CABINET_ROLE_TIMEOUT 3 // unit: 1s
#define AUTHORIZE_TIMEOUT 30
#define AUTHORIZE_COMP_TIMEOUT 1
#define AUTHORIZE_FAIL_TIMEOUT 3
#define AUTHORIZE_STOP_TIMEOUT 30
#define RETURN_TO_CHARGING_PAGE 30
#define GUN_PREPARE_TIMEOUT 30
#define GUN_EV_WAIT_TIMEOUT (120 + 10)
#define GUN_EVSE_WAIT_TIMEOUT (60 + 10)
#define GUN_COMP_WAIT_TIMEOUT 10
#define GUN_PRECHARGING_TIMEOUT 60
#define REBOOT_TIMEOUT 10
#define RESET_TIMEOUT 10
#define OCPP_COST_REQ_INTERVAL 5
#define DISPENSER_RECONNECTE_TIME 30
#define DISPENSER_AUTH_COMP_TIME 3
#define FORCE_BALANCE_TIME 5
#define DISPENSER_UPGRADE_TIME 600
#define AC_CONTACTOR_REOPEN_TIME 40
#define PSU_FAILURE_RESUME_TIME 180
#define MAX_AC_CONTACTOR_COUNT 3
#define STANDBY_TIME 600
#define FAST_STANDBY_TIME 30
#define WIRING_INFO_DELAY 30
#define WAIT_REASSIGN_TIME 30 // unit: second
#define MAX_REQUEST_CHARGING_TIME 15 // unit: second
#define MIN_WAIT_PREPARNING_TIME 5 // unit: second
#define FORCE_CHARGING_WAIT_EVSE 10 // unit: second
#define TRY_RESET_4G_WIFI_TIME 300 // unit: second
#define FAST_RESET_4G_WIFI_TIME 60 // unit: second
#define ENERAGY_INTERVAL 1 // unit: second
#define FAULT_RELEASE_TIME 1 // unit: second
#define MAINTAIN_RECOVERY_TIME 1 // unit: second
#define PARALLEL_WAIT_TIME 3 // unit: second
#define START_UPGRADE_TIME 60 // unit: second
#define PCABINET_UPGRADE_TIME 300 // unit: second
#define MCABINET_UPGRADE_TIME 60 // unit: second
#define AUTO_START_CHARGING "AutoStartCharging"
char *valid_Internet[2] = {"8.8.8.8", "180.76.76.76"};
unsigned char mask_table[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
int whileLoopTime = 10000; // 10 ms
int wtdFd = -1;
byte _authorizeIndex = NO_DEFINE;
BOOL _UpgradeNeedReboot = FALSE;
const byte Group_to_Location_2_Gun[GENERAL_GUN_QUANTITY] = {0, 1, 0, 0};
const byte Location_to_Group_2_Gun[GENERAL_GUN_QUANTITY] = {0, 1, 0, 0};
const byte GroupParallelRelay_2_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
{
{0, 1, 0, 0},
{1, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
};
//Location: 1 2 3 4
// Gun: 1 3 4 2
//Parallel: 1 2 3
//const byte Group_to_Location_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 1, 2};
//const byte Location_to_Group_4_Gun[GENERAL_GUN_QUANTITY] = {0, 2, 3, 1};
//const byte GroupParallelRelay_4_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
//{
// {0, 3, 1, 2}, // group 0
// {1, 0, 2, 3}, // group 1
// {1, 3, 0, 2}, // group 2
// {1, 3, 2, 0} // group 3
//};
//Location: 1 2 3 4
// Gun: 1 4 3 2
//Parallel: 1 2 3
const byte Group_to_Location_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 2, 1};
const byte Location_to_Group_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 2, 1};
const byte GroupParallelRelay_4_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
{
{0, 3, 2, 1}, // group 0
{1, 0, 3, 2}, // group 1
{1, 3, 0, 2}, // group 2
{1, 3, 2, 0} // group 3
};
bool IsAuthorizingMode();
void ClearAuthorizedFlag();
bool isDetectPlugin();
void ClearDetectPluginFlag();
int mystrcmp(unsigned char *p1, unsigned char *p2);
long long DiffTimebWithNow(struct timeb ST);
unsigned char DetectBitValue(unsigned char _byte, unsigned char _bit);
void SetBitValue(unsigned char *_byte, unsigned char _bit, unsigned char value);
void ChargingTerminalProcess(byte gunIndex);
void ChkPrimaryStatus();
//void StartSystemTimeoutDet(unsigned char flag);
//void StopSystemTimeoutDet();
//void StartGunInfoTimeoutDet(unsigned char gunIndex, unsigned char flag);
//void StopGunInfoTimeoutDet(unsigned char gunIndex);
int StoreLogMsg_1(const char *fmt, ...);
void gpio_set_value(unsigned int gpio, unsigned int value);
void ChangeGunSelectByIndex(byte sel);
void ChargingAlarmProcess(byte gunIndex);
void InformOcppErrOccur(byte codeType);
void SetOcppErrorCode(unsigned char _index, char *errCode);
void SetOcppVendorErrorCode(unsigned char _index, char *vendorCode);
void ReleaseAlarmCode(byte gunIndex);
int DB_Open(sqlite3 *db);
int DB_Insert_Record(sqlite3 *db, int gun_index);
int DB_Update_Operactive(sqlite3 *db, uint8_t gun_index, uint8_t IsAvailable);
int DB_Get_Operactive(sqlite3 *db, uint8_t gun_index);
void InitialDHCP();
void InitialDispenserDhcpServerConfig(void);
void StartDispenserDhcpServer(void);
void _SelfTestTimeout(void);
void CheckConnectionTimeout(void);
bool IsParallelCabinetIdle(void);
bool IsConnectorWholeIdle(void);
void SetAcContactor(unsigned char OnOff);
void UpdateErrorCodeToOcpp(byte index);
bool CheckConnectorTypeStatus(void);
void CreateWatchdog(void);
void TryCloseWatchdog(void);
void TryFeedWatchdog(void);
bool IsReadyParalleling(void);
void SetParallelingStart(void);
void SetParallelingDone(void);
void SetPCabinetOutputRelay(unsigned char index, unsigned char OnOff);
void SetParallelCabinetAcContactor(unsigned char OnOff);
unsigned short GetTotalParallelCabinetPower(void);
void MCabinetParallelingProcess(void);
void SCabinetControllProcess(void);
struct SysConfigAndInfo *ShmSysConfigAndInfo;
struct StatusCodeData *ShmStatusCodeData;
struct PsuData *ShmPsuData;
struct CHAdeMOData *ShmCHAdeMOData;
struct GBTData *ShmGBTData;
struct CcsData *ShmCcsData;
struct PrimaryMcuData *ShmPrimaryMcuData;
struct FanModuleData *ShmFanModuleData;
struct RelayModuleData *ShmRelayModuleData[2];
struct LedModuleData *ShmLedModuleData;
struct OCPP16Data *ShmOCPP16Data;
struct OCPP20Data *ShmOCPP20Data;
struct MeterInformation *ShmCsuMeterData;
ChargerInfoData *ShmChargerInfo;
PsuPositionInfoData *ShmPsuPosition;
PsuGroupingInfoData *ShmPsuGrouping;
struct ChargingInfoData *chargingInfo[CONNECTOR_QUANTITY];
struct ChargingInfoData *ac_chargingInfo[AC_QUANTITY];
struct timespec _cmdMainPriority_time;
struct timespec _cmdSubPriority_time;
struct timespec _ConnectorAuthorizing_Time[CONNECTOR_QUANTITY];
struct timespec _ConnectorAuthorizeFail_Time[CONNECTOR_QUANTITY];
struct timespec _DispenserAuthorizing_Time[CONNECTOR_QUANTITY];
struct timespec _DispenserUpgrade_time;
struct timespec _Standby_time;
struct timespec _SystemStatus_Time[CONNECTOR_QUANTITY];
struct timespec _Parallel_Time;
float gunOutputVol[CONNECTOR_QUANTITY];
unsigned char _ocppProfileChkFlag[CONNECTOR_QUANTITY];
float _lastProfilePower[CONNECTOR_QUANTITY];
float _lastProfileCurrent[CONNECTOR_QUANTITY];
float _lastMaxProfilePower;
struct StructStatusNotification _BackupStatusNotification[CONNECTOR_QUANTITY];
bool _NeedReset4gWifi;
struct timespec _4gWifiReset_time;
// for initial index to check EV board type is correct
byte _gunIndex = 0;
byte _acgunIndex = 0;
byte _chademoIndex = 0;
byte _ccsIndex = 0;
byte _gb_Index = 0;
byte _ac_Index = 0;
//byte bd0_1_status = 0;
//byte bd0_2_status = 0;
//byte bd1_1_status = 0;
//byte bd1_2_status = 0;
bool isCardScan = false;
bool isModelNameMatch = true;
//int rfidFd = -1;
//char* rfidPortName = "/dev/ttyS2";
char* fwVersion = "V1.05.00.0000.00";
sqlite3 *localDb;
bool isDb_ready;
//================================================
// initial can-bus
//================================================
int InitCanBus()
{
int s0,nbytes;
struct timeval tv;
struct ifreq ifr0;
struct sockaddr_can addr0;
system("/sbin/ip link set can0 down");
system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
system("/sbin/ip link set can0 up");
s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);
tv.tv_sec = 0;
tv.tv_usec = 10000;
if (setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("Set SO_RCVTIMEO NG");
#endif
}
nbytes=40960;
if (setsockopt(s0, SOL_SOCKET, SO_RCVBUF, &nbytes, sizeof(int)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("Set SO_RCVBUF NG");
#endif
}
nbytes=40960;
if (setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("Set SO_SNDBUF NG");
#endif
}
strcpy(ifr0.ifr_name, "can0" );
ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
addr0.can_family = AF_CAN;
addr0.can_ifindex = ifr0.ifr_ifindex;
bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
return s0;
}
//================================================
// initial uart port
//================================================
char *_priPortName = "/dev/ttyS1";
char *_485PortName = "/dev/ttyS5";
int InitComPort(byte target)
{
int fd;
struct termios tios;
if(target == UPGRADE_PRI)
fd = open(_priPortName, O_RDWR);
else if (target == UPGRADE_FAN || target == UPGRADE_RB || target == UPGRADE_AC || target == UPGRADE_LED)
fd = open(_485PortName, O_RDWR);
if(fd<=0)
{
#ifdef SystemLogMessage
LOG_ERROR("open 407 Communication port NG");
#endif
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)1;
tios.c_lflag=0;
tcflush(fd, TCIFLUSH);
ioctl (fd, TCSETS, &tios);
return fd;
}
//=================================
// Common routine
//=================================
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt)
{
strncpy(dest, src + start, cnt);
dest[cnt] = 0;
}
int InitWatchDog()
{
int fd;
int timeout = 180;
system("/usr/bin/fuser -k /dev/watchdog");
sleep(1);
system("echo V > /dev/watchdog");
sleep(1);
fd=open("/dev/watchdog", O_RDWR);
if(fd<=0)
{
LOG_ERROR("System watch dog initial fail.\r\n");
}
ioctl(fd, _IOWR('W', 6, int), &timeout);
return fd;
}
int StoreLogMsg_1(const char *fmt, ...)
{
char Buf[4096+256];
char buffer[4096];
va_list args;
struct timeb SeqEndTime;
struct tm *tm;
va_start(args, fmt);
int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
va_end(args);
memset(Buf,0,sizeof(Buf));
ftime(&SeqEndTime);
SeqEndTime.time = time(NULL);
tm=localtime(&SeqEndTime.time);
if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == YES)
{
sprintf(Buf,"%02d:%02d:%02d:%03d - %s",
tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm, buffer);
printf("%s \n", Buf);
}
else
{
sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]SystemLog",
tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
buffer,
tm->tm_year+1900,tm->tm_mon+1);
system(Buf);
}
return rc;
}
int mystrcmp(unsigned char *p1, unsigned char *p2)
{
while(*p1==*p2)
{
if(*p1=='\0' || *p2=='\0')
break;
p1++;
p2++;
}
if(*p1=='\0' && *p2=='\0')
return(PASS);
else
return(FAIL);
}
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;
return (StopTime-StartTime);
}
bool CheckTimeOut(struct timeb ST)
{
struct timeb ET;
unsigned int StartTime, StopTime;
ftime(&ET);
StartTime = (unsigned int) ST.time;
StopTime = (unsigned int) ET.time;
return (StopTime > StartTime)? YES : NO;
}
void setChargerMode(byte gun_index, byte mode)
{
chargingInfo[gun_index]->SystemStatus = mode;
}
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);
}
/*
//==========================================
// Check interface status
//==========================================
int isInterfaceUp(const char *interface)
{
int result = FAIL;
FILE *fp;
char cmd[256];
char buf[512];
strcpy(cmd, "ifconfig");
fp = popen(cmd, "r");
if(fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if(strstr(buf, interface) > 0)
{
result = PASS;
}
}
}
pclose(fp);
return result;
}
*/
//=================================
// Create all share memory
//=================================
int CreateShareMemory()
{
int MeterSMId;
if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmSysConfigAndInfo NG");
#endif
return 0;
}
else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmSysConfigAndInfo NG");
#endif
return 0;
}
memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmStatusCodeData NG");
#endif
return 0;
}
else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmStatusCodeData NG");
#endif
return 0;
}
memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));
//creat ShmPsuData
if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmPsuData NG");
#endif
return 0;
}
else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmPsuData NG");
#endif
return 0;
}
memset(ShmPsuData, 0, sizeof(struct PsuData));
/*
if(CHAdeMO_QUANTITY > 0)
{
if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmCHAdeMOData NG");
#endif
return 0;
}
else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmCHAdeMOData NG");
#endif
return 0;
}
memset(ShmCHAdeMOData, 0, sizeof(struct CHAdeMOData));
}
if(GB_QUANTITY > 0)
{
if ((MeterSMId = shmget(ShmGBTCommKey, sizeof(struct GBTData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmGBTData NG");
#endif
return 0;
}
else if ((ShmGBTData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmGBTData NG");
#endif
return 0;
}
memset(ShmGBTData, 0, sizeof(struct GBTData));
}
//creat ShmCcsData
if(CCS_QUANTITY > 0)
{
if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmCcsData NG");
#endif
return 0;
}
else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmCcsData NG");
#endif
return 0;
}
memset(ShmCcsData, 0, sizeof(struct CcsData));
}
*/
//creat ShmPrimaryMcuData
if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmPrimaryMcuData NGn");
#endif
return 0;
}
else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmPrimaryMcuData NG");
#endif
return 0;
}
memset(ShmPrimaryMcuData, 0, sizeof(struct PrimaryMcuData));
//creat ShmFanModuleData
if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmFanModuleData NG");
#endif
return 0;
}
else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmFanModuleData NG");
#endif
return 0;
}
memset(ShmFanModuleData, 0, sizeof(struct FanModuleData));
//creat ShmRelayModuleData
if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmRelayModuleData[0] NG");
#endif
return 0;
}
else if ((ShmRelayModuleData[0] = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmRelayModuleData[0] NG");
#endif
return 0;
}
memset(ShmRelayModuleData[0], 0, sizeof(struct RelayModuleData));
// DO360 RC2
if ((MeterSMId = shmget(ShmRelay2BdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmRelayModuleData[1] NG");
#endif
return 0;
}
else if ((ShmRelayModuleData[1] = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmRelayModuleData[1] NG");
#endif
return 0;
}
memset(ShmRelayModuleData[1], 0, sizeof(struct RelayModuleData));
if ((MeterSMId = shmget(ShmLedBdKey, sizeof(struct LedModuleData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmLedModuleData NG");
#endif
return 0;
}
else if ((ShmLedModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmLedModuleData NG");
#endif
return 0;
}
memset(ShmLedModuleData, 0, sizeof(struct LedModuleData));
//creat ShmOCPP16Data
if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ShmOCPP16Data NG");
#endif
return 0;
}
else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ShmOCPP16Data NG");
#endif
return 0;
}
memset(ShmOCPP16Data,0,sizeof(struct OCPP16Data));
if ((MeterSMId = shmget(ShmOcpp20ModuleKey, sizeof(struct OCPP20Data), IPC_CREAT | 0777)) < 0)
{
LOG_ERROR("[main]CreatShareMemory:shmget OCPP20Data NG\n");
return 0;
}
else if ((ShmOCPP20Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
LOG_ERROR("[main]CreatShareMemory:shmat OCPP20Data NG\n");
return 0;
}
memset(ShmOCPP20Data,0,sizeof(struct OCPP20Data));
if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), IPC_CREAT | 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmget ChargerInfoData NG");
#endif
return 0;
}
else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("[main]CreatShareMemory:shmat ChargerInfoData NG");
#endif
return 0;
}
memset(ShmChargerInfo, 0, sizeof(ChargerInfoData));
ShmPsuPosition = &ShmChargerInfo->PsuPosition;
ShmPsuGrouping = &ShmChargerInfo->PsuGrouping;
return 1;
}
//=================================
// LCM Page
//=================================
void ChangeLcmByIndex(byte page_index)
{
if (ShmSysConfigAndInfo->SysWarningInfo.Level != 2 ||
page_index == _LCM_COMPLETE || page_index == _LCM_FIX)
{
ShmSysConfigAndInfo->SysInfo.PageIndex = page_index;
}
}
//======================================================
// Peripheral initial
//======================================================
void InitGPIO()
{
/*****************0~3, 4 bank, bank x 32+ num*********************/
/***************************************************************/
/*************** GPIO 0 ***************************************/
/***************************************************************/
/* GPMC_AD8 => GPIO0_22 *//*ID BD1_1*/ // no use
system("echo 22 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio22/direction");
/* GPMC_AD9 => GPIO0_23 *//*ID BD1_2*/ // no use
system("echo 23 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio23/direction");
/* GPMC_AD10 => GPIO0_26 *//*IO BD1_1*/ // no use
system("echo 26 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio26/direction");
system("echo 1 > /sys/class/gpio/gpio26/value");
/* GPMC_AD11 => GPIO0_27 *//*IO BD1_2*/ // no use
system("echo 27 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio27/direction");
/* RMII1_REF_CLK => GPIO0_29 *//*USB 0 OCP detection*/
system("echo 29 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio29/direction");
/*XDMA_EVENT_INTR0 => GPIO0_19 *//*AM_RFID_RST*/ // no use
system("echo 19 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio19/direction");
system("echo 1 > /sys/class/gpio/gpio19/value");
/*XDMA_EVENT_INTR1 => GPIO0_20 *//*AM_RFID_ICC*/ // no use
system("echo 20 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio20/direction");
/***************************************************************/
/*************** GPIO 1 ***************************************/
/***************************************************************/
/* GPMC_AD12 => GPIO1_12 *//*ID BD2_1*/ // no use
system("echo 44 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio44/direction");
/* GPMC_AD13 => GPIO1_13 *//*ID BD2_2*/ // no use
system("echo 45 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio45/direction");
/* GPMC_AD14 => GPIO1_14 *//*IO BD2_1*/ // no use
system("echo 46 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio46/direction");
system("echo 0 > /sys/class/gpio/gpio46/value");
/* GPMC_AD15 => GPIO1_15 *//*IO BD2_2*/ // no use
system("echo 47 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio47/direction");
/***************************************************************/
/*************** GPIO 2 ***************************************/
/***************************************************************/
/*LCD_AC_BIAS_EN => GPIO2_25*//*RS-485 for module DE control*/
system("echo 89 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio89/direction");
system("echo 1 > /sys/class/gpio/gpio89/value");
/*LCD_HSYNC => GPIO2_23*//*RS-485 for module RE control*/
system("echo 87 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio87/direction");
system("echo 0 > /sys/class/gpio/gpio87/value");
/*LCD_PCLK => GPIO2_24*//*CCS communication board 1 proximity*/ // no use
system("echo 88 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio88/direction");
/*LCD_VSYNC => GPIO2_22*//*CCS communication board 2 proximity*/ // no use
system("echo 86 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio86/direction");
/***************************************************************/
/*************** GPIO 3 ***************************************/
/***************************************************************/
/*MCASP0_FSX => GPIO3_15*//*Emergency Stop button detect*/
system("echo 111 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio111/direction");
/*MCASP0_ACLKR => GPIO3_18*//*USB1 OCP detect*/
system("echo 114 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio114/direction");
/*MCASP0_AHCLKR => GPIO3_17*//*Emergency IO for AM3352 and STM32F407*/
system("echo 113 > /sys/class/gpio/export");
system("echo \"in\" > /sys/class/gpio/gpio113/direction");
/*MCASP0_ACLKX => GPIO3_14*//*Ethernet PHY reset*/
system("echo 110 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio110/direction");
system("echo 0 > /sys/class/gpio/gpio110/value");
/* MCASP0_FSR => GPIO3_19 *//*SMR Enable control_1 for Pskill_1*/ // no use
system("echo 115 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio115/direction");
system("echo 0 > /sys/class/gpio/gpio115/value");
/* MCASP0_AXR0 => GPIO3_16 *//*CSU board function OK indicator.*/
system("echo 112 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio112/direction");
system("echo 1 > /sys/class/gpio/gpio112/value");
/* MCASP0_AXR1 => GPIO3_20 *//*SMR Enable control_2 for Pskill_2*/ // no use
system("echo 116 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio116/direction");
system("echo 0 > /sys/class/gpio/gpio116/value");
/* (C14) EMU0.gpio3[7] */ /*CP open/short feature enable/disable, pull low for default enable*/
system("echo 103 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio103/direction");
system("echo 0 > /sys/class/gpio/gpio103/value");
/* (B14) EMU1.gpio3[8] */ /*4G module reset, pull high to reset when entry kernel, after Application start, it should be pull low.*/
system("echo 104 > /sys/class/gpio/export");
system("echo \"out\" > /sys/class/gpio/gpio104/direction");
system("echo 0 > /sys/class/gpio/gpio104/value");
LOG_INFO("[main]InitGPIO: Initial GPIO OK");
}
int LoadSysConfigAndInfo(struct SysConfigData *ptr)
{
int fd, wrd;
unsigned char *buf;
unsigned int ChkSum, ChkSumOrg;
if((buf = malloc(MtdBlockSize)) == NULL)
{
LOG_ERROR("malloc buffer NG, rebooting..\n");
if(ShmStatusCodeData!=NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
memset(buf, 0, MtdBlockSize);
//================================================
// Load configuration from mtdblock10
//================================================
system("nanddump /dev/mtd10 -f /mnt/EvseConfig.bin");
fd = open("/mnt/EvseConfig.bin", O_RDWR);
if(fd < 0)
{
free(buf);
LOG_ERROR("open mtdblock10 NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
wrd = read(fd, buf, MtdBlockSize);
close(fd);
if(wrd < MtdBlockSize)
{
free(buf);
LOG_ERROR("read SysConfigData data NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
ChkSum = 0;
for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
{
ChkSum += buf[wrd];
}
memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));
memcpy(&ptr->ModelName, buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev)), ARRAY_SIZE(ptr->ModelName));
memcpy(&ptr->SerialNumber, buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev) + ARRAY_SIZE(ptr->ModelName) + ARRAY_SIZE(ptr->AcModelName)), ARRAY_SIZE(ptr->SerialNumber));
//================================================
// Load configuration from mtdblock11
//================================================
if(ChkSum != ChkSumOrg)
{
LOG_ERROR("Primary SysConfigData checksum NG, read backup\n");
system("nanddump /dev/mtd11 -f /mnt/EvseConfig.bin");
fd = open("/mnt/EvseConfig.bin", O_RDWR);
if(fd < 0)
{
free(buf);
LOG_ERROR("open mtdblock11 (backup) NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
memset(buf, 0, MtdBlockSize);
wrd = read(fd, buf, MtdBlockSize);
close(fd);
if(wrd < MtdBlockSize)
{
free(buf);
LOG_ERROR("read backup SysConfigData data NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
ChkSum = 0;
for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
{
ChkSum += buf[wrd];
}
memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));
//================================================
// Load configuration from mtdblock12 (Factory default)
//================================================
if(ChkSum != ChkSumOrg)
{
LOG_ERROR("backup SysConfigData checksum NG, read Factory default\n");
system("nanddump /dev/mtd12 -f /mnt/EvseConfig.bin");
fd = open("/mnt/EvseConfig.bin", O_RDWR);
if(fd < 0)
{
free(buf);
LOG_ERROR("open mtdblock12 (Factory default) NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
memset(buf, 0, MtdBlockSize);
wrd = read(fd, buf, MtdBlockSize);
close(fd);
if(wrd < MtdBlockSize)
{
free(buf);
LOG_ERROR("read factory default SysConfigData data NG, rebooting..\n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
ChkSum = 0;
for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
{
ChkSum += buf[wrd];
}
memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));
memcpy(buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev)), &ptr->ModelName, ARRAY_SIZE(ptr->ModelName));
memcpy(buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev) + ARRAY_SIZE(ptr->ModelName) + ARRAY_SIZE(ptr->AcModelName)), &ptr->SerialNumber, ARRAY_SIZE(ptr->SerialNumber));
if(ChkSum != ChkSumOrg)
{
LOG_ERROR("factory default SysConfigData checksum NG, restore factory default\n");
free(buf);
system("cd /root;./FactoryConfig -m");
system("rm -f /Storage/OCPP/OCPPConfiguration");
system("sync");
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
return FAIL;
}
}
}
//load OK
memcpy((struct SysConfigData *)ptr, buf, sizeof(struct SysConfigData));
free(buf);
system("rm -f /mnt/EvseConfig.bin");
// SysConfig in flash is empty (0xffffffff)
if((strlen((char*)ShmSysConfigAndInfo->SysConfig.ModelName) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName)) ||
(strlen((char*)ShmSysConfigAndInfo->SysConfig.SerialNumber) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber)) ||
(strlen((char*)ShmSysConfigAndInfo->SysConfig.SystemId) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId)) ||
(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0xff))
{
if(strlen((char*)ShmSysConfigAndInfo->SysConfig.ModelName) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName))
{
LOG_INFO("Model name over length.");
memset(ShmSysConfigAndInfo->SysConfig.ModelName, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName));
}
if(strlen((char*)ShmSysConfigAndInfo->SysConfig.SerialNumber) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber))
{
LOG_INFO("Model serial number over length.");
memset(ShmSysConfigAndInfo->SysConfig.SerialNumber, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber));
}
if(strlen((char*)ShmSysConfigAndInfo->SysConfig.SystemId) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId))
{
LOG_INFO("System id over length.");
memset(ShmSysConfigAndInfo->SysConfig.SystemId, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId));
}
if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0xff)
{
LOG_INFO("Ethernet dhcp config is null.");
}
system("cd /root;./Module_FactoryConfig -m");
sleep(3);
system("/usr/bin/run_evse_restart.sh");
}
LOG_INFO("Load SysConfigData OK");
return PASS;
}
/*
byte GetCurEthUsage()
{
byte result = _ETHERNET_USAGE_NONE;
FILE *fp;
char cmd[256];
char buf[512];
byte targetC = 2;
strcpy(cmd, "route -n");
fp = popen(cmd, "r");
if (fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if (targetC-- == 0)
{
if (strstr(buf, "eth0") > 0)
result = _ETHERNET_USAGE_LAN;
else if (strstr(buf, "mlan0") > 0)
result = _ETHERNET_USAGE_WIFI;
else if (strstr(buf, "ppp0") > 0)
result = _ETHERNET_USAGE_3G_4g;
break;
}
// if (strstr(buf, "inet addr:") > 0)
// {
// }
}
}
pclose(fp);
memset(buf, 0x00, sizeof(buf));
return result;
}
*/
int isEthernetCablePlugIn(int ethernet)
{
int fd, PlugInStatus = 0;
char ch[2];
char buffer[64];
snprintf(buffer, sizeof(buffer), "/sys/class/net/eth%d/carrier", ethernet);
fd = open(buffer, O_RDONLY);
if(fd < 0)
{
return -1;
}
if(read(fd, ch, 1) < 0)
{
return -1;
}
PlugInStatus = atoi(ch);
close(fd);
return PlugInStatus;
}
int isRouteFail()
{
int result = YES;
FILE *fp;
char buf[512];
fp = popen("route -n", "r");
if(fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if(strstr(buf, "eth0") != NULL)
result = NO;
}
}
pclose(fp);
return result;
}
int isReachableInternet()
{
int result = FAIL;
FILE *fp;
char cmd[256];
char buf[512];
char tmp[512];
// if (ShmOCPP16Data->OcppConnStatus == PASS)
// {
// result = PASS;
// }
// else
{
strcpy(cmd, "ifconfig eth0");
fp = popen(cmd, "r");
if (fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if (strstr(buf, "inet addr:") > 0)
{
sscanf(buf, "%*s%s", tmp);
substr(tmp, tmp, strspn(tmp, "addr:"), strlen(buf)-strspn(tmp, "addr:"));
if (strcmp(tmp, (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress) != EQUAL)
{
strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress, tmp);
}
}
}
}
pclose(fp);
memset(buf, 0x00, sizeof(buf));
for(int idx=0;idx<ARRAY_SIZE(valid_Internet);idx++)
{
sprintf(cmd, "ping -c 1 -w 3 -I eth0 %s", valid_Internet[idx]);
fp = popen(cmd, "r");
if(fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
if(strstr(buf, "transmitted") > 0)
{
//sscanf(buf, "%*s%*s%*s%*s%*s%*s%s", tmp);
if(strstr(buf,"100%") != NULL)
{
}
else
{
result = PASS;
}
//DEBUG_INFO("%s",buf);
//DEBUG_INFO("%s\n",tmp);
}
}
}
pclose(fp);
}
}
return result;
}
void AnnounceEthernetStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.EthernetStatusRequest = true;
}
}
}
void AnnounceWiFiStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.WiFiStatusRequest = true;
}
}
}
void AnnounceTelcomModemStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.TelcomModemStatusRequest = true;
}
}
}
void AnnounceBackendStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.BackendStatusRequest = true;
}
}
}
void AnnounceBillingStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.BillingStatusRequest = true;
}
}
}
void AnnounceStopChargingButtonStatus(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.StopButtonStatusRequest = true;
}
}
}
void AnnounceAuthModeConfig(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.AuthModeConfigRequest = true;
}
}
}
void AnnounceEVCCIDConfig(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.EVCCIDConfigRequest = true;
}
}
}
void UpdateConfigAndIcon(void)
{
unsigned char status = _Connnection_Disable;
// update ethernet connection status
status = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet == YES ? _Connnection_Disconnected : _Connnection_Connected;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus = status;
AnnounceEthernetStatus();
}
// update wifi connection status
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
{
status = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == YES ? _Connnection_Disconnected : _Connnection_Connected;
}
else
{
status = _Connnection_Disable;
}
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus = status;
AnnounceWiFiStatus();
}
// update 4g connection status
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
status = (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == NO &&
ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES) ? _Connnection_Connected : _Connnection_Disconnected;
}
else
{
status = _Connnection_Disable;
}
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus = status;
AnnounceTelcomModemStatus();
}
// update backend connection status
status = ShmStatusCodeData->InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet == YES ? _Connnection_Disconnected : _Connnection_Connected;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus = status;
AnnounceBackendStatus();
}
// update billing status
status = ShmSysConfigAndInfo->SysConfig.BillingData.isBilling;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus = status;
AnnounceBillingStatus();
}
// update stop charging button
status = ShmSysConfigAndInfo->SysConfig.StopChargingByButton;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton = status;
AnnounceStopChargingButtonStatus();
}
// update AuthMode config
status = ShmSysConfigAndInfo->SysConfig.AuthorisationMode;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.AuthModeConfig != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.AuthModeConfig = status;
AnnounceAuthModeConfig();
AnnounceEVCCIDConfig();
}
// update EVCCID config
status = ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID;
if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EVCCIDConfig != status)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EVCCIDConfig = status;
AnnounceEVCCIDConfig();
}
}
void Check4gWifiReset(void)
{
int timeDelay = 0;
if(ShmChargerInfo->Control.SysCtrl.bits.BackendEnable)
{
if((!ShmSysConfigAndInfo->SysInfo.InternetConn && !ShmSysConfigAndInfo->SysInfo.OcppConnStatus &&
(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE ||
ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)) ||
ShmStatusCodeData->FaultCode.FaultEvents.bits.Telecom4GModuleBroken == YES)
{
if(!_NeedReset4gWifi)
{
GetClockTime(&_4gWifiReset_time);
LOG_INFO("Backend Enable But Internet Not Available!");
}
_NeedReset4gWifi = true;
}
else
{
_NeedReset4gWifi = false;
}
if(_NeedReset4gWifi)
{
timeDelay = ShmStatusCodeData->FaultCode.FaultEvents.bits.Telecom4GModuleBroken == YES ?
FAST_RESET_4G_WIFI_TIME : TRY_RESET_4G_WIFI_TIME;
if(GetTimeoutValue(_4gWifiReset_time) / uSEC_VAL >= timeDelay)
{
ShmChargerInfo->Control.SysCtrl.bits.Wifi4gResetEnable = true;
usleep(100000);
// before reset 4g io, kill Module_4g & Module_Wifi task
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
system("killall Module_4g &");
}
usleep(100000);
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
{
system("killall Module_Wifi &");
}
LOG_INFO("Reset 4g_Wifi Module");
system("echo 1 > /sys/class/gpio/gpio104/value");
sleep(1);
system("echo 0 > /sys/class/gpio/gpio104/value");
_NeedReset4gWifi = false;
ShmChargerInfo->Control.SysCtrl.bits.Wifi4gResetEnable = false;
}
}
}
else
{
_NeedReset4gWifi = false;
}
}
void MasterCabinetDhcpClientConfig(void)
{
char tmpbuf[256];
//Run DHCP client if enabled
system("killall udhcpc");
system("rm -rf /etc/resolv.conf");
system("echo nameserver 8.8.8.8 > /etc/resolv.conf"); //Google DNS server
system("echo nameserver 180.76.76.76 > /etc/resolv.conf"); //Baidu DNS server
//system("/sbin/ifconfig eth0 down;/sbin/ifconfig eth0 up");
if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0)
{
sprintf(tmpbuf, "/sbin/udhcpc -i eth0 -x hostname:CSU3_%s -s /root/dhcp_script/eth0.script > /dev/null &", ShmSysConfigAndInfo->SysConfig.SystemId);
system(tmpbuf);
}
//Upgrade system id to /etc/hostname
sprintf(tmpbuf, "echo %s > /etc/hostname", ShmSysConfigAndInfo->SysConfig.SystemId);
system(tmpbuf);
}
void InitMasterCabinetEthernet(void)
{
char tmpbuf[256];
//Init Eth0 for internet
memset(tmpbuf,0,256);
sprintf(tmpbuf,"/sbin/ifconfig eth0 %s netmask %s up",
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress);
system(tmpbuf);
memset(tmpbuf,0,256);
sprintf(tmpbuf,"route add default gw %s eth0 ",
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);
system(tmpbuf);
//system("ifconfig lo up");
// /sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up
//Init Eth1 for administrator tool
memset(tmpbuf,0,256);
sprintf(tmpbuf,"/sbin/ifconfig eth1 %s netmask %s up", "192.168.100.1", "255.255.255.0");
system(tmpbuf);
}
void InitSlaveCabinetEthernet(void)
{
char tmpbuf[256];
system("/sbin/ifconfig eth0 down");
system("/sbin/ifconfig eth1 down");
system("killall udhcpc");
system("rm -rf /etc/resolv.conf");
system("pgrep -f \"udhcpd /etc/udhcpd_eth1.conf\" | xargs kill");
//Init Eth0 for internet
memset(tmpbuf,0,256);
sprintf(tmpbuf,"/sbin/ifconfig eth0 192.168.100.3%d netmask %s up",
(ShmChargerInfo->Control.CabinetSwitch - 1),
"255.255.255.0");
system(tmpbuf);
system("/sbin/route add default gw 192.168.100.1 eth0");
//Init Eth1 for internet
memset(tmpbuf,0,256);
sprintf(tmpbuf,"/sbin/ifconfig eth1 %s netmask %s up", SLAVE_ETH1_IP, SLAVE_ETH1_SUBMASK);
system(tmpbuf);
}
void InitEthernet(void)
{
system("ifconfig eth0 down");
system("ifconfig eth1 down");
sleep(2);
char tmpbuf[256];
// /sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 down
system("echo 1 > /sys/class/gpio/gpio110/value");//reset PHY
sleep(2);
InitMasterCabinetEthernet();
MasterCabinetDhcpClientConfig();
// DO360 DHCP Server
InitialDispenserDhcpServerConfig();
StartDispenserDhcpServer();
pid_t pid = fork();
uint8_t cnt_pingDNS_Fail;
if(pid == 0)
{
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus = _Connnection_Disconnected;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus = _Connnection_Disconnected;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus = _Connnection_Disable;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus = _Connnection_Disable;
LOG_INFO("Internet Fork PID = %d", getpid());
for(;;)
{
if(isEthernetCablePlugIn(0) == YES)
{
if(isRouteFail())
{
LOG_INFO("eth0 not in route, restart eht0.");
system("/sbin/ifconfig eth0 down;/sbin/ifconfig eth0 up");
if (ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0)
{
InitialDHCP();
}
else
{
system("pgrep -f \"udhcpc -i eth0\" | xargs kill");
memset(tmpbuf,0,256);
sprintf(tmpbuf,"/sbin/ifconfig eth0 %s netmask %s up &",
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress);
system(tmpbuf);
memset(tmpbuf,0,256);
sprintf(tmpbuf,"route add default gw %s eth0 &",
ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);
system(tmpbuf);
}
}
}
if(isReachableInternet() == PASS)
{
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet != NO)
{
LOG_INFO("Internet is Reachable");
}
ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet = NO;
ShmSysConfigAndInfo->SysInfo.ethInternetConn = YES;
cnt_pingDNS_Fail = 0;
}
else
{
if(++cnt_pingDNS_Fail > 3)
{
if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet != YES)
{
LOG_INFO("Internet is Disconnect Via Ethernet");
}
ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet = YES;
ShmSysConfigAndInfo->SysInfo.ethInternetConn = NO;
}
}
bool ethResult = ShmSysConfigAndInfo->SysInfo.ethInternetConn;
if(ethResult == YES)
{
system("/sbin/ifmetric eth0 0");
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
{
system("/sbin/ifmetric mlan0 1");
}
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
{
system("/sbin/ifmetric ppp0 2");
}
}
if (!ethResult &&
ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
{
ethResult = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == YES ? NO : YES;
if (ethResult)
{
if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
{
system("/sbin/ifmetric eth0 1");
system("/sbin/ifmetric mlan0 0");
}
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
{
system("/sbin/ifmetric ppp0 2");
}
}
}
if (!ethResult &&
ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
{
ethResult = (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == NO &&
ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES) ? YES : NO;
if (ethResult)
{
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
{
system("/sbin/ifmetric mlan0 2");
}
if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
{
system("/sbin/ifmetric eth0 1");
system("/sbin/ifmetric ppp0 0");
}
}
}
if(system("pidof -s OcppBackend > /dev/null") != 0)
{
ShmOCPP16Data->OcppConnStatus = false;
ShmSysConfigAndInfo->SysInfo.OcppConnStatus = false;
}
ShmSysConfigAndInfo->SysInfo.InternetConn = ethResult;
ShmStatusCodeData->InfoCode.InfoEvents.bits.WiFiDisable = ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == false ? true : false;
ShmStatusCodeData->InfoCode.InfoEvents.bits.Telocom4GModuleDisable = ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == false ? true : false;
ShmStatusCodeData->InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet = ShmSysConfigAndInfo->SysInfo.OcppConnStatus == false ? true : false;
UpdateConfigAndIcon();
Check4gWifiReset();
sleep(5);
}
}
#ifdef SystemLogMessage
LOG_INFO("[main]InitEthernet: Initial Ethernet OK.");
#endif
}
/*
int InitialRfidPort()
{
int uartO2 = open(rfidPortName, O_RDWR);
struct termios tios;
if (uartO2 != FAIL)
{
ioctl (uartO2, TCGETS, &tios);
tios.c_cflag = B19200 | 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) 1;
tios.c_lflag = 0;
tcflush(uartO2, TCIFLUSH);
ioctl(uartO2, TCSETS, &tios);
}
if (uartO2 < 0)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RfidModuleCommFail = 1;
}
return uartO2;
}
*/
void GetMacAddress()
{
for (byte index = 0; index < 2; index++)
{
int fd;
struct ifreq ifr;
char tarEth[5];
char Mac[18];
sprintf(tarEth,"eth%d",index);
fd = socket(AF_INET, SOCK_DGRAM, 0);
ifr.ifr_addr.sa_family = AF_INET;
strncpy(ifr.ifr_name, tarEth, IFNAMSIZ - 1);
ioctl(fd, SIOCGIFHWADDR, &ifr);
close(fd);
sprintf(Mac, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2],
ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]);
if (index == 0)
strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthMacAddress, Mac);
else
strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthMacAddress, Mac);
}
}
void GetFirmwareVersion()
{
// Get CSU root file system version
sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, fwVersion);
byte count = 0, chademo = 0, ccs = 0, gb = 0;
for(uint8_t idx=0;idx<3;idx++)
{
if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'J')
{
chademo++;
count++;
}
else if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'G')
{
gb++;
count++;
}
else if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'U' ||
ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'E')
{
ccs++;
count++;
}
}
if (count == 1)
{
if (chademo > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '1';
else if (ccs > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '2';
else if (gb > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '3';
}
else
{
if (chademo > 0 && ccs > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '4';
else if (chademo > 0 && gb > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '5';
else if (ccs > 0 && gb > 0)
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '6';
}
// Get network option from model name
switch(ShmSysConfigAndInfo->SysConfig.ModelName[10])
{
case 'B':
case 'U':
//Blue tooth
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '3';
break;
case 'W':
// WIFI
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '1';
break;
case 'T':
// 3G/4G
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '2';
break;
case 'D':
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '5';
break;
default:
// LAN
ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '0';
break;
}
// Get rating power from model name
memcpy(&ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[10], &ShmSysConfigAndInfo->SysConfig.ModelName[4], 0x03);
// Get IEC or UL
char _buf[3] = {0};
memcpy(_buf, &ShmSysConfigAndInfo->SysConfig.ModelName[2], 2);
if (strcmp(_buf, "YE") == EQUAL || strcmp(_buf, "YC") == EQUAL)
ShmSysConfigAndInfo->SysInfo.ChargerType = _CHARGER_TYPE_IEC;
else if (strcmp(_buf, "WU") == EQUAL)
ShmSysConfigAndInfo->SysInfo.ChargerType = _CHARGER_TYPE_UL;
}
void InitialShareMemoryInfo()
{
FILE *fp;
char cmd[512];
char buf[512];
_UpgradeNeedReboot = FALSE;
//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomApn, "Internet");
//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapId, " ");
//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapPwd, " ");
ShmSysConfigAndInfo->SysConfig.TotalConnectorCount = 0;
ShmSysConfigAndInfo->SysConfig.AcConnectorCount = 0;
ShmSysConfigAndInfo->SysInfo.FactoryConfiguration = 0;
ShmSysConfigAndInfo->SysInfo.InputVoltageR = 0;
ShmSysConfigAndInfo->SysInfo.InputVoltageS = 0;
ShmSysConfigAndInfo->SysInfo.InputVoltageT = 0;
ShmSysConfigAndInfo->SysInfo.SystemFanRotaSpeed = 0;
ShmSysConfigAndInfo->SysInfo.PsuFanRotaSpeed = 0;
ShmSysConfigAndInfo->SysInfo.AuxPower5V = 0;
ShmSysConfigAndInfo->SysInfo.AuxPower12V = 0;
ShmSysConfigAndInfo->SysInfo.AuxPower24V = 0;
ShmSysConfigAndInfo->SysInfo.AuxPower48V = 0;
sprintf((char *)ShmSysConfigAndInfo->SysInfo.CsuHwRev, "REV:5.0");
memcpy(ShmSysConfigAndInfo->SysInfo.CsuBootLoadFwRev, ShmSysConfigAndInfo->SysConfig.CsuBootLoadFwRev, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.CsuBootLoadFwRev));
sprintf(cmd, "/bin/uname -r");
fp = popen(cmd, "r");
if(fp == NULL)
sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev, "Unknown version");
else
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
strcpy((char*)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev, buf);
}
}
// 雙槍 CCS + Chademo
GetFirmwareVersion();
//sprintf((char *) ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, fwVersion);
sprintf((char *) ShmSysConfigAndInfo->SysInfo.CsuPrimFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.LcmHwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.LcmFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuHwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuPrimFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuSecFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.AuxPwrHwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.AuxPwrFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.FanModuleHwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.FanModuleFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.RelayModuleHwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.Relay2ModuleHwRev, " "); //DO360 RC2
sprintf((char *) ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev, " "); //DO360 RC2
sprintf((char *) ShmSysConfigAndInfo->SysInfo.TelcomModemFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.LedModuleFwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.Connector1FwRev, " ");
sprintf((char *) ShmSysConfigAndInfo->SysInfo.Connector2FwRev, " ");
ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp = 0;
ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp = 0;
ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp = 0;
ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp = 0;
ShmSysConfigAndInfo->SysInfo.InternetConn = 0;
ShmSysConfigAndInfo->SysInfo.OcppConnStatus = 0;
ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower = -1;
strcpy((char *) ShmSysConfigAndInfo->SysConfig.UserId, "");
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ChademoboardStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CCSboardStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail = NO;
memset(ShmSysConfigAndInfo->SysInfo.FanModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.FanModuleFwRev));
memset(ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev));
memset(ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev)); //DO360 RC2
ShmPrimaryMcuData->SelfTest_Comp = NO;
ShmRelayModuleData[0]->SelfTest_Comp = NO;
ShmRelayModuleData[1]->SelfTest_Comp = NO;
ShmFanModuleData->SelfTest_Comp = NO;
ShmLedModuleData->SelfTest_Comp = NO;
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
ShmSysConfigAndInfo->SysInfo.MainChargingMode = _MAIN_CHARGING_MODE_MAX;
ShmSysConfigAndInfo->SysInfo.ReAssignedFlag = _REASSIGNED_NONE;
ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
ShmFanModuleData->TestFanSpeed = 0;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ModelNameNoneMatchStestFail = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = NO;
ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag = NO;
ShmSysConfigAndInfo->SysConfig.AlwaysGfdFlag = NO;
LOG_INFO("DispenserSequence = %d, MaxConnectorQuantity = %d",
ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence,
ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity);
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
{
LOG_INFO("Dispenser[%d] <=> %d", i, ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i]);
}
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
memset((char *)&_BackupStatusNotification[i], 0, sizeof(struct StructStatusNotification));
}
}
int Initialization(void)
{
// 初始化卡號驗證的 Flag
ClearAuthorizedFlag();
// 初始化插槍驗證的 Flag
ClearDetectPluginFlag();
// int pinOut[2] = { 116, 115 };
for (byte count = 0; count < CONNECTOR_QUANTITY; count++)
{
chargingInfo[count]->RemoteStartFlag = NO;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStartRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStartConfirm = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStopConfirm = false;
SetOcppErrorCode(count, "NoError");
}
LOG_INFO("Initialization OK");
return PASS;
}
void InitialPsuGroupingAndLocation(void)
{
if(ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable)
{
memcpy(ShmPsuGrouping->Location, Group_to_Location_4_Gun, sizeof(ShmPsuGrouping->Location));
memcpy(ShmPsuGrouping->Layout, Location_to_Group_4_Gun, sizeof(ShmPsuGrouping->Layout));
}
else
{
memcpy(ShmPsuGrouping->Location, Group_to_Location_2_Gun, sizeof(ShmPsuGrouping->Location));
memcpy(ShmPsuGrouping->Layout, Location_to_Group_2_Gun, sizeof(ShmPsuGrouping->Layout));
}
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
ShmPsuGrouping->GroupCollection[i].Index = i;
ShmPsuGrouping->GroupCollection[i].Location = ShmPsuGrouping->Location[i];
if(ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable)
{
memcpy(&ShmPsuGrouping->GroupCollection[i].ParallelConfig[0], &GroupParallelRelay_4_Gun[i][0], GENERAL_GUN_QUANTITY);
}
else
{
memcpy(&ShmPsuGrouping->GroupCollection[i].ParallelConfig[0], &GroupParallelRelay_2_Gun[i][0], GENERAL_GUN_QUANTITY);
}
ShmChargerInfo->Control.GunAvailable[i] = NO;
}
}
void InitialMaxDispenserConnectorQuantity(void)
{
if(ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable == false)
{
ShmChargerInfo->Control.MaxDispenser = 2;
ShmChargerInfo->Control.MaxConnector = 2;
}
else
{
ShmChargerInfo->Control.MaxDispenser = GENERAL_GUN_QUANTITY;
ShmChargerInfo->Control.MaxConnector = GENERAL_GUN_QUANTITY;
}
}
void InitialAuthMode(void)
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'K')
{
ShmChargerInfo->AuthInfo.AuthMode.bits.AutoStartEnable = true;
}
}
void InitialQRCodeMode(void)
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[12] == 'A' && ShmSysConfigAndInfo->SysConfig.ModelName[13] == 'D')
{
ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_ChargeBoxId;
}
else
{
// customized
if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode)
{
ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_Customized;
}
else
{
ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_Default;
}
}
}
void InitialPowerCabinetSetting(void)
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[12] == 'A' && ShmSysConfigAndInfo->SysConfig.ModelName[13] == 'D')
{
ShmSysConfigAndInfo->SysConfig.BillingData.isBilling = true;
}
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus = ShmSysConfigAndInfo->SysConfig.BillingData.isBilling;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton = ShmSysConfigAndInfo->SysConfig.StopChargingByButton;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.AuthModeConfig = ShmSysConfigAndInfo->SysConfig.AuthorisationMode;
ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EVCCIDConfig = ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID;
}
bool InitialChargerSetting(void)
{
bool result = true;
if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'O')
{
ShmChargerInfo->Control.PrimaryCtrl.bits.AcContactorReverse = true;
ShmChargerInfo->Control.PrimaryCtrl.bits.DoorSensorReverse = true;
ShmChargerInfo->Control.SysCtrl.bits.LedBoardDisable = true;
ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable = true;
ShmChargerInfo->Control.SysCtrl.bits.DOLedIndication = true;
}
else if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'K')
{
ShmChargerInfo->Control.SysCtrl.bits.FanBoardDisable = true;
ShmChargerInfo->Control.SysCtrl.bits.LedBoardDisable = true;
ShmChargerInfo->Control.SysCtrl.bits.DKLedIndication = true;
}
else if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'B')
{
//ShmChargerInfo->Control.SysCtrl.bits.FanBoardDisable = true;
ShmChargerInfo->Control.SysCtrl.bits.LedBoardDisable = true;
ShmChargerInfo->Control.SysCtrl.bits.DOLedIndication = true;
//ShmChargerInfo->Control.SysCtrl.bits.DKLedIndication = true;
ShmChargerInfo->Control.RelayCtrl.bits.AcInputDisable = true;
ShmChargerInfo->Control.RelayCtrl.bits.DcInputEnable = true;
}
else
{
result = false;
}
InitialMaxDispenserConnectorQuantity();
InitialAuthMode();
InitialQRCodeMode();
InitialPsuGroupingAndLocation();
InitialPowerCabinetSetting();
if(!CheckConnectorTypeStatus())
{
result = false;
}
return result;
}
bool InitialSystemDefaultConfig()
{
bool result = true;
LoadSysConfigAndInfo(&ShmSysConfigAndInfo->SysConfig);
InitGPIO();
InitEthernet();
GetMacAddress();
// system("echo 1 > /sys/class/gpio/gpio110/value"); //reset PHY
// sleep(3);
// system("/sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 down");
// sleep(1);
// system("/sbin/ifconfig eth1 192.168.0.10 netmask 255.255.255.0 up");
return result;
}
/*
bool DisplaySelfTestFailReason()
{
bool result = false;
// RB、FB、407、EV 小板中有些板子無回應
if (ShmRelayModuleData->SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail = YES; result = true; }
if (ShmFanModuleData->SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail = YES; result = true; }
if (ShmPrimaryMcuData->SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail = YES; result = true; }
// if (ShmLedModuleData->SelfTest_Comp == NO)
// { ShmStatusCodeData->AlarmCode.AlarmEvents.bits.LedboardStestFail = YES; }
for (byte index = 0; index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; index++)
{
if (chargingInfo[index]->Type == _Type_Chademo)
{
if (ShmCHAdeMOData->evse[chargingInfo[index]->type_index].SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ChademoboardStestFail = YES; result = true; }
}
else if (chargingInfo[index]->Type == _Type_GB)
{
if (ShmGBTData->evse[chargingInfo[index]->type_index].SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbtboardStestFail = YES; result = true; }
}
else if (chargingInfo[index]->Type == _Type_CCS_2)
{
if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121)
{
if (ShmCcsData->V2GMessage_DIN70121[chargingInfo[index]->type_index].SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CCSboardStestFail = YES; result = true; }
}
}
}
for (byte index = 0; index < ShmSysConfigAndInfo->SysConfig.AcConnectorCount; index++)
{
// 先借 GBT 顯示
if (ac_chargingInfo[index]->SelfTest_Comp == NO)
{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcConnectorStestFail = YES; result = true; }
}
if (ShmSysConfigAndInfo->SysInfo.AcContactorStatus == NO)
{
// AC Contact 未搭上
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail = YES;
result = true;
}
else if (ShmPsuData->SystemAvailablePower <= 0 && ShmPsuData->SystemAvailableCurrent <= 0)
{
// PSU 通訊問題
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail = YES;
result = true;
}
return result;
}
*/
void SelfTestRun(void)
{
LOG_INFO("Self test.");
system("/root/Module_ChargerSelfTest &");
}
void SpawnNormalService(void)
{
system("/root/Module_EventLogging &");
system("/root/Module_PrimaryComm &");
system("/root/Module_EvComm &");
//system("/root/Module_LcmControl &");
system("/root/Module_InternalComm &");
system("/root/Module_PsuComm &");
system("/root/Module_ProduceUtils &");
system("/root/Module_CabinetParallel &");
system("/root/Module_LedIndication &");
}
void SpawnOcppService(void)
{
if(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL)
{
system("/root/OcppBackend &");
}
}
void SpawnInternetService(void)
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T')
{
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
system("/root/Module_4g &");
}
}
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
{
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
{
system("/root/Module_Wifi &");
}
}
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
{
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
system("/root/Module_4g &");
}
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
{
system("/root/Module_Wifi &");
}
}
}
int SpawnTask(void)
{
sleep(2);
SpawnNormalService();
SpawnInternetService();
return PASS;
}
int runFlashShellCmd(const char *cmd)
{
int result = FAIL;
char buf[256];
FILE *fp;
fp = popen(cmd, "r");
if(fp != NULL)
{
while(fgets(buf, sizeof(buf), fp) != NULL)
{
LOG_INFO("%s\n", buf);
}
result = PASS;
}
pclose(fp);
return result;
}
int StoreUsrConfigData(struct SysConfigData *UsrData)
{
int result = PASS;
int fd, wrd;
unsigned int i, Chk;
unsigned char *ptr, *BufTmp;
Chk = 0;
ptr = (unsigned char *)UsrData;
if((BufTmp = malloc(MtdBlockSize)) != NULL)
{
memset(BufTmp, 0, MtdBlockSize);
memcpy(BufTmp, ptr, sizeof(struct SysConfigData));
for(i = ARRAY_SIZE(UsrData->CsuBootLoadFwRev); i < MtdBlockSize - 4; i++)
{
Chk += *(BufTmp+i);
}
memcpy(BufTmp + MtdBlockSize - 4, &Chk, 4);
// Output configuration to file.
fd = open("/mnt/EvseTempConfig.bin", O_RDWR | O_CREAT | O_TRUNC);
if(fd < 0)
{
LOG_ERROR("open /mnt/EvseTempConfig.bin NG");
free(BufTmp);
return 0;
}
wrd = write(fd, BufTmp, MtdBlockSize);
close(fd);
if(wrd < MtdBlockSize)
{
LOG_ERROR("write /mnt/EvseTempConfig.bin NG");
free(BufTmp);
return 0;
}
LOG_INFO("EvseTempConfig write to file in /mnt OK.");
LOG_INFO("Erase /dev/mtd10.");
runFlashShellCmd("flash_erase /dev/mtd10 0 0");
LOG_INFO("Write /dev/mtd10.");
runFlashShellCmd("nandwrite -p /dev/mtd10 /mnt/EvseTempConfig.bin");
LOG_INFO("Erase /dev/mtd11.");
runFlashShellCmd("flash_erase /dev/mtd11 0 0");
LOG_INFO("Write /dev/mtd11.");
runFlashShellCmd("nandwrite -p /dev/mtd11 /mnt/EvseTempConfig.bin");
system("rm -f /mnt/EvseTempConfig.bin");
LOG_INFO("EvseTempConfig write to flash OK");
}
else
{
LOG_ERROR("alloc BlockSize NG");
result = FAIL;
}
if(BufTmp != NULL)
{
free(BufTmp);
}
return result;
}
//===============================================
// Common Detect Chk - Stop Charging ?
//===============================================
bool isEvBoardStopChargeFlag(byte gunIndex)
{
return chargingInfo[gunIndex]->ChargingStopFlag.bits.AlarmStop;
}
bool isNormalStopChargeFlag(byte gunIndex)
{
return (chargingInfo[gunIndex]->ChargingStopFlag.bits.NormalStop || chargingInfo[gunIndex]->ChargingStopFlag.bits.ManualStop);
}
//===============================================
// 掃描插槍狀況
//===============================================
void ClearDetectPluginFlag()
{
ShmSysConfigAndInfo->SysInfo.WaitForPlugit = NO;
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
if (chargingInfo[gun_index]->RemoteStartFlag == YES)
chargingInfo[gun_index]->RemoteStartFlag = NO;
}
if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
}
void DetectPluginStart()
{
ShmSysConfigAndInfo->SysInfo.WaitForPlugit = YES;
}
bool isDetectPlugin()
{
if(ShmSysConfigAndInfo->SysInfo.WaitForPlugit == YES)
return YES;
return NO;
}
//===============================================
// Common Detect Chk - Chademo
//===============================================
bool isEvGunLocked_chademo(byte gunIndex)
{
return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}
bool isEvContactorWelding_chademo(byte gunIndex)
{
return DetectBitValue(ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].EvDetection, 3);
}
bool isEvStopReq_chademo(byte gunIndex)
{
return DetectBitValue(ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].EvDetection, 4);
}
bool isEvStopCharging_chademo(byte gunIndex)
{
if (isEvGunLocked_chademo(gunIndex) == NO)
{
// 無鎖槍 = 停止
LOG_INFO("gun locked none (%d)", gunIndex);
return YES;
}
return NO;
}
byte isPrechargeStatus_chademo(byte gunIndex)
{
byte result = 0x00;
result = ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;
return result;
}
//===============================================
// Common Detect Chk - GB
//===============================================
bool isEvGunLocked_gb(byte gunIndex)
{
return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}
bool isEvStopCharging_gb(byte gunIndex)
{
if (isEvGunLocked_gb(gunIndex) == NO)
{
// 無鎖槍 = 停止
LOG_INFO("gun locked none.");
return YES;
}
return NO;
}
byte isPrechargeStatus_gb(byte gunIndex)
{
byte result = 0x00;
result = ShmGBTData->ev[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;
return result;
}
//===============================================
// Common Detect Chk - CCS
//===============================================
bool isEvGunLocked_ccs(byte gunIndex)
{
return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}
byte isPrechargeStatus_ccs(byte gunIndex)
{
byte result = 0x00;
if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121)
{
result = ShmCcsData->V2GMessage_DIN70121[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;
}
return result;
}
bool isEvStopCharging_ccs(byte gunIndex)
{
if (isEvGunLocked_ccs(gunIndex) == NO)
{
// 無鎖槍 = 停止
LOG_INFO("gun locked none.");
return YES;
}
return NO;
}
//===============================================
// Callback
//===============================================
void DisplayChargingInfo()
{
LOG_INFO("*********** DisplayChargingInfo ***********");
for (byte i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
if (chargingInfo[i]->SystemStatus != S_IDLE &&
chargingInfo[i]->SystemStatus != S_RESERVATION)
{
ChangeGunSelectByIndex(i);
return;
}
}
if (ShmSysConfigAndInfo->SysConfig.AcConnectorCount > 0 &&
ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc == NO_DEFINE &&
ac_chargingInfo[0]->SystemStatus >= S_PREPARNING && ac_chargingInfo[0]->SystemStatus <= S_COMPLETE)
{
ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = DEFAULT_AC_INDEX;
}
usleep(50000);
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}
void _AutoReturnTimeout()
{
LOG_INFO("*********** _AutoReturnTimeout %d*********** ", ShmSysConfigAndInfo->SysInfo.PageIndex);
if (ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_WAIT_FOR_PLUG)
{
ClearDetectPluginFlag();
}
// else if (ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_AUTHORIZ_COMP)
// {
// DetectPluginStart();
// }
usleep(50000);
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}
void _SelfTestTimeout(void)
{
if (ShmSysConfigAndInfo->SysInfo.BootingStatus != BOOT_COMPLETE)
{
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
setChargerMode(gun_index, MODE_FAULT);
}
}
ShmPsuData->Work_Step = _NO_WORKING;
ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_FAIL;
LOG_INFO("Self test timeout.");
}
void _AuthorizedTimeout()
{
if(IsAuthorizingMode())
{
LOG_INFO("*********** _AuthorizedTimeout ***********");
isCardScan = false;
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_AUTHORIZ_FAIL;
ChangeLcmByIndex(_LCM_AUTHORIZ_FAIL);
strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
ClearAuthorizedFlag();
}
}
void _DetectPlugInTimeout()
{
LOG_INFO("*********** _DetectPlugInTimeout ***********");
strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
ClearDetectPluginFlag();
usleep(50000);
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}
void _DetectEvChargingEnableTimeout(byte gunIndex)
{
if (chargingInfo[gunIndex]->Type == _Type_Chademo)
{
if(!isEvGunLocked_chademo(gunIndex))
{
LOG_INFO("*********** _DetectEvChargingEnableTimeout (chademo) ***********");
}
}
else if (chargingInfo[gunIndex]->Type == _Type_GB)
{
if(!isEvGunLocked_ccs(gunIndex))
{
LOG_INFO("*********** _DetectEvChargingEnableTimeout (gb) ***********");
}
}
else if (chargingInfo[gunIndex]->Type == _Type_CCS_2)
{
if(!isEvGunLocked_ccs(gunIndex))
{
LOG_INFO("*********** _DetectEvChargingEnableTimeout (ccs) ***********");
}
}
ChargingTerminalProcess(gunIndex);
_AutoReturnTimeout();
}
void _DetectEvseChargingEnableTimeout(byte gunIndex)
{
LOG_INFO("*********** _DetectEvseChargingEnableTimeout (GFD timeout) ***********");
//if (chargingInfo[gunIndex]->GroundFaultStatus != GFD_PASS)
{
setChargerMode(gunIndex, MODE_TERMINATING);
_AutoReturnTimeout();
}
}
void _PrepareTimeout(byte gunIndex)
{
LOG_INFO("*********** _PrepareTimeout ***********");
setChargerMode(gunIndex, MODE_TERMINATING);
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = YES;
_AutoReturnTimeout();
}
void _CcsPrechargeTimeout(byte gunIndex)
{
LOG_INFO("*********** _CcsPrechargeTimeout ***********");
setChargerMode(gunIndex, MODE_IDLE);
}
//===============================================
// 取得卡號與卡號驗證
//===============================================
bool canStartCharging()
{
char buf2[16] = "";
memset(buf2, 0, ARRAY_SIZE(buf2));
for (byte index = 0; index < strlen((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status); index++)
{
sprintf(buf2 + (index - 1) * 2, "%02X", ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status[index]);
}
sprintf(buf2, "%s", ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status);
// 因為無法得知實際的長度，所以只能用搜尋的方式
if(strcmp(buf2, "Accepted") == EQUAL)
return true;
else
{
}
return false;
}
void AuthorizingStart()
{
ShmOCPP16Data->SpMsg.bits.AuthorizeReq = YES;
ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = YES;
}
void ClearAuthorizedFlag()
{
ShmOCPP16Data->SpMsg.bits.AuthorizeConf = NO;
ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = NO;
}
bool isAuthorizedComplete()
{
if (ShmOCPP16Data->SpMsg.bits.AuthorizeConf == NO)
return false;
return true;
}
bool IsAuthorizingMode()
{
if(ShmSysConfigAndInfo->SysInfo.AuthorizeFlag == NO)
return false;
return true;
}
void ReleaseAlarmCode(byte gunIndex)
{
if (strcmp((char *)ShmOCPP16Data->StatusNotification[gunIndex].ErrorCode, "NoError") != EQUAL)
{
SetOcppErrorCode(gunIndex, "NoError");
}
if (strcmp((char *)ShmOCPP16Data->StatusNotification[gunIndex].VendorErrorCode, "") != EQUAL)
{
SetOcppVendorErrorCode(gunIndex, "");
}
if (strcmp((char *)chargingInfo[gunIndex]->ConnectorAlarmCode, "") != EQUAL)
{
strcpy((char *)chargingInfo[gunIndex]->ConnectorAlarmCode, "");
}
if (strcmp((char *)chargingInfo[gunIndex]->EvConnAlarmCode, "") != EQUAL)
{
strcpy((char *)chargingInfo[gunIndex]->EvConnAlarmCode, "");
}
if (strcmp((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemotenAlarmCode, "") != EQUAL)
{
strcpy((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemotenAlarmCode, "");
}
}
//===============================================
// EmergencyStop and Charging Stop
//===============================================
void ChargingTerminalProcess(byte gunIndex)
{
setChargerMode(gunIndex, MODE_TERMINATING);
}
void ChargingAlarmProcess(byte gunIndex)
{
UpdateErrorCodeToOcpp(gunIndex);
setChargerMode(gunIndex, MODE_ALARM);
}
void AcChargingTerminalProcess()
{
ac_chargingInfo[0]->SystemStatus = MODE_TERMINATING;
}
void StopChargingProcessByString(byte level)
{
if (level > ShmSysConfigAndInfo->SysWarningInfo.Level)
{
ShmSysConfigAndInfo->SysWarningInfo.Level = level;
}
}
void ReleaseChargingProcessByString(byte level)
{
if (level >= ShmSysConfigAndInfo->SysWarningInfo.Level)
ShmSysConfigAndInfo->SysWarningInfo.Level = 0;
}
// 一般錯誤停止充電處理函式
void BoardErrOccurByString(byte index, char *code)
{
byte level = 1;
if ((chargingInfo[index]->SystemStatus > S_IDLE && chargingInfo[index]->SystemStatus < S_TERMINATING) ||
(chargingInfo[index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
{
if (strncmp(code, "023730", 6) == EQUAL && ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop == NO)
{
ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop = YES;
}
ChargingTerminalProcess(index);
}
StopChargingProcessByString(level);
}
// 急停狀況的停止充電處理函式
void EmcOccureByString(char *code)
{
byte level = 2;
if(ShmSysConfigAndInfo->SysInfo.SelfTestSeq != _STEST_COMPLETE)
{
return;
}
// 嚴重的急停有以下幾種 : EMC 按鈕、Mainbreak、Dooropen
// 其錯誤等級為 2
if (strncmp(code, "042251", 6) == EQUAL || strncmp(code, "042252", 6) == EQUAL ||
strncmp(code, "042238", 6) == EQUAL || strncmp(code, "042267", 6) == EQUAL)
{
for (byte gun = 0; gun < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun++)
{
if ((chargingInfo[gun]->SystemStatus > S_IDLE && chargingInfo[gun]->SystemStatus < S_TERMINATING) ||
(chargingInfo[gun]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[gun]->SystemStatus <= S_CCS_PRECHARGE_ST1))
{
if (strncmp((char *)chargingInfo[gun]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[gun]->ConnectorAlarmCode, code, 6);
}
ChargingAlarmProcess(gun);
}
}
StopChargingProcessByString(level);
InformOcppErrOccur(4);
}
}
void ReleaseBoardErrOccurByString(byte index, char *code)
{
bool isTrigger = false;
byte level = 1;
if (strncmp(code, "023730", 6) == 0 && ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop == YES)
{
isTrigger = true;
ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop = NO;
}
if (isTrigger)
{
ReleaseChargingProcessByString(level);
}
}
void ReleaseEmsOccureByString(byte index, char *code)
{
bool isTrigger = false;
byte level = 2;
if (strncmp(code, "042251", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES)
{
isTrigger = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = NO;
}
else if (strncmp(code, "042252", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen == YES)
{
isTrigger = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = NO;
}
else if (strncmp(code, "042237", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip == YES)
{
isTrigger = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
}
else if (strncmp(code, "042238", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip == YES)
{
isTrigger = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
}
else if (strncmp(code, "042267", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm == YES)
{
isTrigger = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = NO;
}
if (isTrigger)
{
ReleaseChargingProcessByString(level);
}
}
//===============================================
// 確認硬體 (按鈕) 狀態
//===============================================
void ChkPrimaryStatus()
{
if(ShmChargerInfo->Control.TestCtrl.bits.ChargingSimulation)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = NO;
return;
}
if (ShmPrimaryMcuData->InputDet.bits.EmergencyButton == ABNORMAL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = YES;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = YES;
EmcOccureByString("042251");
}
else
{
ReleaseEmsOccureByString(0, "042251");
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = NO;
}
if (ShmPrimaryMcuData->InputDet.bits.AcMainBreakerDetec == ABNORMAL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = YES;
//EmcOccureByString("042238");
}
else
{
//ReleaseEmsOccureByString(0, "042238");
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
}
if (ShmPrimaryMcuData->InputDet.bits.SpdDetec == ABNORMAL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = YES;
}
else
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
}
if (ShmPrimaryMcuData->InputDet.bits.DoorOpen == ABNORMAL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = YES;
EmcOccureByString("042252");
}
else
{
ReleaseEmsOccureByString(0, "042252");
}
}
struct timespec _AcContactReOpen_Time;
void ChkPsuStatus(void)
{
if(!ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm)
{
for(int psuGroup = 0; psuGroup < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; psuGroup++)
{
if(ShmPsuData->PsuGroup[psuGroup].GroupErrorFlag.PsuGroupErrorValue != 0)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = YES;
}
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm)
{
EmcOccureByString("042267");
}
}
else
{
if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor &&
ShmChargerInfo->Control.PsuCtrl.bits.FailureResume == NO)
{
bool allFaultStatus = true;
for(int gunIndex = 0; gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gunIndex++)
{
if(chargingInfo[gunIndex]->SystemStatus != S_FAULT && chargingInfo[gunIndex]->SystemStatus != S_MAINTAIN)
{
allFaultStatus = false;
}
}
if(allFaultStatus)
{
LOG_INFO("PSU Failure, Need Resume");
ShmChargerInfo->Control.PsuCtrl.bits.FailureResume = YES;
}
}
}
}
int AcContactorReOpenCount = 0;
void PsuFailureResume(void)
{
if(ShmChargerInfo->Control.PsuCtrl.bits.FailureResume)
{
if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu == NO)
{
LOG_INFO("Ac Contactor Off By Psu Failure");
// update _AcContactReOpen_Time
GetClockTime(&_AcContactReOpen_Time);
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = YES;
AcContactorReOpenCount++;
}
else
{
if(AcContactorReOpenCount < MAX_AC_CONTACTOR_COUNT)
{
if(GetTimeoutValue(_AcContactReOpen_Time) / uSEC_VAL >= AC_CONTACTOR_REOPEN_TIME)
{
ReleaseEmsOccureByString(0, "042267");
// update _AcContactReOpen_Time
GetClockTime(&_AcContactReOpen_Time);
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = NO;
ShmChargerInfo->Control.PsuCtrl.bits.FailureResume = NO;
LOG_INFO("Psu Failure Resume");
}
}
}
}
else
{
if(AcContactorReOpenCount > 0)
{
if(GetTimeoutValue(_AcContactReOpen_Time) / uSEC_VAL >= PSU_FAILURE_RESUME_TIME)
{
AcContactorReOpenCount = 0;
}
}
}
}
void SetAcContactor(unsigned char OnOff)
{
OnOff = OnOff ? ON : OFF;
if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor != OnOff)
{
if(OnOff)
{
ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = NO;
}
LOG_INFO("Set Ac Contactor %s", OnOff == ON ? "On" : "Off");
}
ShmChargerInfo->Control.RelayCtrl.bits.AcContactor = OnOff == ON ? ON : OFF;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER && ShmChargerInfo->ParallelCabinet.ParallelStatus == _Parallel_None)
{
SetParallelCabinetAcContactor(OnOff);
}
}
void StandbyCheck(void)
{
if(IsConnectorWholeIdle() && IsParallelCabinetIdle())
{
if(ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown)
{
int time = STANDBY_TIME;
if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor)
{
if(ShmChargerInfo->Control.TestCtrl.bits.FastStandbyTime)
{
time = FAST_STANDBY_TIME;
}
if((GetTimeoutValue(_Standby_time) / uSEC_VAL) >= time)
{
SetAcContactor(OFF);
}
}
}
else
{
ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = YES;
GetClockTime(&_Standby_time);
}
}
else
{
if(ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown)
{
ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = NO;
}
}
}
void CheckDisconnectionStatusRecovery(void)
{
bool recovery = true;
// check all connector
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection)
{
recovery = false;
}
}
if(recovery)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = false;
}
}
//===============================================
// 確認各小板偵測的錯誤狀況
//===============================================
void CheckErrorOccurStatus(byte index)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.NormalStopRequest)
{
chargingInfo[index]->ChargingStopFlag.bits.NormalStop = true;
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AlarmStopRequest)
{
if(strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[index]->ConnectorAlarmCode, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemotenAlarmCode, 6);
}
if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
{
LOG_INFO("Connector %d Error Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
}
chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.TimeoutStopRequest)
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.TimeoutStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.Disconnection = true;
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = true;
if(chargingInfo[index]->SystemStatus == S_AUTHORIZING ||
chargingInfo[index]->SystemStatus == S_PREPARNING ||
chargingInfo[index]->SystemStatus == S_PREPARING_FOR_EV ||
chargingInfo[index]->SystemStatus == S_PREPARING_FOR_EVSE ||
chargingInfo[index]->SystemStatus == S_CHARGING)
{
if(strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042304", 6);
}
if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
{
LOG_INFO("Connector %d Disconnect Alarm Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
}
chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
}
else if(chargingInfo[index]->SystemStatus == S_REASSIGN_CHECK ||
chargingInfo[index]->SystemStatus == S_REASSIGN)
{
setChargerMode(index, MODE_IDLE);
}
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo)
{
CheckDisconnectionStatusRecovery();
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen)
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_PRIMARY;
StopChargingProcessByString(2);
}
if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042251", 6);
else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042252", 6);
}
}
else
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_PRIMARY)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
ReleaseChargingProcessByString(2);
}
}
// RB
if (ShmSysConfigAndInfo->SysConfig.PhaseLossPolicy == YES)
{
if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == YES ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == YES ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == YES)
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_INUVP;
StopChargingProcessByString(2);
}
if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042203", 6);
else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042204", 6);
else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042205", 6);
}
if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
{
LOG_INFO("Connector %d RC Board Input UVP Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
}
chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
}
else
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INUVP)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
ReleaseChargingProcessByString(2);
}
}
}
else
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INUVP)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
ReleaseChargingProcessByString(2);
}
}
if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == YES ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == YES ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == YES)
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_INOVP;
StopChargingProcessByString(2);
}
if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042200", 6);
else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042201", 6);
else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == YES)
memcpy(chargingInfo[index]->ConnectorAlarmCode, "042202", 6);
}
if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
{
LOG_INFO("Connector %d RC Board Input OVP Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
}
chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
}
else
{
if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INOVP)
{
ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
ReleaseChargingProcessByString(2);
}
}
}
/*
//===============================================
// 確認 GPIO 狀態
//===============================================
void gpio_set_value(unsigned int gpio, unsigned int value)
{
int fd;
char buf[MAX_BUF];
snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
fd = open(buf, O_WRONLY);
if (fd < 0)
{
perror("gpio/set-value");
return;
}
if (value)
write(fd, "1", 2);
else
write(fd, "0", 2);
close(fd);
}
int gpio_get_value(unsigned int gpio, unsigned int *value)
{
int fd;
char buf[MAX_BUF];
char ch;
snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
fd = open(buf, O_RDONLY);
if (fd < 0) {
perror("gpio/get-value");
return fd;
}
read(fd, &ch, 1);
if (ch != '0') {
*value = 1;
} else {
*value = 0;
}
close(fd);
return 0;
}
void CheckGpioInStatus()
{
int pinIn[2] = { 27, 47 };
unsigned int gpioValue = 0;
for (int i = 0; i < ARRAY_SIZE(pinIn); i++)
{
gpio_get_value(pinIn[i], &gpioValue);
if (gpioValue == 0x01)
{
switch(pinIn[i])
{
// 小板緊急停止
case 47:
{
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
if (chargingInfo[i]->slotsIndex == 1)
{
if (chargingInfo[i]->Type == _Type_Chademo)
BoardErrOccurByString(i, "023730");
else if (chargingInfo[i]->Type == _Type_CCS_2)
BoardErrOccurByString(i, "013627");
break;
}
}
}
break;
case 27:
{
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
if (chargingInfo[i]->slotsIndex == 3)
{
if (chargingInfo[i]->Type == _Type_Chademo)
BoardErrOccurByString(i, "023730");
else if (chargingInfo[i]->Type == _Type_CCS_2)
BoardErrOccurByString(i, "013627");
break;
}
}
}
break;
}
}
else
{
switch (pinIn[i])
{
// 小板解除緊急停止
case 47:
{
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
if (chargingInfo[i]->slotsIndex == 1)
{
if (chargingInfo[i]->Type == _Type_Chademo)
ReleaseBoardErrOccurByString(i, "023730");
else if (chargingInfo[i]->Type == _Type_CCS_2)
ReleaseBoardErrOccurByString(i, "013627");
break;
}
}
}
break;
case 27:
{
for (int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
if (chargingInfo[i]->slotsIndex == 3)
{
if (chargingInfo[i]->Type == _Type_Chademo)
ReleaseBoardErrOccurByString(i, "023730");
else if (chargingInfo[i]->Type == _Type_CCS_2)
ReleaseBoardErrOccurByString(i, "013627");
break;
}
}
}
break;
}
}
}
}
*/
//===============================================
// Main process
//===============================================
// 檢查 Byte 中某個 Bit 的值
// _byte : 欲改變的 byte
// _bit : 該 byte 的第幾個 bit
unsigned char DetectBitValue(unsigned char _byte, unsigned char _bit)
{
return ( _byte & mask_table[_bit] ) != 0x00;
}
// 設定 Byte 中某個 Biｔ的值
// _byte : 欲改變的 byte
// _bit : 該 byte 的第幾個 bit
// value : 修改的值為 0 or 1
void SetBitValue(unsigned char *_byte, unsigned char _bit, unsigned char value)
{
if(value == 1)
*_byte |= (1 << _bit);
else if (value == 0)
*_byte ^= (1 << _bit);
}
void UserScanFunction()
{
}
unsigned char isModeChange(unsigned char gun_index)
{
unsigned char result = NO;
if(chargingInfo[gun_index]->SystemStatus != chargingInfo[gun_index]->PreviousSystemStatus)
{
result = YES;
chargingInfo[gun_index]->PreviousSystemStatus = chargingInfo[gun_index]->SystemStatus;
}
return result;
}
void ScannerCardProcess()
{
}
struct timespec _StartAuthorizing_Time;
void PowerCabinetAuthorizingSettingInitial(void)
{
ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser = 0;
ShmSysConfigAndInfo->SysInfo.AuthorizedTarget = 0;
ShmSysConfigAndInfo->SysInfo.AuthorizedType = _AuthResult_None;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Idle;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.StartAuthorize = false;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = false;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = false;
}
void AnnounceAccountBalance(unsigned char index, int balance)
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance = true;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AccountBalance = balance;
if(!ShmChargerInfo->Control.TestCtrl.bits.DisableBalance)
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AccountBalanceRequest = true;
}
LOG_INFO("%sAnnounce Account Balance %d To Connector %d",
ShmChargerInfo->Control.TestCtrl.bits.DisableBalance ? "Do Not " : "", balance, index + 1);
}
void FouceAnnounceAccountBalance(unsigned char index)
{
if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance)
{
AnnounceAccountBalance(index, 0);
}
}
void CleanConnectorUserIdAndPrice(unsigned char index)
{
if(chargingInfo[index]->SystemStatus == S_IDLE)
{
LOG_INFO("*********** Connector %d Clean UserId & UserPrice ***********", index + 1);
memset(chargingInfo[index]->StartUserId, 0x00, 32);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].UserPrice = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AccountBalance = -6553500;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance = false;
}
}
void DispenserAuthorizationInitial(unsigned char dispenser)
{
LOG_INFO("*********** Dispenser %d Authorizing Initial ***********", dispenser + 1);
memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].UserId, 0x00, 32);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Idle;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthTarget = 0;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType = _AuthType_None;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_None;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection = false;
}
void ConnectorAuthorizationInitial(unsigned char connector)
{
LOG_INFO("*********** Connector %d Authorizing Initial ***********", connector + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingType = _AuthType_None;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult = _AuthResult_None;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.SwipeRfidConfirm = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartConfirm = false;
chargingInfo[connector]->RemoteStartFlag = false;
CleanConnectorUserIdAndPrice(connector);
}
void SetAuthorizingTarget(unsigned char dispenser, unsigned char target, unsigned char type)
{
memset(ShmSysConfigAndInfo->SysConfig.UserId, 0x00, 32);
switch(type)
{
case _AuthType_RFID:
LOG_INFO("*********** Dispenser %d Target %02X RFID Authorize ***********", dispenser + 1, target);
memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].UserId, 32);
break;
case _AuthType_RemoteStart:
LOG_INFO("*********** Connector %d Remote Start Authorize ***********", target);
memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmOCPP16Data->RemoteStartTransaction[target - 1].IdTag, 20);
break;
}
if(target == AUTO_GUN_SELECTION)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection = true;
}
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Busy;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType = type;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.StartAuthorize = true;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = false;
ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser = dispenser;
ShmSysConfigAndInfo->SysInfo.AuthorizedTarget = target;
ShmSysConfigAndInfo->SysInfo.AuthorizedType = type;
}
void OCPPAuthorizingStart(void)
{
ShmOCPP16Data->SpMsg.bits.AuthorizeConf = false;
ShmOCPP16Data->SpMsg.bits.AuthorizeReq = true;
}
void AuthorizeTimeoutProcess(void)
{
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AuthorizingResult == _AuthResult_Invalid)
{
FouceAnnounceAccountBalance(index);
if(GetTimeoutValue(_ConnectorAuthorizeFail_Time[index]) / uSEC_VAL >= AUTHORIZE_FAIL_TIMEOUT)
{
LOG_INFO("*********** Connector id %d Authorized Fail Return ***********", index + 1);
ConnectorAuthorizationInitial(index);
}
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthStatus == _AuthorizeStatus_End)
{
int CompletedTime = 0;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthTarget != AUTO_GUN_SELECTION)
{
CompletedTime = DISPENSER_AUTH_COMP_TIME;
}
else
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthResult == _AuthResult_Valid)
{
CompletedTime = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout;
}
else
{
CompletedTime = AUTHORIZE_FAIL_TIMEOUT;
}
}
if(GetTimeoutValue(_DispenserAuthorizing_Time[index]) / uSEC_VAL >= CompletedTime)
{
LOG_INFO("*********** Dispenser id %d Authorized Return ***********", index + 1);
DispenserAuthorizationInitial(index);
}
}
}
}
bool IsNewAuthorizingRequest(void)
{
bool NewRequest = false;
bool FindRemoteStartRequest = false;
// remote start check
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmOCPP16Data->CsMsg.bits[index].RemoteStartTransactionReq == true)
{
unsigned char dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].ParentDispensetIndex;
SetAuthorizingTarget(dispenser, index + 1, _AuthType_RemoteStart);
ShmOCPP16Data->CsMsg.bits[index].RemoteStartTransactionReq = false;
chargingInfo[index]->RemoteStartFlag = true;
FindRemoteStartRequest = true;
NewRequest = true;
break;
}
}
if(!FindRemoteStartRequest)
{
// local rfid authorize check
for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthStatus == _AuthorizeStatus_Idle &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.AuthorizeRequest == true)
{
if(strlen((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].UserId) > 0)
{
SetAuthorizingTarget(index, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthTarget, _AuthType_RFID);
NewRequest = true;
}
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.AuthorizeRequest = false;
}
}
}
return NewRequest;
}
void PowerCabinetAuthorizeProcess(void)
{
unsigned char dispenser = 0, connector = 0;
dispenser = ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser;
AuthorizeTimeoutProcess();
switch(ShmSysConfigAndInfo->SysInfo.AuthorizedStatus)
{
case _AuthorizeStatus_Idle:
if(IsNewAuthorizingRequest())
{
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Wait;
}
break;
case _AuthorizeStatus_Wait:
if(ShmSysConfigAndInfo->SysInfo.AuthorizedType == _AuthType_RemoteStart)
{
LOG_INFO("*********** Connector %d Remote Start Authorizing Bypass ***********",
ShmSysConfigAndInfo->SysInfo.AuthorizedTarget);
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Valid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
else
{
if(ShmOCPP16Data->OcppConnStatus)
{
LOG_INFO("*********** Dispenser %d OPCC AuthorizeReq ***********", dispenser + 1);
OCPPAuthorizingStart();
}
else
{
LOG_INFO("*********** Dispenser %d Start Local Authorizing ***********", dispenser + 1);
}
// update start authorizing timeout
GetClockTime(&_StartAuthorizing_Time);
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Busy;
}
break;
case _AuthorizeStatus_Busy:
if(GetTimeoutValue(_StartAuthorizing_Time) / uSEC_VAL >= AUTHORIZE_TIMEOUT)
{
LOG_INFO("*********** Dispenser %d Authorizing Timeout ***********", dispenser + 1);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
else
{
if(ShmOCPP16Data->OcppConnStatus)
{
if(ShmOCPP16Data->SpMsg.bits.AuthorizeConf)
{
BOOL accept = false;
if(strcmp((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Accepted") == EQUAL)
{
accept = true;
}
LOG_INFO("*********** Dispenser %d OCPP Authorize %s ***********", dispenser + 1, accept ? "OK" : "NG");
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = accept ? _AuthResult_Valid : _AuthResult_Invalid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
}
else
{
if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING)
{
LOG_INFO("*********** Dispenser %d No Charging ***********", dispenser + 1);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
else if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_FREE_CHARGING)
{
// set authorize pass when offline policy is free charge
LOG_INFO("*********** Dispenser %d Free Charging ***********", dispenser + 1);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Valid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
else if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_LOCAL_LIST)
{
BOOL find = false;
// check white list
for(int i = 0; i < 10; i++)
{
if (strcmp((char *)ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[i], "") != EQUAL)
{
if (strcmp((char *)ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[i], (char *)ShmSysConfigAndInfo->SysConfig.UserId) == EQUAL)
{
find = true;
LOG_INFO("*********** Dispenser %d White Card OK ***********", dispenser + 1);
break;
}
}
}
if(find == false)
{
if(ShmChargerInfo->AuthInfo.AuthMode.bits.AutoStartEnable &&
strcmp((char *)ShmSysConfigAndInfo->SysConfig.UserId, AUTO_START_CHARGING) == EQUAL)
{
find = true;
LOG_INFO("******** Dispenser %d Auto Start Charging ********", dispenser + 1);
}
}
LOG_INFO("*********** Dispenser %d Local Authorization %s ***********", dispenser + 1, find ? "OK" : "NG");
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = find ? _AuthResult_Valid : _AuthResult_Invalid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
else
{
LOG_INFO("*********** Dispenser %d Invalid Policy ***********", dispenser + 1);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
}
}
}
break;
case _AuthorizeStatus_Done:
if(ShmSysConfigAndInfo->SysInfo.AuthorizedTarget == AUTO_GUN_SELECTION)
{
// auto gun selection
}
else
{
connector = ShmSysConfigAndInfo->SysInfo.AuthorizedTarget - 1;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingType = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.SystemStatus == S_IDLE &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Valid)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType == _AuthType_RFID)
{
LOG_INFO("*********** Connector %d RFID Authorize OK ***********", connector + 1);
memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.StartUserId, ShmSysConfigAndInfo->SysConfig.UserId, 32);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType == _AuthType_RemoteStart)
{
LOG_INFO("*********** Connector id %d RemoteAuthorize OK ***********", connector + 1);
memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.StartUserId, ShmSysConfigAndInfo->SysConfig.UserId, 32);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest = true;
}
}
else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Invalid)
{
// update connector authorizing timeout
GetClockTime(&_ConnectorAuthorizeFail_Time[connector]);
}
}
// authorize completed
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = true;
// update dispenser authorizing timeout
GetClockTime(&_DispenserAuthorizing_Time[dispenser]);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_End;
// update authorizing completed timeout
GetClockTime(&_StartAuthorizing_Time);
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_End;
break;
case _AuthorizeStatus_End:
if(GetTimeoutValue(_StartAuthorizing_Time) / uSEC_VAL >= AUTHORIZE_COMP_TIMEOUT)
{
LOG_INFO("*********** PowerCabinet Authorize Completed ***********");
PowerCabinetAuthorizingSettingInitial();
}
break;
default:
// update authorizing completed timeout
GetClockTime(&_StartAuthorizing_Time);
ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_End;
break;
}
}
BOOL IsConnectorAuthorizeSuccess(unsigned char connector)
{
BOOL success = false;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult == _AuthResult_Valid)
{
success = true;
}
return success;
}
BOOL IsAutoGunSelectionAuthorizeSuccess(unsigned char connector)
{
BOOL success = false;
unsigned char dispenser = 0;
dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].ParentDispensetIndex;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Valid)
{
success = true;
}
return success;
}
/*
bool AddGunInfoByConnector(byte typeValue, byte slots)
{
bool result = true;
switch (typeValue)
{
case '0': // none
break;
case '1': // IEC 62196-2 Type 1/SAE J1772 Plug
break;
case '2': // IEC 62196-2 Type 1/SAE J1772 Socket
break;
case '3': // IEC 62196-2 Type 2 Plug
case '4': // IEC 62196-2 Type 2 Socket
if (AC_QUANTITY > _ac_Index)
{
ac_chargingInfo[_acgunIndex] = &ShmSysConfigAndInfo->SysInfo.AcChargingData[_ac_Index];
// AC 固定 index
ac_chargingInfo[_acgunIndex]->Index = 0;
ac_chargingInfo[_acgunIndex]->ReservationId = -1;
ac_chargingInfo[_acgunIndex]->SystemStatus = S_IDLE;
ac_chargingInfo[_acgunIndex]->Type = _Type_AC;
ac_chargingInfo[_acgunIndex]->IsAvailable = YES;
_ac_Index++;
_acgunIndex++;
}
else
result = false;
break;
case '5': // GB/T AC Plug
break;
case '6': // GB/T AC Socket
break;
case 'J': // CHAdeMO
{
if (CHAdeMO_QUANTITY > _chademoIndex)
{
chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.ChademoChargingData[_chademoIndex];
chargingInfo[_gunIndex]->Index = _gunIndex;
chargingInfo[_gunIndex]->ReservationId = -1;
chargingInfo[_gunIndex]->slotsIndex = slots;
chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
chargingInfo[_gunIndex]->Type = _Type_Chademo;
chargingInfo[_gunIndex]->type_index = _chademoIndex;
chargingInfo[_gunIndex]->IsAvailable = YES;
_chademoIndex++;
_gunIndex++;
}
else
result = false;
}
break;
case 'U': // CCS1 combo
case 'E': // CCS2 combo
{
if (CCS_QUANTITY > _ccsIndex)
{
chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[_ccsIndex];
chargingInfo[_gunIndex]->Index = _gunIndex;
chargingInfo[_gunIndex]->ReservationId = -1;
chargingInfo[_gunIndex]->slotsIndex = slots;
chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
chargingInfo[_gunIndex]->Type = _Type_CCS_2;
chargingInfo[_gunIndex]->type_index = _ccsIndex;
chargingInfo[_gunIndex]->IsAvailable = YES;
// 現階段預設為走 DIN70121
ShmCcsData->CommProtocol = _CCS_COMM_V2GMessage_DIN70121;
_ccsIndex++;
_gunIndex++;
}
else
result = false;
}
break;
case 'G': // GBT DC
{
if (GB_QUANTITY > _gb_Index)
{
chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.GbChargingData[_gb_Index];
chargingInfo[_gunIndex]->Index = _gunIndex;
chargingInfo[_gunIndex]->ReservationId = -1;
chargingInfo[_gunIndex]->slotsIndex = slots;
chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
chargingInfo[_gunIndex]->Type = _Type_GB;
chargingInfo[_gunIndex]->type_index = _gb_Index;
chargingInfo[_gunIndex]->IsAvailable = YES;
_gb_Index++;
_gunIndex++;
}
else
result = false;
}
break;
case 'D': // GBT DC x 2
break;
}
return result;
}
*/
unsigned short ParsingRatingPower(char *modelname)
{
char strVal[3], strExp[2];
unsigned short value = 0, exponent = 0;
memset(strVal, 0x00, sizeof(strVal));
memset(strExp, 0x00, sizeof(strExp));
memcpy(strVal, &modelname[4], 2);
memcpy(strExp, &modelname[6], 1);
value = atoi(strVal);
exponent = atoi(strExp);
if(value < 0 || exponent < 0)
{
return 0;
}
for(int i = 0; i < exponent; i++)
{
value *= 10;
}
return value;
}
bool CheckConnectorTypeStatus(void)
{
bool result = true;
if (strlen((char *) ShmSysConfigAndInfo->SysConfig.ModelName) >= 14)
{
// DO360 for Audi, two gun only
_gunIndex = ShmChargerInfo->Control.MaxConnector;
ShmSysConfigAndInfo->SysConfig.TotalConnectorCount = _gunIndex;
ShmChargerInfo->Control.ChargerRatingPower = ParsingRatingPower((char *)ShmSysConfigAndInfo->SysConfig.ModelName);
LOG_INFO("DC Gun Count = %d, RatingPower = %d.%d kW",
ShmSysConfigAndInfo->SysConfig.TotalConnectorCount,
(ShmChargerInfo->Control.ChargerRatingPower / 10),
(ShmChargerInfo->Control.ChargerRatingPower % 10));
if(ShmSysConfigAndInfo->SysConfig.TotalConnectorCount == 0)
{
result = false;
}
//DO360 charging info default setting
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
chargingInfo[i] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData;
chargingInfo[i]->Index = (i < ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity || i == 0) ? i : 0xFF;
chargingInfo[i]->Evboard_id = 0x00;
chargingInfo[i]->ReservationId = -1;
chargingInfo[i]->slotsIndex = 0;
chargingInfo[i]->SystemStatus = S_BOOTING;
chargingInfo[i]->Type = _Type_Unknown;
chargingInfo[i]->type_index = 0;
chargingInfo[i]->IsAvailable = YES;
}
}
else
{
// Module Name 不正確 - 告警
result = false;
}
return result;
}
void KillTaskExceptPrimary()
{
ChangeLcmByIndex(_LCM_FIX);
system("killall Module_CabinetParallel");
system("killall Module_ChargerSelfTest");
system("killall Module_LedIndication");
system("killall Module_EvComm");
system("killall Module_InternalComm");
system("killall Module_PsuComm");
system("killall Module_4g &");
system("killall Module_Wifi &");
}
void KillAllTask()
{
ChangeLcmByIndex(_LCM_FIX);
system("killall Module_CabinetParallel");
system("killall Module_ChargerSelfTest");
system("killall Module_LedIndication");
system("killall Module_EventLogging");
system("killall Module_PrimaryComm");
system("killall Module_EvComm");
system("killall Module_LcmControl");
system("killall Module_InternalComm");
system("killall Module_PsuComm");
system("killall OcppBackend &");
system("killall Module_4g &");
system("killall Module_Wifi &");
}
int TransferImageViaFTP(char *IpAddress, char *SourcePath)
{
int isPass = PASS;
unsigned char ftpcmdbuf[256];
LOG_INFO("Transfer image(%s) to ip: %s ", SourcePath, IpAddress);
//Using ftpput command to transfer upgrade image,
//User name : root
//User password : y42j/4cj84
//Destination : as same as source path
sprintf((char*)ftpcmdbuf,"ftpput -u root -p y42j/4cj84 %s %s %s", IpAddress, SourcePath, SourcePath);
if(system((char*)ftpcmdbuf) != 0)
{
isPass = FAIL;
LOG_INFO("Transfer Image NG - FTP put upgrade image to fail");
}
else
{
LOG_INFO("FTP put Image OK");
}
return isPass;
}
void TriggerDispenserUpgrade(unsigned char index, char *FileName)
{
memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].FwFileName, 0x00, 128);
memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].FwFileName, FileName, strlen(FileName));
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.FirmwareUpdateRequest = true;
LOG_INFO("Trigger dispenser %d to update image [%s]", index + 1, FileName);
}
BOOL PutImageToAllDispenser(char *SourcePath, char *FileName)
{
int isPass = FAIL;
BOOL transferred = FALSE;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_DispenserMatched)
{
char DispenserIpAddress[16];
memset((char*)DispenserIpAddress, 0x00, 16);
sprintf((char*)DispenserIpAddress, "%d.%d.%d.%d",
((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 0) & 0xFF),
((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 8) & 0xFF),
((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 16) & 0xFF),
((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 24) & 0xFF));
isPass = TransferImageViaFTP(DispenserIpAddress, SourcePath);
if(isPass == PASS)
{
TriggerDispenserUpgrade(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex, FileName);
}
transferred = true;
}
}
return transferred;
}
BOOL WaitAllDispenserUpgradeCompleted(void)
{
BOOL completed = TRUE;
GetClockTime(&_DispenserUpgrade_time);
do
{
completed = TRUE;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateConfirm)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateCompleted)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateRequest = false;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateConfirm = false;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateCompleted = false;
LOG_INFO("Dispenser %d Upgrade Success", i + 1);
}
else
{
completed = FALSE;
}
}
}
if(GetTimeoutValue(_DispenserUpgrade_time) / uSEC_VAL >= DISPENSER_UPGRADE_TIME)
{
LOG_INFO("Wait Upgrade Timeout");
completed = FALSE;
break;
}
if(completed == FALSE)
{
sleep(1);
}
}while(!completed);
return completed;
}
void UpgradePrepare(void)
{
int count = 0;
SetAcContactor(OFF);
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Alarm ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Charging)
{
count++;
}
}
}
if(count > 0)
{
sleep(3);
}
else
{
sleep(1);
}
}
void TriggerPCabinetUpgrade(unsigned char index, char *FileName)
{
memset(ShmChargerInfo->ParallelCabinet.PCabinet[index].FwFileName, 0x00, 128);
memcpy(ShmChargerInfo->ParallelCabinet.PCabinet[index].FwFileName, FileName, strlen(FileName));
ShmChargerInfo->ParallelCabinet.PCabinet[index].UpdateRequest = YES;
LOG_INFO("Trigger PCabinet %d to update image [%s]", index + 1, FileName);
}
BOOL PutImageToAllParallelCabinet(char *SourcePath, char *FileName)
{
int isPass = FAIL;
BOOL transferred = FALSE;
for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Alarm ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Charging)
{
int channel = ShmChargerInfo->ParallelCabinet.PCabinet[i].SocketChannel;
if(ShmChargerInfo->CabinetConnInfo[channel].Status == _SCONN_MATCHED &&
ShmChargerInfo->ParallelCabinet.PCUpdateState[i] == Not_Update)
{
char PCabinetIpAddress[16];
memset((char*)PCabinetIpAddress, 0x00, 16);
sprintf((char*)PCabinetIpAddress, "%d.%d.%d.%d",
((ShmChargerInfo->CabinetConnInfo[channel].IpAddress >> 0) & 0xFF),
((ShmChargerInfo->CabinetConnInfo[channel].IpAddress >> 8) & 0xFF),
((ShmChargerInfo->CabinetConnInfo[channel].IpAddress >> 16) & 0xFF),
((ShmChargerInfo->CabinetConnInfo[channel].IpAddress >> 24) & 0xFF));
isPass = TransferImageViaFTP(PCabinetIpAddress, SourcePath);
if(isPass == PASS)
{
TriggerPCabinetUpgrade(i, FileName);
}
transferred = true;
}
}
}
return transferred;
}
BOOL WaitAllPCabinetStartUpgrade(void)
{
BOOL isStart = true;
int count = 0;
struct timespec _waitStart;
GetClockTime(&_waitStart);
do
{
isStart = true;
count = 0;
for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Alarm ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Charging)
{
count++;
if(ShmChargerInfo->ParallelCabinet.PCUpdateState[i] != Updating)
{
isStart = false;
}
}
}
if((GetTimeoutValue(_waitStart) / uSEC_VAL) >= START_UPGRADE_TIME)
{
isStart = false;
break;
}
usleep(10000);
}while(!isStart);
if(isStart && count > 0)
{
LOG_INFO("Total %d PCabinet upgrade start...", count);
}
else
{
if(count > 0)
{
LOG_INFO("Wait PCabinet upgrade timeout");
}
else
{
LOG_INFO("No PCabinet need to upgrade");
}
}
return isStart;
}
BOOL WaitAllPCabinetUpgradeCompleted(void)
{
BOOL completed = true;
int count = 0;
struct timespec _waitCompleted;
GetClockTime(&_waitCompleted);
do
{
completed = true;
count = 0;
for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Alarm ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Charging)
{
count++;
if(ShmChargerInfo->ParallelCabinet.PCUpdateState[i] != Updated)
{
completed = false;
}
}
}
if((GetTimeoutValue(_waitCompleted) / uSEC_VAL) >= PCABINET_UPGRADE_TIME)
{
completed = false;
break;
}
usleep(10000);
}while(!completed);
if(completed && count > 0)
{
LOG_INFO("Total %d PCabinet upgrade completed!", count);
}
else
{
if(count > 0)
{
LOG_INFO("Wait PCabinet upgrade completed timeout");
}
else
{
LOG_INFO("Need not to wait PCabinet completed");
}
}
return completed;
}
BOOL WaitMCabinetUpgradeCompleted(void)
{
BOOL completed = true;
struct timespec _waitCompleted;
GetClockTime(&_waitCompleted);
do
{
completed = false;
if(ShmChargerInfo->SCabinetControl.NeedUpgrade == _R_NoUpgrade)
{
completed = true;
}
if(ShmChargerInfo->SCabinetControl.SCabinetStatus != _DeviceStatus_Idle &&
ShmChargerInfo->SCabinetControl.SCabinetStatus != _DeviceStatus_Alarm &&
ShmChargerInfo->SCabinetControl.SCabinetStatus != _DeviceStatus_Charging)
{
completed = false;
break;
}
if((GetTimeoutValue(_waitCompleted) / uSEC_VAL) >= MCABINET_UPGRADE_TIME)
{
completed = false;
break;
}
usleep(10000);
}while(!completed);
if(completed)
{
LOG_INFO("MCabinet upgrade completed!");
}
else
{
LOG_INFO("Wait MCabinet upgrade timeout or disconnected...");
}
return completed;
}
bool IsModelNameMatch(char *model)
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == model[0] &&
ShmSysConfigAndInfo->SysConfig.ModelName[1] == model[1] &&
ShmSysConfigAndInfo->SysConfig.ModelName[7] == model[7] &&
ShmSysConfigAndInfo->SysConfig.ModelName[8] == model[8] &&
ShmSysConfigAndInfo->SysConfig.ModelName[9] == model[9] &&
ShmSysConfigAndInfo->SysConfig.ModelName[11] == model[11] &&
ShmSysConfigAndInfo->SysConfig.ModelName[12] == model[12] &&
ShmSysConfigAndInfo->SysConfig.ModelName[13] == model[13])
{
return true;
}
return false;
}
char CheckUpdateProcess()
{
char model[32];
bool support = false;
bool OneImageOnly = false;
int isPass = true;
uint8_t retSucc = 0;
uint8_t retFail = 0;
byte target = 0;
char *new_str = NULL;
unsigned char *ptr = NULL;
int fd = 0;
int uartFd = 0;
unsigned int Type = 0;
long int MaxLen = 48 * 1024 * 1024, ImageLen = 0;
DIR *d;
struct dirent *dir;
char cmdBuf[128];
d = opendir("/mnt/");
if(d)
{
while((dir = readdir(d)) != NULL && !OneImageOnly)
{
if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
continue;
}
new_str = calloc(strlen("/mnt/") + strlen(dir->d_name) + 1, sizeof(char));
strcat(new_str, "/mnt/");
strcat(new_str, dir->d_name);
fd = open(new_str, O_RDONLY);
if(fd < 0)
{
close(fd);
free(new_str);
continue;
}
LOG_INFO("%s\n", new_str);
ptr = calloc(MaxLen, sizeof(char)); //-48 is take out the header
memset(ptr, 0xFF, MaxLen); //-48 is take out the header
//get the image length
ImageLen = read(fd, ptr, MaxLen);
if (ImageLen > 20)
{
support = false;
memcpy(model, ptr, 16);
LOG_INFO("Model: %s", model);
Type = (((unsigned int)ptr[16]) << 24 | ((unsigned int)ptr[17]) << 16 | ((unsigned int)ptr[18]) << 8 | ((unsigned int)ptr[19]));
LOG_INFO("Typed...%x", Type);
//if(strcmp(model, (char *)ShmSysConfigAndInfo->SysConfig.ModelName) == EQUAL)
if(IsModelNameMatch(model))
{
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
PutImageToAllParallelCabinet(new_str, dir->d_name);
WaitAllPCabinetStartUpgrade();
}
if(ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE && ShmChargerInfo->SCabinetControl.NeedUpgrade)
{
ShmChargerInfo->SCabinetControl.UpgradeState = Updating;
sleep(1);
}
switch (Type)
{
case 0x10000001:
case 0x10000002:
case 0x10000003:
case 0x10000004:
case 0x10000005:
support = true;
_UpgradeNeedReboot = TRUE;
isPass = Upgrade_Flash(Type, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
break;
case 0x10000006: // primary mcu
case 0x1000000D: // relay board
case 0x1000000E: // fan board
case 0x10000014: // led board
support = true;
target = 0x00;
if (Type == 0x10000006)
{
target = UPGRADE_PRI;
}
else if (Type == 0x1000000D)
{
target = UPGRADE_RB;
}
else if (Type == 0x1000000E)
{
target = UPGRADE_FAN;
}
else if (Type == 0x10000014)
{
target = UPGRADE_LED;
}
uartFd = InitComPort(target);
if(target == UPGRADE_RB)
{
isPass = Upgrade_UART(uartFd, Type, UPGRADE_DORC1, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
if(isPass == PASS)
{
retSucc++;
}
else
{
retFail++;
}
LOG_INFO("Upgrade %s", isPass == PASS ? "Success" : "Fail");
sleep(3);
isPass = Upgrade_UART(uartFd, Type, UPGRADE_DORC2, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
}
else
{
isPass = Upgrade_UART(uartFd, Type, target, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
}
close(uartFd);
break;
}
if(support)
{
if(isPass == PASS)
{
retSucc++;
}
else
{
retFail++;
}
LOG_INFO("Upgrade %s", isPass == PASS ? "Success" : "Fail");
}
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
LOG_INFO("MCabinet upgrade completed");
WaitAllPCabinetUpgradeCompleted();
}
if(ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE && ShmChargerInfo->SCabinetControl.UpgradeState == Updating)
{
ShmChargerInfo->SCabinetControl.UpgradeState = Updated;
LOG_INFO("SCabinet upgrade completed");
WaitMCabinetUpgradeCompleted();
}
}
else
{
if(model[0] == 'D' && (model[1] == 'D' || model[1] == 'X'))
{
OneImageOnly = true;
_UpgradeNeedReboot = TRUE;
LOG_INFO("Start Put Image To All Dispenser");
PutImageToAllDispenser(new_str, dir->d_name);
WaitAllDispenserUpgradeCompleted();
LOG_INFO("All Dispenser Upgrade Completed");
}
}
}
sprintf(cmdBuf, "rm -f %s", new_str);
system(cmdBuf);
close(fd);
free(new_str);
free(ptr);
}
}
free(dir);
closedir(d);
if(retFail != 0)
{
return FAIL;
}
return PASS;
}
/*
void CreateRfidFork()
{
pid_t rfidRecPid;
rfidRecPid = fork();
if (rfidRecPid == 0)
{
while(true)
{
// 刷卡判斷
RFID rfid;
if (ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING ||
!ShmSysConfigAndInfo->SysConfig.isRFID)
{}
else if(getRequestCardSN(rfidFd, 0, &rfid))
{
PRINTF_FUNC("Get Card..-%s- \n", ShmSysConfigAndInfo->SysConfig.UserId);
if (strlen((char *)ShmSysConfigAndInfo->SysConfig.UserId) == 0)
{
if (ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian == RFID_ENDIAN_LITTLE)
{
switch (rfid.snType)
{
case RFID_SN_TYPE_6BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X",
rfid.currentCard[0], rfid.currentCard[1],
rfid.currentCard[2], rfid.currentCard[3],
rfid.currentCard[4], rfid.currentCard[5]);
break;
case RFID_SN_TYPE_7BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X%02X",
rfid.currentCard[0], rfid.currentCard[1],
rfid.currentCard[2], rfid.currentCard[3],
rfid.currentCard[4], rfid.currentCard[5],
rfid.currentCard[6]);
break;
case RFID_SN_TYPE_10BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
rfid.currentCard[0], rfid.currentCard[1],
rfid.currentCard[2], rfid.currentCard[3],
rfid.currentCard[4], rfid.currentCard[5],
rfid.currentCard[6], rfid.currentCard[7],
rfid.currentCard[8], rfid.currentCard[9]);
break;
case RFID_SN_TYPE_4BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X",
rfid.currentCard[0], rfid.currentCard[1],
rfid.currentCard[2], rfid.currentCard[3]);
break;
}
}
else if (ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian == RFID_ENDIAN_BIG)
{
switch (rfid.snType)
{
case RFID_SN_TYPE_6BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X",
rfid.currentCard[5], rfid.currentCard[4],
rfid.currentCard[3], rfid.currentCard[2],
rfid.currentCard[1], rfid.currentCard[0]);
break;
case RFID_SN_TYPE_7BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X%02X",
rfid.currentCard[6], rfid.currentCard[5],
rfid.currentCard[4], rfid.currentCard[3],
rfid.currentCard[2], rfid.currentCard[1],
rfid.currentCard[0]);
break;
case RFID_SN_TYPE_10BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
rfid.currentCard[9], rfid.currentCard[8],
rfid.currentCard[7], rfid.currentCard[6],
rfid.currentCard[5], rfid.currentCard[4],
rfid.currentCard[3], rfid.currentCard[2],
rfid.currentCard[1], rfid.currentCard[0]);
break;
case RFID_SN_TYPE_4BYTE:
sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
"%02X%02X%02X%02X",
rfid.currentCard[3], rfid.currentCard[2],
rfid.currentCard[1], rfid.currentCard[0]);
break;
}
}
LOG_INFOUNC("card number = %s\n", ShmSysConfigAndInfo->SysConfig.UserId);
}
}
sleep(1);
}
}
}
*/
#if 0
void StartSystemTimeoutDet(unsigned char flag)
{
if (ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag != flag)
{
gettimeofday(&ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer, NULL);
}
ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag = flag;
}
void StopSystemTimeoutDet()
{
gettimeofday(&ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer, NULL);
ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag = Timeout_None;
}
void StartGunInfoTimeoutDet(unsigned char gunIndex, unsigned char flag)
{
if (gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount)
{
if (chargingInfo[gunIndex]->TimeoutFlag != flag)
{
gettimeofday(&chargingInfo[gunIndex]->TimeoutTimer, NULL);
}
chargingInfo[gunIndex]->TimeoutFlag = flag;
}
}
void StopGunInfoTimeoutDet(unsigned char gunIndex)
{
if (gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount)
{
chargingInfo[gunIndex]->TimeoutFlag = Timeout_None;
}
}
#endif
void TriggerDispenserConnectionTimeoutSetting(void)
{
BOOL trigger = FALSE;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.ConnectorTimeoutConfigRequest = 1;
trigger = TRUE;
}
}
if(trigger)
{
LOG_INFO("********** Trigger Dispenser Connector Timeout Value: %d **********", ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout);
}
}
void CheckConnectionTimeout(void)
{
if(system("pidof -s OcppBackend > /dev/null") != 0)
{
_connectionTimeout = CONN_PLUG_TIME_OUT;
}
else
{
if(ShmOCPP16Data->OcppConnStatus &&
strcmp((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData,"") != 0)
{
_connectionTimeout = atoi((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData);
if(_connectionTimeout <= 0)
{
_connectionTimeout = CONN_PLUG_TIME_OUT;
}
}
else
{
_connectionTimeout = CONN_PLUG_TIME_OUT;
}
}
if(_connectionTimeout != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout = _connectionTimeout;
TriggerDispenserConnectionTimeoutSetting();
}
}
void CreateTimeoutFork()
{
pid_t timeoutPid;
timeoutPid = fork();
if (timeoutPid == 0)
{
GetClockTime(&_cmdSubPriority_time);
CheckConnectionTimeout();
LOG_INFO("Timeout Fork PID = %d", getpid());
while(true)
{
if ((GetTimeoutValue(_cmdSubPriority_time) / 1000) > 5000)
{
CheckConnectionTimeout();
GetClockTime(&_cmdSubPriority_time);
}
//printf("Timeout ***********SystemTimeoutFlag = %d, ********\n", ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag);
// 系統
// switch(ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag)
// {
// case Timeout_SelftestChk:
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= SELFTEST_TIMEOUT)
// {
// _SelfTestTimeout();
// StopSystemTimeoutDet();
// }
// break;
// case Timeout_Authorizing:
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_TIMEOUT)
// {
// _AuthorizedTimeout();
// StopSystemTimeoutDet();
// }
// break;
// case Timeout_VerifyFail:
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_FAIL_TIMEOUT)
// {
// _AutoReturnTimeout();
// StopSystemTimeoutDet();
// }
// break;
// case Timeout_VerifyComp:
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_COMP_TIMEOUT)
// {
// _AutoReturnTimeout();
// StopSystemTimeoutDet();
// }
// break;
// case Timeout_WaitPlug:
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= _connectionTimeout)
// {
// _DetectPlugInTimeout();
// StopSystemTimeoutDet();
// }
// break;
// case Timeout_ReturnToChargingGunDet:
// {
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= RETURN_TO_CHARGING_PAGE)
// {
// DisplayChargingInfo();
// StopSystemTimeoutDet();
// }
// }
// break;
// case Timeout_AuthorizingForStop:
// {
// if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_STOP_TIMEOUT)
// {
// strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
// ClearAuthorizedFlag();
// StopSystemTimeoutDet();
// }
// }
// break;
// }
// 各槍
// for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
// {
//printf("Timeout ***********TimeoutFlag = %d, ********\n", chargingInfo[gun_index]->TimeoutFlag);
// switch(chargingInfo[gun_index]->TimeoutFlag)
// {
// case Timeout_Preparing:
// {
// if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_PREPARE_TIMEOUT)
// {
// _PrepareTimeout(gun_index);
// StopGunInfoTimeoutDet(gun_index);
// }
// }
// break;
// case Timeout_EvChargingDet:
// {
// if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_EV_WAIT_TIMEOUT)
// {
// _DetectEvChargingEnableTimeout(gun_index);
// StopGunInfoTimeoutDet(gun_index);
// }
// }
// break;
// case Timeout_EvseChargingDet:
// {
// if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_EVSE_WAIT_TIMEOUT)
// {
// _DetectEvseChargingEnableTimeout(gun_index);
// StopGunInfoTimeoutDet(gun_index);
// }
// }
// break;
// case Timeout_EvseCompleteDet:
// {
// if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_COMP_WAIT_TIMEOUT)
// {
// StopGunInfoTimeoutDet(gun_index);
// }
// }
// break;
// case Timeout_ForCcsPrechargeDet:
// {
// if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_PRECHARGING_TIMEOUT)
// {
// _CcsPrechargeTimeout(gun_index);
// StopGunInfoTimeoutDet(gun_index);
// }
// }
// break;
// }
// }
sleep(1);
}
}
}
void CheckFactoryConfigFunction(void)
{
if(ShmSysConfigAndInfo->SysInfo.FactoryConfiguration)
{
char Buf[256];
sprintf(Buf, "cd /root;./FactoryConfig -m");
system(Buf);
system("rm -f /Storage/OCPP/OCPPConfiguration");
system("sync");
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
}
void CheckFwUpdateFunction(void)
{
char UpdateResult = PASS;
if (ShmSysConfigAndInfo->SysInfo.FirmwareUpdate == YES)
{
ShmChargerInfo->Control.SysCtrl.bits.NeedSelfTest = false;
UpgradePrepare();
ShmChargerInfo->Control.PrimaryCtrl.bits.Paused = true;
ShmChargerInfo->Control.RelayCtrl.bits.Paused = true;
ShmChargerInfo->Control.FanCtrl.bits.Paused = true;
LOG_INFO("ftp : update start.");
TryCloseWatchdog();
//KillTask();
ChangeLcmByIndex(_LCM_FIX);
system("killall Module_PrimaryComm");
system("killall Module_InternalComm");
UpdateResult = CheckUpdateProcess();
if (UpdateResult == PASS)
{
LOG_INFO("ftp : update complete.");
}
else
{
LOG_INFO("ftp : update fail.");
}
ShmSysConfigAndInfo->SysInfo.FirmwareUpdate = NO;
sleep(5);
if(_UpgradeNeedReboot)
{
system("reboot -f");
}
else
{
KillAllTask();
system("/usr/bin/run_evse_restart.sh");
}
}
else if(ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq == YES)
{
ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = NO;
ShmChargerInfo->Control.SysCtrl.bits.NeedSelfTest = false;
UpgradePrepare();
ShmChargerInfo->Control.PrimaryCtrl.bits.Paused = true;
ShmChargerInfo->Control.RelayCtrl.bits.Paused = true;
ShmChargerInfo->Control.FanCtrl.bits.Paused = true;
if (strcmp((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Downloaded") == EQUAL)
{
LOG_INFO("Backend : update start.");
TryCloseWatchdog();
strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "");
strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installing");
ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = YES;
//KillTask();
system("killall Module_PrimaryComm");
system("killall Module_InternalComm");
for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
{
setChargerMode(_index, MODE_UPDATE);
}
UpdateResult = CheckUpdateProcess();
if (UpdateResult == PASS)
{
LOG_INFO("Backend : update complete.");
strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installed");
}
else
{
LOG_INFO("Backend : update fail.");
strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "InstallationFailed");
}
//strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installed");
sleep(1);
ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = YES;
sleep(5);
if(_UpgradeNeedReboot)
{
system("reboot -f");
}
else
{
KillAllTask();
system("/usr/bin/run_evse_restart.sh");
}
}
}
}
void ExecuteWriteWiringInfo(void)
{
struct SysConfigData config;
memcpy(&config, &ShmSysConfigAndInfo->SysConfig, sizeof(struct SysConfigData));
config.SwitchDebugFlag = NO;
strcpy((char *) config.UserId, "");
int result = StoreUsrConfigData(&config);
if(result != 1)
{
LOG_INFO("Store User Config NG");
}
else
{
LOG_INFO("Store User Config OK");
}
}
struct timespec _WiringInfo_time;
int CheckWiringInfoUpdate(void)
{
if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.FlashConfigChanged)
{
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.FlashConfigChanged = false;
LOG_INFO("Flash Config Changed");
GetClockTime(&_WiringInfo_time);
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteFlash = true;
}
if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteFlash)
{
// 30s for reboot request timeout
if((GetTimeoutValue(_WiringInfo_time) / uSEC_VAL) >= WIRING_INFO_DELAY ||
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo)
{
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteFlash = false;
LOG_INFO("Start Write To Flash");
pid_t writePid = fork();
if(writePid == 0)
{
ExecuteWriteWiringInfo();
if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo)
{
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo = false;
ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
LOG_INFO("Clean Wiring Info And Need Soft Reset");
}
return NO;
}
LOG_INFO("Clean Write Flahs Flag");
}
}
return YES;
}
void CheckSoftHardReset(void)
{
if(ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset)
{
ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = false;
LOG_INFO("********** Need Soft Reset **********");
sleep(5);
system("killall OcppBackend &");
KillAllTask();
TryCloseWatchdog();
system("/usr/bin/run_evse_restart.sh");
}
if(ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset)
{
ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset = false;
LOG_INFO("********** Need Hard Reset **********");
sleep(5);
system("reboot -f");
}
}
//===============================================
// Check reservation date is expired
//===============================================
int isReservationExpired(unsigned char gun_index)
{
int result = NO;
struct tm expiredDate;
struct timeb expiredTime;
if (sscanf((char*) ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate,
"%4d-%2d-%2dT%2d:%2d:%2d", &expiredDate.tm_year,
&expiredDate.tm_mon, &expiredDate.tm_mday, &expiredDate.tm_hour,
&expiredDate.tm_min, &expiredDate.tm_sec) == 6)
{
expiredDate.tm_year -= 1900;
expiredDate.tm_mon -= 1;
expiredTime.time = mktime(&expiredDate);
if (!CheckTimeOut(expiredTime))
{
result = YES;
}
}
return result;
}
struct timespec _Reboot_time;
void TriggerDispenserHardwareReboot(void)
{
BOOL trigger = FALSE;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootConfirm == 0 &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest == 0)
{
trigger = TRUE;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest = 1;
}
}
}
if(trigger)
{
GetClockTime(&_Reboot_time);
LOG_INFO("********** Trigger Dispenser Hardware Reboot **********");
}
}
BOOL IsDispenserHardwareRebootResponsed(void)
{
BOOL response_ok = TRUE;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootConfirm)
{
response_ok = FALSE;
// 10s for reboot request timeout
if((GetTimeoutValue(_Reboot_time) / uSEC_VAL) >= REBOOT_TIMEOUT)
{
response_ok = TRUE;
LOG_INFO("Reboot request timeout");
}
}
}
}
return response_ok;
}
struct timespec _Reset_time;
void TriggerDispenserSoftwareReset(void)
{
BOOL trigger = FALSE;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetConfirm == 0 &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest == 0)
{
trigger = TRUE;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest = 1;
}
}
}
if(trigger)
{
GetClockTime(&_Reset_time);
LOG_INFO("********** Trigger Dispenser Software Reset **********");
}
}
BOOL IsDispenserSoftwareResetResponsed(void)
{
BOOL response_ok = TRUE;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetConfirm)
{
response_ok = FALSE;
// 10s for reset request timeout
if((GetTimeoutValue(_Reset_time) / uSEC_VAL) >= RESET_TIMEOUT)
{
response_ok = TRUE;
LOG_INFO("Reset request timeout");
}
}
}
}
return response_ok;
}
// the unit of return value: 0.01 dollar
int TariffParsing(char *StringItem, char *TariffCode)
{
char *ptrSave, *ptrToken;
char strSource[128];
int fee = 0;
memcpy(strSource, StringItem, 128);
ptrToken = strtok_r(strSource, ";", &ptrSave);
while(ptrToken != NULL)
{
char *strTariff = strstr(ptrToken, TariffCode);
if(strTariff != NULL)
{
char *strFee = strstr(strTariff, "$");
if(strFee != NULL)
{
strFee++;
float fFee = atof(strFee);
fee = (int)(fFee * 100);
break;
}
}
ptrToken = strtok_r(NULL, ";", &ptrSave);
}
return fee;
}
void DefaultPriceHandler(char *StrDefaultPrice)
{
BOOL trigger = FALSE;
unsigned int ConnectionFee = 0, CurrentRate = 0, OccupancyFee = 0;
LOG_INFO("********** Default Price: %s", StrDefaultPrice);
ConnectionFee = TariffParsing(StrDefaultPrice, "Connection Fee");
LOG_INFO("********** Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
CurrentRate = TariffParsing(StrDefaultPrice, "Current Rate");
LOG_INFO("********** Current Rate: %d.%02d **********", (CurrentRate / 100), (CurrentRate % 100));
OccupancyFee = TariffParsing(StrDefaultPrice, "Occupancy Fee");
LOG_INFO("********** Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice = CurrentRate;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest == 0)
{
trigger = TRUE;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest = 1;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.CurrencyConfigRequest = 1;
}
}
}
if(trigger)
{
LOG_INFO("********** Trigger Dispenser Default Price **********");
}
}
void UserPriceHandler(char *UserId, char *UserPrice)
{
unsigned int ConnectionFee = 0, CurrentRate = 0, OccupancyFee = 0;
int AccountBalance = 0;
ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Connection Fee");
CurrentRate = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Current Rate");
OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Occupancy Fee");
AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Account Balance");
LOG_INFO("********** User Id: %s **********", ShmOCPP16Data->Cost.SetUserPrice.idToken);
LOG_INFO("********** User Price: %s", ShmOCPP16Data->Cost.SetUserPrice.price);
LOG_INFO("********** Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
LOG_INFO("********** Current Rate: %d.%02d **********", (CurrentRate / 100), (CurrentRate % 100));
LOG_INFO("********** Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
LOG_INFO("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.StartUserId, UserId) == EQUAL)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].UserPrice != CurrentRate ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
{
LOG_INFO("********** Connector Id %d User Price %d.%02d, Account Balance %d.%02d **********",
(i + 1), (CurrentRate / 100), (CurrentRate % 100), (AccountBalance / 100), (AccountBalance % 100));
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].UserPrice = CurrentRate;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;
if(chargingInfo[i]->SystemStatus == S_AUTHORIZING)
{
AnnounceAccountBalance(i, AccountBalance);
}
}
}
}
void RunningFinalCostHandler(void)
{
unsigned int ConnectionFee = 0, SessionFee = 0, OccupancyFee = 0, TotalCost = 0;
int AccountBalance = 0;
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus >= S_REASSIGN_CHECK &&
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus <= S_ALARM)
{
if(strlen((char *)ShmOCPP16Data->Cost.RunningCost[i].description) > 0)
{
ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Connection Fee");
SessionFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Session Fee");
OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Occupancy Fee");
TotalCost = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Total Cost");
AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Account Balance");
LOG_INFO("********** Connector Id: %d Running Cost **********", (i + 1));
LOG_INFO("********** Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
LOG_INFO("********** Session Fee: %d.%02d **********", (SessionFee / 100), (SessionFee % 100));
LOG_INFO("********** Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
LOG_INFO("********** Total Cost: %d.%02d **********", (TotalCost / 100), (TotalCost % 100));
LOG_INFO("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost != TotalCost ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
{
LOG_INFO("********** Connector Id %d Total Cost %d.%02d, Account Balance %d.%02d **********",
(i + 1), (TotalCost / 100), (TotalCost % 100), (AccountBalance / 100), (AccountBalance % 100));
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost = TotalCost;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;
memset(&ShmOCPP16Data->Cost.RunningCost[i], 0x00, sizeof(struct StrcutRunningCost));
}
if(strlen((char *)ShmOCPP16Data->Cost.FinalCost[i].description) > 0)
{
ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Connection Fee");
SessionFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Session Fee");
OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Occupancy Fee");
TotalCost = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Total Cost");
AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Account Balance");
LOG_INFO("********** Connector Id: %d Final Cost **********", (i + 1));
LOG_INFO("********** Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
LOG_INFO("********** Session Fee: %d.%02d **********", (SessionFee / 100), (SessionFee % 100));
LOG_INFO("********** Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
LOG_INFO("********** Total Cost: %d.%02d **********", (TotalCost / 100), (TotalCost % 100));
LOG_INFO("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost != TotalCost ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
{
LOG_INFO("********** Connector Id %d Total Cost %d.%02d, Account Balance %d.%02d **********",
(i + 1), (TotalCost / 100), (TotalCost % 100), (AccountBalance / 100), (AccountBalance % 100));
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost = TotalCost;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;
memset(&ShmOCPP16Data->Cost.FinalCost[i], 0x00, sizeof(struct StrcutFinalCost));
}
}
}
}
struct timespec _Cost_Price_time;
char MyDefaultPriceString[128];
struct StrcutSetUserPrice MyUserPrice;
char MyConnectorRunningCostString[CONNECTOR_QUANTITY][128];
char MyConnectorFinalCostString[CONNECTOR_QUANTITY][128];
void CheckOcppCostAndPrice(void)
{
// 5s for reboot request timeout
if((GetTimeoutValue(_Cost_Price_time) / uSEC_VAL) >= OCPP_COST_REQ_INTERVAL)
{
GetClockTime(&_Cost_Price_time);
if(strcmp(MyDefaultPriceString, (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData) != EQUAL)
{
DefaultPriceHandler((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
memcpy(MyDefaultPriceString, ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, 128);
}
if(strlen((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) > 0 && strlen((char *)ShmOCPP16Data->Cost.SetUserPrice.price) > 0)
{
UserPriceHandler((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken, (char *)ShmOCPP16Data->Cost.SetUserPrice.price);
memset(&ShmOCPP16Data->Cost.SetUserPrice, 0x00, sizeof(struct StrcutSetUserPrice));
}
RunningFinalCostHandler();
}
}
//===============================================
// OCPP
//===============================================
void CheckOcppStatus()
{
if (ShmOCPP16Data->SpMsg.bits.BootNotificationConf == YES)
{
ShmOCPP16Data->SpMsg.bits.BootNotificationConf = NO;
LOG_INFO("*********************OCPP Boot Notification****************************");
}
if (ShmOCPP16Data->MsMsg.bits.ResetReq == YES)
{
bool canReset = true;
if (ShmSysConfigAndInfo->SysWarningInfo.Level != 2)
{
for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
{
if (chargingInfo[_index]->SystemStatus != S_IDLE &&
chargingInfo[_index]->SystemStatus != S_RESERVATION &&
chargingInfo[_index]->SystemStatus != S_MAINTAIN)
{
canReset = false;
if (chargingInfo[_index]->SystemStatus >= S_REASSIGN && chargingInfo[_index]->SystemStatus < S_TERMINATING)
{
ChargingTerminalProcess(_index);
}
}
}
}
if(canReset)
{
if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Hard") == EQUAL)
{
//trigger dispenser to hardware reboot
TriggerDispenserHardwareReboot();
if(IsDispenserHardwareRebootResponsed())
{
ShmOCPP16Data->MsMsg.bits.ResetReq = NO;
sprintf((char*)ShmOCPP16Data->Reset.ResponseStatus, "Accepted");
LOG_INFO("****** Hard Reboot ******");
ShmOCPP16Data->MsMsg.bits.ResetConf = YES;
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
setChargerMode(i, MODE_MAINTAIN);
}
sleep(3);
system("reboot -f");
}
}
if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Soft") == EQUAL)
{
//trigger dispenser to software reset
TriggerDispenserSoftwareReset();
if(IsDispenserSoftwareResetResponsed())
{
ShmOCPP16Data->MsMsg.bits.ResetReq = NO;
sprintf((char*)ShmOCPP16Data->Reset.ResponseStatus, "Accepted");
LOG_INFO("****** Soft Reboot ******");
ShmOCPP16Data->MsMsg.bits.ResetConf = YES;
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
{
setChargerMode(i, MODE_MAINTAIN);
}
sleep(3);
system("killall OcppBackend &");
KillAllTask();
TryCloseWatchdog();
system("/usr/bin/run_evse_restart.sh");
}
}
}
}
CheckOcppCostAndPrice();
}
void OcppStartTransation(byte gunIndex)
{
byte _OcppGunIndex = gunIndex;
strcpy((char *)ShmOCPP16Data->StartTransaction[_OcppGunIndex].IdTag, (char *)chargingInfo[gunIndex]->StartUserId);
chargingInfo[gunIndex]->EvBatteryStartSoc = chargingInfo[gunIndex]->EvBatterySoc;
LOG_INFO("Gun index %d, OCPP Start Transation Index %d, IdTag = %s, StartSoc = %d",
chargingInfo[gunIndex]->Index, _OcppGunIndex, ShmOCPP16Data->StartTransaction[_OcppGunIndex].IdTag, chargingInfo[gunIndex]->EvBatteryStartSoc);
ShmOCPP16Data->CpMsg.bits[_OcppGunIndex].StartTransactionConf = NO;
ShmOCPP16Data->CpMsg.bits[_OcppGunIndex].StartTransactionReq = YES;
}
void OcppStopTransation(byte gunIndex)
{
byte _OcppGunIndex = gunIndex;
strcpy((char *)ShmOCPP16Data->StopTransaction[_OcppGunIndex].IdTag, (char *)chargingInfo[gunIndex]->StartUserId);
LOG_INFO("Gun index %d, OCPP Stop Transation Index %d, IdTag = %s, StopSoc = %d",
chargingInfo[gunIndex]->Index, _OcppGunIndex, ShmOCPP16Data->StopTransaction[_OcppGunIndex].IdTag, chargingInfo[gunIndex]->EvBatterySoc);
ShmOCPP16Data->CpMsg.bits[_OcppGunIndex].StopTransactionReq = YES;
}
// no use
bool OcppRemoteStop(byte gunIndex)
{
byte acDirIndex = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;
// 有 AC 槍的話
if (acDirIndex > 0 && gunIndex > 0)
{
gunIndex += acDirIndex;
}
bool result = ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq;
if (ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq == YES)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "Remote");
ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq = NO;
}
return result;
}
void OcppRemoteStartChk()
{
if (ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING)
{}
else if(!isDetectPlugin())
{
// 如果有 AC 槍，則固定是第 2 把槍，所以索引固定為 1
byte acDirIndex = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;
for (byte ac_index = 0; ac_index < ShmSysConfigAndInfo->SysConfig.AcConnectorCount; ac_index++)
{
if (ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq == YES)
{
if (ac_chargingInfo[ac_index]->SystemStatus == S_IDLE ||
ac_chargingInfo[ac_index]->SystemStatus == S_RESERVATION)
{
ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq = NO;
ac_chargingInfo[ac_index]->RemoteStartFlag = YES;
ShmSysConfigAndInfo->SysInfo.OrderCharging = YES;
//ShmSysConfigAndInfo->SysInfo.OrderCharging = DEFAULT_AC_INDEX;
ShmOCPP16Data->CsMsg.bits[ShmSysConfigAndInfo->SysConfig.TotalConnectorCount + ac_index].RemoteStartTransactionReq = NO;
DetectPluginStart();
return;
}
ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq = NO;
}
}
byte threeGunIndex = 0;
byte dcIndex = 0;
bool isGunUsingStatus = false;
for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
{
// 如果有 AC 槍，且 DC 槍也有兩把
if (acDirIndex == 1 && _index == 1)
threeGunIndex = 1;
if (ShmOCPP16Data->CsMsg.bits[_index + threeGunIndex].RemoteStartTransactionReq == YES)
dcIndex = _index;
if (chargingInfo[_index]->SystemStatus != S_IDLE)
{
isGunUsingStatus = true;
}
}
// 如果是雙槍單模，只認閒置狀態的槍，如果有預約~ 則預約也算被使用
if (isGunUsingStatus && ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf)
{
if (dcIndex == 0)
threeGunIndex = 0;
ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
return;
}
if (dcIndex == 0)
threeGunIndex = 0;
if (ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq == YES)
{
if (chargingInfo[dcIndex]->SystemStatus == S_IDLE ||
chargingInfo[dcIndex]->SystemStatus == S_RESERVATION)
{
chargingInfo[dcIndex]->RemoteStartFlag = YES;
ShmSysConfigAndInfo->SysInfo.OrderCharging = YES;
//ShmSysConfigAndInfo->SysInfo.OrderCharging = gun_index;
ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
DetectPluginStart();
}
ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
}
}
}
void ChkOcppStatus(byte gunIndex)
{
if(strcmp((char *)ShmOCPP16Data->StatusNotification[gunIndex].ErrorCode, "") == EQUAL)
{
if(strcmp((char *)_BackupStatusNotification[gunIndex].ErrorCode, "") != EQUAL)
{
strcpy((char *)ShmOCPP16Data->StatusNotification[gunIndex].ErrorCode, (char *)_BackupStatusNotification[gunIndex].ErrorCode);
strcpy((char *)ShmOCPP16Data->StatusNotification[gunIndex].VendorErrorCode, (char *)_BackupStatusNotification[gunIndex].VendorErrorCode);
//LOG_INFO("Gun %d Ocpp StatusNotification Recovery", gunIndex + 1);
}
}
if (chargingInfo[gunIndex]->SystemStatus == S_IDLE &&
ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowReq == YES)
{
ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowReq = NO;
if (isReservationExpired(gunIndex))
{
LOG_INFO("***************ChkOcppStatus: Gun %d OcppReservedStatus********************", gunIndex + 1);
chargingInfo[gunIndex]->ReservationId = ShmOCPP16Data->ReserveNow[gunIndex].ReservationId;
chargingInfo[gunIndex]->SystemStatus = S_RESERVATION;
}
ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowConf = YES;
}
if (chargingInfo[gunIndex]->SystemStatus == S_RESERVATION &&
ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationReq == YES)
{
ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationReq = NO;
if (isReservationExpired(gunIndex))
{
LOG_INFO("***************ChkOcppStatus: Gun %d Cancel OcppReservedStatus********************", gunIndex + 1);
chargingInfo[gunIndex]->ReservationId = 0;
chargingInfo[gunIndex]->SystemStatus = S_IDLE;
}
ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationConf = YES;
}
if (ShmOCPP16Data->CsMsg.bits[gunIndex].ChangeAvailabilityReq == YES)
{
LOG_INFO("***************ChkOcppStatus: Gun %d OcppChangeAvailability********************", gunIndex + 1);
ShmOCPP16Data->CsMsg.bits[gunIndex].ChangeAvailabilityReq = NO;
if(strcmp((char *)ShmOCPP16Data->ChangeAvailability[gunIndex].Type, "Operative") == EQUAL)
{
if (isDb_ready)
DB_Update_Operactive(localDb, gunIndex, true);
chargingInfo[gunIndex]->IsAvailable = YES;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.AvailabilityRequest = 1;
if (chargingInfo[gunIndex]->SystemStatus == S_IDLE ||
chargingInfo[gunIndex]->SystemStatus == S_RESERVATION ||
chargingInfo[gunIndex]->SystemStatus == S_MAINTAIN)
{
setChargerMode(gunIndex, MODE_IDLE);
}
}
else if (strcmp((char *)ShmOCPP16Data->ChangeAvailability[gunIndex].Type, "Inoperative") == EQUAL)
{
if (isDb_ready)
DB_Update_Operactive(localDb, gunIndex, false);
chargingInfo[gunIndex]->IsAvailable = NO;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.AvailabilityRequest = 1;
if (chargingInfo[gunIndex]->SystemStatus == S_IDLE ||
chargingInfo[gunIndex]->SystemStatus == S_RESERVATION ||
chargingInfo[gunIndex]->SystemStatus == S_MAINTAIN)
{
setChargerMode(gunIndex, MODE_MAINTAIN);
}
}
}
if (ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorReq == YES)
{
ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorReq = NO;
if(chargingInfo[gunIndex]->SystemStatus == S_PREPARNING ||
chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EV ||
chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EVSE ||
chargingInfo[gunIndex]->SystemStatus == S_CHARGING)
{
// 充電中，需停止充電
strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "UnlockCommand");
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.UnlockStopRequest = true;
LOG_INFO("********** OcppUnlockStop Gun %d **********", gunIndex + 1);
}
strcpy((char *)ShmOCPP16Data->UnlockConnector[gunIndex].ResponseStatus, "Unlocked");
ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorConf = YES;
}
if (ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq == YES)
{
ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq = NO;
if(chargingInfo[gunIndex]->SystemStatus == S_PREPARNING ||
chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EV ||
chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EVSE ||
chargingInfo[gunIndex]->SystemStatus == S_CHARGING)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "Remote");
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.RemoteStopRequest = true;
LOG_INFO("********** OcppRemoteStop Gun %d **********", gunIndex + 1);
}
}
}
bool CheckBackendChargingTimeout(byte gunIndex)
{
bool result = false;
if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)
{
if (ShmSysConfigAndInfo->SysConfig.MaxChargingDuration > 0)
{
if (chargingInfo[gunIndex]->PresentChargedDuration > (ShmSysConfigAndInfo->SysConfig.MaxChargingDuration * 60))
result = true;
}
}
else if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
{
// 隨插即充電的要看 offline
if (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration > 0)
{
if (chargingInfo[gunIndex]->PresentChargedDuration > (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration * 60))
result = true;
}
}
return result;
}
bool CheckBackendChargingEnergy(byte gunIndex)
{
bool result = false;
if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)
{
if (ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy > 0)
{
if (chargingInfo[gunIndex]->PresentChargedEnergy > ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy)
result = true;
}
}
else if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
{
// 隨插即充電的要看 offline
if (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy > 0)
{
if (chargingInfo[gunIndex]->PresentChargedEnergy > (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy))
result = true;
}
}
return result;
}
void InformOcppErrOccur(byte codeType)
{
char _error[25];
switch(codeType)
{
case 4: strcpy(_error, "InternalError"); break;
case 6: strcpy(_error, "NoError"); break;
case 7: strcpy(_error, "OtherError"); break;
case 13: strcpy(_error, "UnderVoltage"); break;
case 14: strcpy(_error, "OverVoltage"); break;
}
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
SetOcppErrorCode(gun_index, _error);
}
}
void SetOcppErrorCode(unsigned char _index, char *errCode)
{
strcpy((char *)ShmOCPP16Data->StatusNotification[_index].ErrorCode, errCode);
strcpy((char *)_BackupStatusNotification[_index].ErrorCode, errCode);
}
void SetOcppVendorErrorCode(unsigned char _index, char *vendorCode)
{
strcpy((char *)ShmOCPP16Data->StatusNotification[_index].VendorErrorCode, vendorCode);
strcpy((char *)_BackupStatusNotification[_index].VendorErrorCode, vendorCode);
}
//===============================================
// SQLite3 related routine
//===============================================
int DB_Open(sqlite3 *db)
{
int result = PASS;
char* errMsg = NULL;
char* createRecordSql="CREATE TABLE IF NOT EXISTS charging_record("
"idx integer primary key AUTOINCREMENT, "
"reservationId text, "
"transactionId text, "
"startMethod text, "
"userId text, "
"dateTimeStart text, "
"dateTimeStop text,"
"socStart text, "
"socStop text, "
"chargeEnergy text, "
"stopReason text"
");";
char* createCfgSql="CREATE TABLE IF NOT EXISTS `config` ( "
"`idx` INTEGER PRIMARY KEY AUTOINCREMENT, "
"`IsAvailable` TEXT NOT NULL, "
"`connector` INTEGER NOT NULL, "
"`val` TEXT NOT NULL, unique(IsAvailable,connector) on conflict replace);";
if(sqlite3_open(DB_FILE, &db))
{
result = FAIL;
LOG_ERROR( "Can't open database: %s", sqlite3_errmsg(db));
sqlite3_close(db);
}
else
{
LOG_INFO( "Local charging record database open successfully.");
if (sqlite3_exec(db, createRecordSql, 0, 0, &errMsg) != SQLITE_OK)
{
result = FAIL;
LOG_INFO( "Create local charging record table error message: %s", errMsg);
}
else
{
LOG_INFO( "Opened local charging record table successfully");
}
if (sqlite3_exec(db, createCfgSql, 0, 0, &errMsg) != SQLITE_OK)
{
result = FAIL;
LOG_INFO( "Create local config table error message: %s", errMsg);
}
else
{
LOG_INFO( "Opened local config table successfully");
}
sqlite3_close(db);
}
return result;
}
int DB_Insert_Record(sqlite3 *db, int gun_index)
{
int result = PASS;
char* errMsg = NULL;
char insertSql[1024];
sprintf(insertSql, "insert into charging_record(reservationId, transactionId, startMethod, userId, dateTimeStart, dateTimeStop, socStart, socStop, chargeEnergy, stopReason) "
"values('%d', '%d', '%d', '%s', '%s', '%s', '%d', '%d', '%f', '%s');",
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].ReservationId,
ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartDateTime,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StopDateTime,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc,
ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy,
ShmOCPP16Data->StopTransaction[gun_index].StopReason);
if(sqlite3_open("/Storage/ChargeLog/localCgargingRecord.db", &db))
{
result = FAIL;
LOG_ERROR( "Can't open database: %s", sqlite3_errmsg(db));
sqlite3_close(db);
}
else
{
LOG_INFO( "Local charging record database open successfully.");
if (sqlite3_exec(db, insertSql, 0, 0, &errMsg) != SQLITE_OK)
{
result = FAIL;
LOG_INFO( "Insert local charging record error message: %s", errMsg);
}
else
{
LOG_INFO( "Insert local charging record successfully");
}
sqlite3_close(db);
}
return result;
}
int DB_Update_Operactive(sqlite3 *db, uint8_t gun_index, uint8_t IsAvailable)
{
uint8_t result = false;
char* errMsg = NULL;
char sqlStr[1024];
srand(time(NULL));
if(sqlite3_open(DB_FILE, &db))
{
result = FAIL;
LOG_ERROR( "Can't open database: %s", sqlite3_errmsg(db));
sqlite3_close(db);
}
else
{
LOG_INFO( "Local charging record database open successfully (%d).", IsAvailable);
sprintf(sqlStr, "insert or replace into config (IsAvailable, connector, val) values('IsAvailable', %d, %d);", gun_index, IsAvailable);
LOG_INFO("sqlStr= %s", sqlStr);
if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
{
result = FAIL;
LOG_INFO( "update config error message: %s", errMsg);
}
else
{
LOG_INFO("update connector-%d config item isOperactive to %d", gun_index, IsAvailable);
}
sqlite3_close(db);
}
return result;
}
int DB_Get_Operactive(sqlite3 *db, uint8_t gun_index)
{
uint8_t result = true;
char* errMsg = NULL;
char sqlStr[1024];
char **rs;
int rows, cols;
sprintf(sqlStr, "select * from config where IsAvailable='IsAvailable' and connector=%d;", gun_index);
//DEBUG_INFO("sqlStr= %s\r\n", sqlStr);
if(sqlite3_open(DB_FILE, &db))
{
result = FAIL;
LOG_ERROR( "Can't open database: %s", sqlite3_errmsg(db));
sqlite3_close(db);
}
else
{
LOG_INFO( "Local config query database open successfully.");
sqlite3_get_table(db, sqlStr, &rs, &rows, &cols, &errMsg);
if(rows>0)
{
for(int idxRow=1;idxRow<=rows;idxRow++)
{
if(strcmp(rs[(idxRow*cols)+3], "0") == 0)
{
result = false;
}
LOG_INFO("Query connector-%d isOperactive: %s", gun_index, rs[(idxRow*cols)+3]);
}
}
else
{
LOG_INFO("Query connector-%d fail, set default value to operactive.", gun_index);
}
sqlite3_free_table(rs);
sqlite3_close(db);
}
return result;
}
//===============================================
// Config process
//===============================================
void AddPlugInTimes(byte gunIndex)
{
if (chargingInfo[gunIndex]->Type == _Type_Chademo)
ShmSysConfigAndInfo->SysConfig.ChademoPlugInTimes += 1;
else if(chargingInfo[gunIndex]->Type == _Type_CCS_2)
ShmSysConfigAndInfo->SysConfig.Ccs2PlugInTimes += 1;
else if(chargingInfo[gunIndex]->Type == _Type_GB)
ShmSysConfigAndInfo->SysConfig.GbPlugInTimes += 1;
}
void ChangeStartOrStopDateTime(byte isStart, byte gunIndex)
{
char cmdBuf[32];
struct timeb csuTime;
struct tm *tmCSU;
ftime(&csuTime);
tmCSU = localtime(&csuTime.time);
sprintf(cmdBuf, "%04d-%02d-%02d %02d:%02d:%02d", tmCSU->tm_year + 1900,
tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
tmCSU->tm_sec);
if (isStart)
strcpy((char *)chargingInfo[gunIndex]->StartDateTime, cmdBuf);
else
strcpy((char *)chargingInfo[gunIndex]->StopDateTime, cmdBuf);
}
void zipLogFiles()
{
const char* logPath = "/Storage/SystemLog";
// 獲取目錄
DIR* pDir = opendir(logPath);
if (pDir != NULL)
{
struct timeb csuTime;
struct tm *tmCSU;
ftime(&csuTime);
tmCSU = localtime(&csuTime.time);
// LOG_INFO("Time : %04d-%02d-%02d %02d:%02d:%02d \n", tmCSU->tm_year + 1900,
// tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
// tmCSU->tm_sec);
// Read items inside the folder
struct dirent* pEntry = NULL;
while ((pEntry = readdir(pDir)) != NULL)
{
if (strcmp(pEntry->d_name, ".") != 0 &&
strcmp(pEntry->d_name, "..") != 0 &&
strncmp(pEntry->d_name, "[", 1) == 0 &&
strstr(pEntry->d_name, "tar") < 0)
{
char yearC[5];
unsigned short year = 0;
char monthC[3];
unsigned short month = 0;
yearC[4] = '\0';
strncpy(yearC, pEntry->d_name + 1, 4);
monthC[2] = '\0';
strncpy(monthC, pEntry->d_name + 6, 2);
year = atoi(yearC);
month = atoi(monthC);
if (year != 0)
{
if (year < tmCSU->tm_year + 1900 ||
(year >= tmCSU->tm_year + 1900 && month < tmCSU->tm_mon + 1))
{
LOG_INFO("tar file name : %s", pEntry->d_name);
char file[256];
memset(file, 0x00, sizeof(file));
strcat(file, "tar zcvf ");
strcat(file, logPath);
strncat(file, "/", 1);
strcat(file, pEntry->d_name);
strcat(file, ".tar");
strncat(file, " ", 1);
strcat(file, logPath);
strncat(file, "/", 1);
strcat(file, pEntry->d_name);
LOG_INFO("zip = %s \n", file);
system(file);
}
}
}
}
}
// Close folder
closedir(pDir);
}
void ChangeGunSelectByIndex(byte sel)
{
ShmSysConfigAndInfo->SysInfo.CurGunSelected = sel;
ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
}
void StopProcessingLoop()
{
for (;;)
{
CheckFactoryConfigFunction();
CheckFwUpdateFunction();
if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2)
{
ChkPrimaryStatus();
if (ShmSysConfigAndInfo->SysWarningInfo.Level == 0)
{
LOG_INFO("Soft reboot for retry self-tets (Primary).");
KillAllTask();
sleep(3);
TryCloseWatchdog();
system("/usr/bin/run_evse_restart.sh");
return;
}
}
if(ShmOCPP16Data->MsMsg.bits.ResetReq == YES)
{
if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Hard") == EQUAL)
{
ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset = true;
}
if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Soft") == EQUAL)
{
ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
}
}
CheckSoftHardReset();
sleep(1);
}
}
void CreateWatchdog(void)
{
wtdFd = InitWatchDog();
if(wtdFd < 0)
{
LOG_INFO("Watchdog Initial Fail");
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
}
else
{
LOG_INFO("Watchdog Initial Success");
}
}
void TryCloseWatchdog(void)
{
if(wtdFd > 0)
{
write(wtdFd, "V", 1);
close(wtdFd);
}
}
void TryFeedWatchdog(void)
{
if(wtdFd > 0)
{
write(wtdFd, "a", 1);
}
}
bool IsParallelCabinetIdle(void)
{
bool result = true;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE)
{
result = false;
}
return result;
}
bool IsConnectorWholeIdle(void)
{
bool result = true;
for (byte count = 0; count < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; count++)
{
if (chargingInfo[count]->SystemStatus != S_IDLE &&
chargingInfo[count]->SystemStatus != S_RESERVATION &&
chargingInfo[count]->SystemStatus != S_FAULT &&
chargingInfo[count]->SystemStatus != S_MAINTAIN)
{
result = false;
break;
}
}
return result;
}
void ClearAlarmCodeWhenAcOff()
{
if (!ShmSysConfigAndInfo->SysInfo.AcContactorStatus)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = NO;
}
}
//==========================================
// Check task processing
//==========================================
void CheckTask()
{
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
{
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
if(system("pidof -s Module_4g > /dev/null") != 0 && ShmChargerInfo->Control.SysCtrl.bits.Wifi4gResetEnable == false)
{
LOG_ERROR("Module_4g not running, restart it.");
system("/root/Module_4g &");
}
}
}
if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
{
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
{
if(system("pidof -s Module_Wifi > /dev/null") != 0 && ShmChargerInfo->Control.SysCtrl.bits.Wifi4gResetEnable == false)
{
LOG_ERROR("Module_Wifi not running, restart it.");
system("/root/Module_Wifi &");
}
}
}
if(ShmChargerInfo->Control.CabinetRole != _CROLE_SLAVE &&
strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL)
{
ShmChargerInfo->Control.SysCtrl.bits.BackendEnable = true;
if((time((time_t*)NULL) - ShmOCPP16Data->procDogTime) > 180)
{
LOG_ERROR("OcppBackend watch dog timeout task restart.");
ShmOCPP16Data->procDogTime = time((time_t*)NULL);
system("pkill OcppBackend");
}
if(system("pidof -s OcppBackend > /dev/null") != 0)
{
LOG_ERROR("OcppBackend not running, restart it.");
system("/root/OcppBackend &");
}
}
else
{
ShmChargerInfo->Control.SysCtrl.bits.BackendEnable = false;
}
if(system("pidof -s Module_ProduceUtils > /dev/null") != 0)
{
LOG_ERROR("Module_ProduceUtils not running, restart it.");
system ("/root/Module_ProduceUtils &");
}
if(system("pidof -s Module_EvComm > /dev/null") != 0)
{
LOG_ERROR("Module_EvComm not running, restart it.");
system ("/root/Module_EvComm &");
}
if(system("pidof -s Module_InternalComm > /dev/null") != 0)
{
LOG_ERROR("Module_InternalComm not running, restart it.");
system ("/root/Module_InternalComm &");
//ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
}
}
void InitialDHCP()
{
char tmpbuf[256];
memset(tmpbuf,0,256);
system("pgrep -f \"udhcpc -i eth0\" | xargs kill");
sprintf(tmpbuf, "/sbin/udhcpc -i eth0 -x hostname:CSU3_%s -s /root/dhcp_script/eth0.script > /dev/null &", ShmSysConfigAndInfo->SysConfig.SystemId);
system(tmpbuf);
}
void InitialDispenserDhcpServerConfig(void)
{
system("echo 'start 192.168.100.10' > /etc/udhcpd_eth1.conf");
system("echo 'end 192.168.100.20' >> /etc/udhcpd_eth1.conf");
system("echo 'interface eth1' >> /etc/udhcpd_eth1.conf");
system("echo 'opt dns 8.8.8.8' >> /etc/udhcpd_eth1.conf");
system("echo 'option subnet 255.255.255.0' >> /etc/udhcpd_eth1.conf");
system("echo 'opt router 192.168.100.1' >> /etc/udhcpd_eth1.conf");
system("echo 'option domain local' >> /etc/udhcpd_eth1.conf");
system("echo 'option lease 86400' >> /etc/udhcpd_eth1.conf");
usleep(1000);
}
void StartDispenserDhcpServer(void)
{
system("pgrep -f \"udhcpd /etc/udhcpd_eth1.conf\" | xargs kill");
system("/usr/sbin/udhcpd /etc/udhcpd_eth1.conf > /dev/null &");
}
//==========================================
// Check Smart Charging Profile
//==========================================
void Ocpp_ProfileReq_Cmd(byte gunIndex)
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if(ShmOCPP16Data->CSUMsg.bits[gunIndex].ChargingProfileConf == NO)
{
if(ShmOCPP16Data->CSUMsg.bits[gunIndex].ChargingProfileReq == NO)
{
ShmOCPP16Data->CSUMsg.bits[gunIndex].ChargingProfileReq = YES;
}
}
}
}
bool Ocpp_Chk_ProfileConf_Cmd(byte gunIndex)
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if (ShmOCPP16Data->CSUMsg.bits[gunIndex].ChargingProfileConf == YES)
{
ShmOCPP16Data->CSUMsg.bits[gunIndex].ChargingProfileConf = NO;
return true;
}
}
return false;
}
int GetStartScheduleTime(unsigned char *time)
{
int result = -1;
struct tm tmScheduleStart;
struct timeb tbScheduleStart;
if((sscanf((char *)time, "%4d-%2d-%2dT%2d:%2d:%2d", &tmScheduleStart.tm_year, &tmScheduleStart.tm_mon, &tmScheduleStart.tm_mday, &tmScheduleStart.tm_hour, &tmScheduleStart.tm_min, &tmScheduleStart.tm_sec) == 6))
{
tmScheduleStart.tm_year -= 1900;
tmScheduleStart.tm_mon -= 1;
tbScheduleStart.time = mktime(&tmScheduleStart);
tbScheduleStart.millitm = 0;
result = DiffTimebWithNow(tbScheduleStart) / 1000;
}
return result;
}
void Ocpp_ChargingProfile_Process(byte _index)
{
int _time = 0;
int _startCount = NO_DEFINE;
int _maxCount = 0;
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if (strcmp((char *)ShmOCPP16Data->SmartChargingProfile[_index].ChargingProfileKind, "Absolute") == EQUAL &&
ShmOCPP16Data->SmartChargingProfile[_index].ChargingProfileId == YES)
{
_time = GetStartScheduleTime(ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.StartSchedule);
_maxCount = ARRAY_SIZE(ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod);
_startCount = NO_DEFINE;
for (byte _count = 0; _count < _maxCount; _count++)
{
// 預設最小輸出電流 (MIN_OUTPUT_CUR) A
if (_time >= ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_count].StartPeriod)
{
if ((_count == 0 && ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_count].Limit >= MIN_OUTPUT_CUR) ||
ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_count].Limit > MIN_OUTPUT_CUR)
{
_startCount = _count;
}
}
}
if (_startCount < _maxCount)
{
chargingInfo[_index]->ChargingProfilePower = ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit * AC_OUTPUT_VOL * ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].NumberPhases;
if (chargingInfo[_index]->EvBatterytargetVoltage > 0 &&
(int)chargingInfo[_index]->PresentChargingVoltage > 0)
{
chargingInfo[_index]->ChargingProfileCurrent = (chargingInfo[_index]->ChargingProfilePower / chargingInfo[_index]->PresentChargingVoltage) * 10;
}
else
{
chargingInfo[_index]->ChargingProfileCurrent = -1;
}
}
else
{
chargingInfo[_index]->ChargingProfilePower = -1;
chargingInfo[_index]->ChargingProfileCurrent = -1;
}
}
else
{
chargingInfo[_index]->ChargingProfilePower = -1;
chargingInfo[_index]->ChargingProfileCurrent = -1;
}
}
else
{
chargingInfo[_index]->ChargingProfilePower = -1;
chargingInfo[_index]->ChargingProfileCurrent = -1;
}
if((int)_lastProfilePower[_index] != (int)chargingInfo[_index]->ChargingProfilePower ||
(int)_lastProfileCurrent[_index] != (int)chargingInfo[_index]->ChargingProfileCurrent)
{
LOG_INFO("Gun %d Get Profile - Index = %d, Limit = %f",
_index + 1, _startCount,
ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit);
LOG_INFO("Max: %d kW, Gun %d ChargingProfile Power = %d, Current = %d",
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower == -1 ? (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower : ((int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower / 1000),
_index + 1, (int)chargingInfo[_index]->ChargingProfilePower, (int)chargingInfo[_index]->ChargingProfileCurrent);
}
_lastProfilePower[_index] = chargingInfo[_index]->ChargingProfilePower;
_lastProfileCurrent[_index] = chargingInfo[_index]->ChargingProfileCurrent;
}
void Ocpp_MaxChargingProfile_Process(void)
{
int _time = 0;
int _startCount = NO_DEFINE;
int _maxCount = 0;
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if (strcmp((char *)ShmOCPP16Data->MaxChargingProfile.ChargingProfileKind, "Absolute") == EQUAL &&
ShmOCPP16Data->MaxChargingProfile.ChargingProfileId == YES)
{
_time = GetStartScheduleTime(ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.StartSchedule);
_maxCount = ARRAY_SIZE(ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod);
_startCount = NO_DEFINE;
for (byte _count = 0; _count < _maxCount; _count++)
{
// 預設最小輸出電流 (MIN_OUTPUT_CUR) A
if (_time >= ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_count].StartPeriod)
{
if ((_count == 0 && ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_count].Limit >= MIN_OUTPUT_CUR) ||
ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_count].Limit > MIN_OUTPUT_CUR)
{
_startCount = _count;
}
}
}
if(_startCount < _maxCount)
{
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower = ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit * AC_OUTPUT_VOL * ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_startCount].NumberPhases;
}
else
{
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower = -1;
}
}
else
{
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower = -1;
}
}
else
{
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower = -1;
}
if((int)_lastMaxProfilePower != (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower)
{
LOG_INFO("Charger Get Max Profile - Index = %d, Limit = %f",
_startCount, ShmOCPP16Data->MaxChargingProfile.ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit);
LOG_INFO("Charger Max Profile Power = %d", (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower);
}
_lastMaxProfilePower = ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower;
}
void CheckSmartChargeProfile(byte _index)
{
if(Ocpp_Chk_ProfileConf_Cmd(_index))
{
Ocpp_MaxChargingProfile_Process();
Ocpp_ChargingProfile_Process(_index);
}
}
bool Ocpp_CheckInvalidId(byte _index)
{
bool invalid = false;
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
if(strstr((char *) ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemData, "TRUE"))
{
if(strcmp((char *)ShmOCPP16Data->StartTransaction[_index].ResponseIdTagInfo.Status, "Blocked") == EQUAL ||
strcmp((char *)ShmOCPP16Data->StartTransaction[_index].ResponseIdTagInfo.Status, "Expired") == EQUAL ||
strcmp((char *)ShmOCPP16Data->StartTransaction[_index].ResponseIdTagInfo.Status, "Invalid") == EQUAL)
{
invalid = true;
LOG_INFO("Gun %d Stop Transaction On Invalid Id", _index + 1);
}
}
else
{
if(strcmp((char *)ShmOCPP16Data->StartTransaction[_index].ResponseIdTagInfo.Status, "Accepted") != EQUAL)
{
invalid = true;
LOG_INFO("Gun %d Start Transaction Not Accepted", _index + 1);
}
}
}
return invalid;
}
void TheEndCharging(byte gun_index)
{
chargingInfo[gun_index]->isRemoteStart = NO;
//StopGunInfoTimeoutDet(gun_index);
//StartGunInfoTimeoutDet(gun_index, Timeout_EvseCompleteDet);
ChangeStartOrStopDateTime(NO, gun_index);
//DB_Insert_Record(localDb, gun_index);
}
void UpdateErrorCodeToOcpp(byte index)
{
//printf("ConnectorAlarmCode = %s \n", chargingInfo[index]->ConnectorAlarmCode);
if (strcmp((char *)chargingInfo[index]->ConnectorAlarmCode, "") != EQUAL)
{
SetOcppErrorCode(index, "InternalError");
SetOcppVendorErrorCode(index, (char *)chargingInfo[index]->ConnectorAlarmCode);
}
else if (strcmp((char *)chargingInfo[index]->EvConnAlarmCode, "") != EQUAL)
{
SetOcppErrorCode(index, "OtherError");
SetOcppVendorErrorCode(index, (char *)chargingInfo[index]->EvConnAlarmCode);
}
}
void CheckMiscCommandRequirement(void)
{
BOOL NeedAnnouncement = FALSE;
unsigned char connector = 0;
if(ShmSysConfigAndInfo->SysInfo.FirmwareUpdate != YES)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
NeedAnnouncement = FALSE;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.ConnectorTimeoutConfigRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.CurrencyConfigRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.BackendStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.EthernetStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.WiFiStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.TelcomModemStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.BillingStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.StopButtonStatusRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.AuthModeConfigRequest ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.EVCCIDConfigRequest)
{
NeedAnnouncement = TRUE;
}
for(int j = 0; j < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity; j++)
{
connector = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorID[j] - 1;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.AvailabilityRequest ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.AccountBalanceRequest)
{
NeedAnnouncement = TRUE;
}
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.MiscNeedAnnouncement != NeedAnnouncement)
{
if(NeedAnnouncement)
{
LOG_INFO("********** Dispenser %d Misc Command Need Announcement **********", i + 1);
}
else
{
LOG_INFO("********** Dispenser %d Misc Command Announced **********", i + 1);
}
}
}
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.MiscNeedAnnouncement = NeedAnnouncement;
}
}
}
void CheckDispenserVersionUpdateRequirement(void)
{
}
bool IsReadyParalleling(void)
{
bool ready = true;
for(int i = 0; i < ShmChargerInfo->Control.MaxConnector; i++)
{
if(chargingInfo[i]->SystemStatus != S_IDLE && chargingInfo[i]->SystemStatus != S_MAINTAIN)
{
ready = false;
break;
}
}
return ready;
}
void SetParallelingStart(void)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(chargingInfo[i]->SystemStatus == S_IDLE)
{
setChargerMode(i, MODE_MAINTAIN);
}
}
ShmChargerInfo->ParallelCabinet.ParallelStatus = _Parallel_Wait;
}
void SetParallelingDone(void)
{
unsigned short totalPow = 0;
totalPow = GetTotalParallelCabinetPower();
if(totalPow != ShmChargerInfo->ParallelCabinet.TotalParallelPower)
{
LOG_INFO("Total Parallel Cabinet Power: %d.%d kW", (totalPow / 10), (totalPow % 10));
}
ShmChargerInfo->ParallelCabinet.TotalParallelPower = totalPow;
ShmChargerInfo->ParallelCabinet.ParallelStatus = _Parallel_None;
}
void SetPCabinetOutputRelay(unsigned char index, unsigned char OnOff)
{
unsigned char relay = 0;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle &&
ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelConfirm)
{
relay = OnOff == YES ? YES : NO;
if(ShmChargerInfo->ParallelCabinet.PCabinet[index].OutputRelaySetting[index] != relay)
{
LOG_INFO("Set Parallel Cabinet Gun %d Output Relay %s", index + 1, relay == YES ? "ON" : "OFF");
}
ShmChargerInfo->ParallelCabinet.PCabinet[i].OutputRelaySetting[index] = relay;
}
}
}
}
void SetParallelCabinetAcContactor(unsigned char OnOff)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle &&
ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelConfirm)
{
ShmChargerInfo->ParallelCabinet.PCabinet[i].AcContactorSetting = OnOff == YES ? YES : NO;
}
}
}
unsigned short GetTotalParallelCabinetPower(void)
{
unsigned short power = 0, slavePow = 0;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Idle ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Alarm ||
ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DS_Charging)
{
slavePow = ParsingRatingPower((char *)ShmChargerInfo->ParallelCabinet.PCabinet[i].ModelName);
power += slavePow;
}
}
}
return power;
}
unsigned char preParallelStatus = 0;
void MCabinetParallelingProcess(void)
{
bool PsuReInitial = false;
unsigned char status = 0;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
if(IsReadyParalleling())
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelRequest)
{
ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelRequest = false;
ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelConfirm = true;
PsuReInitial = true;
}
}
if(PsuReInitial)
{
SetParallelingStart();
}
}
status = ShmChargerInfo->ParallelCabinet.ParallelStatus;
switch(status)
{
case _Parallel_None:
if(preParallelStatus != status)
{
LOG_INFO("MCabinet Parallel Status [None]");
GetClockTime(&_Parallel_Time);
}
unsigned short totalPow = 0;
totalPow = GetTotalParallelCabinetPower();
if(totalPow != ShmChargerInfo->ParallelCabinet.TotalParallelPower)
{
LOG_INFO("Total Parallel Cabinet Power: %d.%d kW", (totalPow / 10), (totalPow % 10));
}
ShmChargerInfo->ParallelCabinet.TotalParallelPower = totalPow;
break;
case _Parallel_Wait:
if(preParallelStatus != status)
{
LOG_INFO("MCabinet Parallel Status [Wait]");
SetAcContactor(OFF);
SetParallelCabinetAcContactor(OFF);
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
SetPCabinetOutputRelay(i, OFF);
}
GetClockTime(&_Parallel_Time);
}
if((GetTimeoutValue(_Parallel_Time) / uSEC_VAL) >= PARALLEL_WAIT_TIME)
{
ShmChargerInfo->ParallelCabinet.ParallelStatus = _Parallel_Working;
}
break;
case _Parallel_Working:
if(preParallelStatus != status)
{
LOG_INFO("MCabinet Parallel Status [Working]");
SetAcContactor(ON);
SetParallelCabinetAcContactor(ON);
GetClockTime(&_Parallel_Time);
}
if(ShmPsuData->Work_Step == _WORK_CHARGING)
{
ShmChargerInfo->ParallelCabinet.ParallelStatus = _Parallel_Done;
}
break;
case _Parallel_Done:
if(preParallelStatus != status)
{
LOG_INFO("MCabinet Parallel Status [Done]");
GetClockTime(&_Parallel_Time);
}
if((GetTimeoutValue(_Parallel_Time) / uSEC_VAL) >= PARALLEL_WAIT_TIME)
{
SetParallelingDone();
}
break;
}
preParallelStatus = status;
}
}
void SCabinetControllProcess(void)
{
if(ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE)
{
if(ShmChargerInfo->SCabinetControl.SAcContactor)
{
SetAcContactor(ON);
}
else
{
SetAcContactor(OFF);
}
unsigned short _parallelRelay = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
_parallelRelay = ShmChargerInfo->SCabinetControl.SParallelRelay[i] > 0 ? (1 < i) : 0;
}
if(_parallelRelay != ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue)
{
LOG_INFO("SCabinet Set Parallel Relay %X -> %X", ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue, _parallelRelay);
}
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue = _parallelRelay;
}
}
void CheckConnectorDisconnectionRecovery(unsigned char connector)
{
unsigned char dispenser = 0;
dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].ParentDispensetIndex;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_Timeout)
{
LOG_INFO("Connector %d Disconnection Recovery", connector + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.Disconnection = false;
}
}
bool ConnectorRequestToCharging(unsigned char connector)
{
unsigned char role = 0;
bool done = false;
role = ShmPsuGrouping->GroupCollection[connector].Role;
switch(role)
{
case _GROLE_IDLE:
if(!ShmPsuGrouping->GroupCollection[connector].GroupCtrl.bits.ChargingRequest)
{
LOG_INFO("Request Gun %d To Start Charging", connector + 1);
}
ShmPsuGrouping->GroupCollection[connector].GroupCtrl.bits.ChargingRequest = true;
break;
case _GROLE_MASTER:
done = true;
break;
case _GROLE_SLAVE:
if(!ShmPsuGrouping->GroupCollection[connector].GroupCtrl.bits.SlaveChargingRequest)
{
LOG_INFO("Gun %d Wait For Re-Grouping", connector + 1);
}
ShmPsuGrouping->GroupCollection[connector].GroupCtrl.bits.SlaveChargingRequest = true;
break;
case _GROLE_REQUEST_TO_CHARGING:
done = true;
break;
default:
break;
}
return done;
}
bool IsConnectorGroupingCompleted(unsigned char connector)
{
unsigned char role = 0;
bool completed = false;
role = ShmPsuGrouping->GroupCollection[connector].Role;
switch(role)
{
case _GROLE_MASTER:
completed = true;
break;
default:
break;
}
return completed;
}
void SelfTestFailReason(void)
{
char reason[50];
memset(reason, 0x00, sizeof(reason));
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip)
{
StatusCodeCompose(reason, "042251");
}
else if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail)
{
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail)
{
StatusCodeCompose(reason, "042280");
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail)
{
StatusCodeCompose(reason, "042281");
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail)
{
StatusCodeCompose(reason, "042282");
}
}
else if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail ||
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail)
{
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail)
{
StatusCodeCompose(reason, "042285");
}
if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail)
{
StatusCodeCompose(reason, "042286");
}
}
else
{
StatusCodeCompose(reason, "Self Test Fail");
}
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
SetOcppErrorCode(gun_index, "InternalError");
SetOcppVendorErrorCode(gun_index, reason);
setChargerMode(gun_index, MODE_MAINTAIN);
}
}
int main(void)
{
unsigned long time = 0;
if(CreateShareMemory() == 0)
{
#ifdef SystemLogMessage
LOG_ERROR("CreatShareMemory NG");
#endif
if(ShmStatusCodeData!=NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
}
sleep(5);
system("reboot -f");
sleep(5);
system("reboot -f");
}
LOG_INFO("\n");
LOG_INFO("===== Boot and Initialization start =====");
LOG_INFO("Main Fork PID = %d", getpid());
if (!InitialSystemDefaultConfig())
{
LOG_INFO("InitialSystemDefaultConfig NG");
StopProcessingLoop();
}
LOG_INFO("ModelName: [%s], SN: [%s], SW Version: [%s]",
ShmSysConfigAndInfo->SysConfig.ModelName, ShmSysConfigAndInfo->SysConfig.SerialNumber, fwVersion);
LOG_INFO("InitialShareMemoryInfo");
InitialShareMemoryInfo();
LOG_INFO("ChargerType (IEC or UL) = %d", ShmSysConfigAndInfo->SysInfo.ChargerType);
ChangeLcmByIndex(_LCM_INIT);
if(!InitialChargerSetting())
{
isModelNameMatch = false;
}
Initialization();
LOG_INFO("Spawn all Task.");
SpawnTask();
if (!isModelNameMatch)
{
LOG_INFO("Module Name & HW info none match.");
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ModelNameNoneMatchStestFail = YES;
ChangeLcmByIndex(_LCM_FIX);
// Module Name 與硬體對應不正確
LOG_ERROR("Module Name & HW info none match.");
sleep(3);
KillAllTask();
StopProcessingLoop();
}
LOG_INFO("Module Name & HW info correct. Initialize.......");
CreateTimeoutFork();
SelfTestRun();
while(ShmSysConfigAndInfo->SysInfo.BootingStatus != BOOT_COMPLETE)
{
sleep(1);
}
if(ShmSysConfigAndInfo->SysInfo.SelfTestSeq != _STEST_COMPLETE)
{
sleep(1);
SelfTestFailReason();
}
else
{
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
setChargerMode(gun_index, MODE_IDLE);
if(ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity > 0)
{
ShmChargerInfo->Control.GunAvailable[gun_index] = YES;
}
}
}
if(ShmChargerInfo->Control.CabinetRole != _CROLE_SLAVE)
{
SetAcContactor(ON);
SpawnOcppService();
}
else
{
InitSlaveCabinetEthernet();
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
setChargerMode(gun_index, MODE_MAINTAIN);
}
}
// Local DB
if(DB_Open(localDb) != PASS)
{
LOG_INFO("DB_Open fail.");
isDb_ready = false;
}
else
{
isDb_ready = true;
for(int _index=0; _index< ShmSysConfigAndInfo->SysConfig.TotalConnectorCount;_index++)
{
chargingInfo[_index]->IsAvailable = DB_Get_Operactive(localDb, _index);
}
}
ChangeLcmByIndex(_LCM_IDLE);
sleep(1);
CreateWatchdog();
// Main loop
LOG_INFO("%s \n", ShmSysConfigAndInfo->SysInfo.SelfTestSeq == _STEST_COMPLETE ?
"****************************Main Loop**********************************" :
"********************** SelfTest Fail **********************");
GetClockTime(&_cmdMainPriority_time);
for (;;)
{
CheckOcppStatus();
ChkPrimaryStatus();
ChkPsuStatus();
PsuFailureResume();
if ((IsConnectorWholeIdle() || ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_FIX) &&
ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag != Timeout_ReturnToChargingGunDet)
{
CheckFactoryConfigFunction();
CheckFwUpdateFunction();
}
if(CheckWiringInfoUpdate() != YES)
{
// return fork process
return 0;
}
CheckSoftHardReset();
StandbyCheck();
// OCPP 邏輯
//OcppRemoteStartChk();
// 讀卡邏輯
//ScannerCardProcess();
PowerCabinetAuthorizeProcess();
// 當 AC 沒有搭上時，清除一些錯誤碼
ClearAlarmCodeWhenAcOff();
if ((GetTimeoutValue(_cmdMainPriority_time) / uSEC_VAL) > MAIN_PRIORITY_INTERVAL)
{
CheckTask();
for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
{
if((chargingInfo[_index]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[_index]->SystemStatus <= S_CHARGING) ||
(chargingInfo[_index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[_index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
{
if (chargingInfo[_index]->SystemStatus == S_CHARGING && _ocppProfileChkFlag[_index] == 12)
{
Ocpp_ProfileReq_Cmd(_index);
gunOutputVol[_index] = chargingInfo[_index]->PresentChargingVoltage;
_ocppProfileChkFlag[_index] = 0;
}
else if (chargingInfo[_index]->SystemStatus != S_CHARGING)
{
Ocpp_ProfileReq_Cmd(_index);
_ocppProfileChkFlag[_index] = 0;
}
else
{
_ocppProfileChkFlag[_index]++;
}
}
}
GetClockTime(&_cmdMainPriority_time);
}
CheckMiscCommandRequirement();
CheckDispenserVersionUpdateRequirement();
MCabinetParallelingProcess();
SCabinetControllProcess();
for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
{
//CheckGpioInStatus();
CheckErrorOccurStatus(gun_index);
ChkOcppStatus(gun_index);
if((chargingInfo[gun_index]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[gun_index]->SystemStatus <= S_CHARGING) ||
(chargingInfo[gun_index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[gun_index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
{
if(chargingInfo[gun_index]->SystemStatus == S_CHARGING)
{
// 進充電後，如果輸出電壓落差大於 10V 則直接繼續看 ChargingProfile
if (chargingInfo[gun_index]->PresentChargingVoltage >= gunOutputVol[gun_index] + 10 ||
chargingInfo[gun_index]->PresentChargingVoltage <= gunOutputVol[gun_index] - 10)
{
_ocppProfileChkFlag[gun_index] = 12;
gunOutputVol[gun_index] = chargingInfo[gun_index]->PresentChargingVoltage;
}
}
}
CheckSmartChargeProfile(gun_index);
//LOG_INFO("index = %d, ErrorCode = %s \n", gun_index, ShmOCPP16Data->StatusNotification[gun_index].ErrorCode);
switch(chargingInfo[gun_index]->SystemStatus)
{
case S_MAINTAIN:
if(isModeChange(gun_index))
{
if(ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE)
{
LOG_INFO("================== Slave Cabinet %d ==================", ShmChargerInfo->Control.CabinetSwitch - 1);
}
LOG_INFO("================== S_MAINTAIN (%x) ================== \n", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AvailabilityRequest = true;
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetSecTimeoutValue(_SystemStatus_Time[gun_index]);
if(ShmSysConfigAndInfo->SysInfo.BootingStatus != BOOT_COMPLETE ||
ShmSysConfigAndInfo->SysInfo.SelfTestSeq != _STEST_COMPLETE ||
ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE)
{
break;
}
if(chargingInfo[gun_index]->IsAvailable == YES &&
(ShmChargerInfo->Control.GunAvailable[gun_index] == YES || ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity > 0) &&
ShmChargerInfo->ParallelCabinet.ParallelStatus == _Parallel_None)
{
if(time >= MAINTAIN_RECOVERY_TIME)
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AvailabilityRequest = true;
setChargerMode(gun_index, MODE_IDLE);
}
}
break;
case S_IDLE:
case S_RESERVATION:
case S_FAULT:
{
// clean PermissionRequest flag
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;
if(isModeChange(gun_index))
{
if (chargingInfo[gun_index]->SystemStatus == S_IDLE)
{
LOG_INFO("================== S_IDLE (%x) ================== \n", gun_index + 1);
chargingInfo[gun_index]->PresentChargedDuration = 0;
chargingInfo[gun_index]->RemainChargingDuration = 0;
strcpy((char *)chargingInfo[gun_index]->StartDateTime, "");
strcpy((char *)chargingInfo[gun_index]->StopDateTime, "");
strcpy((char *)chargingInfo[gun_index]->StartUserId, "");
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "");
ReleaseAlarmCode(gun_index);
// clean connector information
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType = _AuthType_None;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingResult = _AuthResult_None;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingVoltage = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingCurrent = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteRemainChargingDuration = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteSoc = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].UserPrice = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].TotalCost = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AccountBalance = -6553500;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AnnounceBalance = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.StartWaitPlug = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.OutputLimitEnable = false;
chargingInfo[gun_index]->EvBatterytargetVoltage = 0;
chargingInfo[gun_index]->EvBatterytargetCurrent = 0;
chargingInfo[gun_index]->EvBatteryMaxVoltage = 0;
chargingInfo[gun_index]->EvBatterySoc = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteTargetVoltage = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteTargetCurrent = 0;
// clean RemoteStart & RemoteStop flag
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStopConfirm = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.UnlockStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.UnlockStopConfirm = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NormalStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AlarmStopRequest = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest = false;
memset(chargingInfo[gun_index]->ConnectorAlarmCode, 0x00, sizeof(chargingInfo[gun_index]->ConnectorAlarmCode));
memset(&ShmOCPP16Data->Cost.RunningCost[gun_index], 0x00, sizeof(struct StrcutRunningCost));
memset(&ShmOCPP16Data->Cost.FinalCost[gun_index], 0x00, sizeof(struct StrcutFinalCost));
chargingInfo[gun_index]->PresentChargedEnergy = 0;
chargingInfo[gun_index]->PresentChargingPower = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingPower = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingCurrent = 0;
chargingInfo[gun_index]->ChargingProfilePower = -1;
chargingInfo[gun_index]->ChargingProfileCurrent = -1;
// clean force charging info
memset(&ShmChargerInfo->Control.FCharging[gun_index], 0x00, sizeof(ForceCharging));
}
else if (chargingInfo[gun_index]->SystemStatus == S_RESERVATION)
{
LOG_INFO("================== S_RESERVATION (%x) ================== \n", gun_index + 1);
ShmOCPP16Data->CsMsg.bits[gun_index].ReserveNowConf = YES;
}
else if (chargingInfo[gun_index]->SystemStatus == S_FAULT)
{
LOG_INFO("================== S_FAULT (%x) ================== \n", gun_index + 1);
}
GetClockTime(&_SystemStatus_Time[gun_index]);
}
if (chargingInfo[gun_index]->IsAvailable == NO ||
(ShmChargerInfo->Control.GunAvailable[gun_index] == NO && ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity == 0))
{
setChargerMode(gun_index, MODE_MAINTAIN);
continue;
}
if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2 ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Alarm ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest ||
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest)
{
if(strncmp((char *)chargingInfo[gun_index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[gun_index]->ConnectorAlarmCode, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemotenAlarmCode, 6);
}
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest = false;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
{
if(strncmp((char *)chargingInfo[gun_index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[gun_index]->ConnectorAlarmCode, "042304", 6);
LOG_INFO("Connector %d Disconnect Occur", gun_index + 1);
}
}
if(chargingInfo[gun_index]->SystemStatus != S_FAULT)
{
ClearDetectPluginFlag();
UpdateErrorCodeToOcpp(gun_index);
setChargerMode(gun_index, MODE_FAULT);
}
else
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
{
CheckConnectorDisconnectionRecovery(gun_index);
}
}
}
else
{
if (chargingInfo[gun_index]->SystemStatus == S_FAULT)
{
time = GetSecTimeoutValue(_SystemStatus_Time[gun_index]);
if(time >= FAULT_RELEASE_TIME)
{
ReleaseAlarmCode(gun_index);
setChargerMode(gun_index, MODE_IDLE);
}
break;
}
// clean stop charge flag
chargingInfo[gun_index]->StopChargeFlag = false;
chargingInfo[gun_index]->ChargingStopFlag.ChargingStopValue = 0;
{ // Idle 正常程序起點
// 判斷是否有啟用檢查插槍
if(IsConnectorAuthorizeSuccess(gun_index))
{
if(chargingInfo[gun_index]->IsAvailable &&
chargingInfo[gun_index]->SystemStatus == S_IDLE)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RemoteStart)
{
LOG_INFO("Connector %d remote start charging", gun_index + 1);
}
else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RFID)
{
LOG_INFO("Connector %d swipe rfid start charging", gun_index + 1);
}
setChargerMode(gun_index, MODE_AUTHORIZING);
continue;
}
}
else if(IsAutoGunSelectionAuthorizeSuccess(gun_index))
{
if(chargingInfo[gun_index]->IsAvailable &&
chargingInfo[gun_index]->SystemStatus == S_IDLE &&
chargingInfo[gun_index]->ConnectorPlugIn &&
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Preparing)
{
strcpy((char *)chargingInfo[gun_index]->StartUserId, (char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].ParentDispensetIndex].UserId);
LOG_INFO("Auto Gun Selection %d, CardNumber = %s", gun_index, chargingInfo[gun_index]->StartUserId);
DispenserAuthorizationInitial(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].ParentDispensetIndex);
setChargerMode(gun_index, MODE_REASSIGN_CHECK);
continue;
}
}
else if (chargingInfo[gun_index]->SystemStatus == S_RESERVATION)
{
if (!isReservationExpired(gun_index))
{
chargingInfo[gun_index]->SystemStatus = S_IDLE;
}
}
// only for test & debug purpose
else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging &&
ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.StartForceCharging)
{
ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.StartForceCharging = false;
LOG_INFO("Gun %d Start Force Charging", gun_index + 1);
setChargerMode(gun_index, MODE_REASSIGN_CHECK);
continue;
}
else
{
}
} // Idle 正常程序終點
}
}
break;
case S_AUTHORIZING:
if(isModeChange(gun_index))
{
LOG_INFO("================== S_AUTHORIZING (%x) ================== \n", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
//StopSystemTimeoutDet();
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = false;
SetAcContactor(ON);
GetClockTime(&_ConnectorAuthorizing_Time[gun_index]);
}
if(GetTimeoutValue(_ConnectorAuthorizing_Time[gun_index]) / uSEC_VAL >= FORCE_BALANCE_TIME)
{
FouceAnnounceAccountBalance(gun_index);
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RemoteStart)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm)
{
// sync with dispenser
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm = false;
GetClockTime(&_ConnectorAuthorizing_Time[gun_index]);
LOG_INFO("Sync with Gun %d through remote start", gun_index + 1);
FouceAnnounceAccountBalance(gun_index);
}
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RFID)
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.SwipeRfidConfirm)
{
// sync with dispenser
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.SwipeRfidConfirm = false;
GetClockTime(&_ConnectorAuthorizing_Time[gun_index]);
LOG_INFO("Sync with Connector %d through swipe rfid", gun_index + 1);
}
}
if(GetTimeoutValue(_ConnectorAuthorizing_Time[gun_index]) / uSEC_VAL >= ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout)
{
if(!chargingInfo[gun_index]->ConnectorPlugIn)
{
LOG_INFO("*********** Gun %d Plug In Timeout ***********", gun_index + 1);
}
else
{
LOG_INFO("*********** Gun %d Preparing State Timeout ***********", gun_index + 1);
}
setChargerMode(gun_index, MODE_IDLE);
ConnectorAuthorizationInitial(gun_index);
}
else
{
if(chargingInfo[gun_index]->ConnectorPlugIn &&
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Preparing)
{
AddPlugInTimes(gun_index);
LOG_INFO("index = %d, CardNumber = %s \n", gun_index, chargingInfo[gun_index]->StartUserId);
setChargerMode(gun_index, MODE_REASSIGN_CHECK);
ConnectorAuthorizationInitial(gun_index);
}
else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo)
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.StartWaitPlug = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo = false;
LOG_INFO("*********** Gun %d User Stop Plug In ***********", gun_index + 1);
setChargerMode(gun_index, MODE_IDLE);
ConnectorAuthorizationInitial(gun_index);
}
else if(isEvBoardStopChargeFlag(gun_index) == YES)
{
LOG_INFO("********** Gun %d Alarm Stop (S_AUTHORIZING) **********", gun_index + 1);
setChargerMode(gun_index, MODE_IDLE);
ConnectorAuthorizationInitial(gun_index);
}
}
break;
case S_REASSIGN_CHECK:
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_REASSIGN_CHECK (%x) ================== \n", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
//StopSystemTimeoutDet();
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = false;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputEnergy = ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputDuration = ShmSysConfigAndInfo->SysConfig.MaxChargingDuration;
LOG_INFO("Max Total Current %d A, Max Total Power %d kW, Total Energy %d kWh, Total Duration %d",
ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent,
ShmSysConfigAndInfo->SysConfig.MaxChargingPower,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputEnergy,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputDuration);
SetAcContactor(ON);
SetPCabinetOutputRelay(gun_index, ON);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if(ConnectorRequestToCharging(gun_index))
{
setChargerMode(gun_index, MODE_REASSIGN);
}
else if(time >= WAIT_REASSIGN_TIME)
{
if(ShmPsuData->Work_Step != _WORK_CHARGING)
{
LOG_INFO("Gun %d Wait PSU Work Step Timeout", gun_index + 1);
}
else
{
LOG_INFO("Gun %d Request Charging Timeout", gun_index + 1);
}
setChargerMode(gun_index, MODE_IDLE);
}
}
break;
case S_REASSIGN:
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_REASSIGN (%x) ================== \n", gun_index + 1);
//gettimeofday(&_toAverage_time, NULL);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if(IsConnectorGroupingCompleted(gun_index))
{
setChargerMode(gun_index, MODE_PRECHARGE);
}
else if(time >= MAX_REQUEST_CHARGING_TIME)
{
LOG_INFO("Gun %d Grouping Timeout", gun_index + 1);
setChargerMode(gun_index, MODE_IDLE);
}
}
break;
case S_PREPARNING:
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_PREPARNING (%x) ================== \n", gun_index + 1);
//StopGunInfoTimeoutDet(gun_index);
//StartGunInfoTimeoutDet(gun_index, Timeout_Preparing);
SetAcContactor(ON);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if ((chargingInfo[gun_index]->AvailableChargingPower > 10) && time >= MIN_WAIT_PREPARNING_TIME)
{
setChargerMode(gun_index, MODE_PREPARE_FOR_EV);
continue;
}
if (isEvBoardStopChargeFlag(gun_index) == YES)
{
// 板端或後臺要求停止
LOG_INFO("********** Gun %d Alarm Stop (S_PREPARNING) **********", gun_index + 1);
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
}
ChargingAlarmProcess(gun_index);
}
else if(isNormalStopChargeFlag(gun_index) == YES)
{
LOG_INFO("********** Gun %d Normal Stop (S_PREPARNING) %s**********", gun_index + 1,
chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
}
ChargingTerminalProcess(gun_index);
}
if(time > GUN_PREPARE_TIMEOUT)
{
LOG_INFO("********** Gun %d PrepareTimeout **********", gun_index + 1);
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = YES;
if(strncmp((char *)chargingInfo[gun_index]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy(chargingInfo[gun_index]->ConnectorAlarmCode, "012279", 6);
LOG_INFO("Gun %d No Psu Resource", gun_index + 1);
}
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
}
ChargingAlarmProcess(gun_index);
}
}
break;
case S_PREPARING_FOR_EV: // 等待車端的通訊 (EV 小板)，待車端回報後，開始樁端的測試
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_PREPARING_FOR_EV (%x) ================== \n", gun_index + 1);
//strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
//StopGunInfoTimeoutDet(gun_index);
//StartGunInfoTimeoutDet(gun_index, Timeout_EvChargingDet);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest)
{
setChargerMode(gun_index, MODE_PREPARE_FOR_EVSE);
}
// only for test & debug purpose
else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
{
LOG_INFO("Gun %d [Force Charging] S_PREPARING_FOR_EV OK", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest = true;
}
if (isEvBoardStopChargeFlag(gun_index) == YES)
{
// 板端或後臺要求停止
LOG_INFO("********** Gun %d Alarm Stop (S_PREPARING_FOR_EV) **********", gun_index + 1);
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
}
ChargingAlarmProcess(gun_index);
}
else if(isNormalStopChargeFlag(gun_index) == YES)
{
LOG_INFO("********** Gun %d Normal Stop (S_PREPARING_FOR_EV) %s**********", gun_index + 1,
chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
}
ChargingTerminalProcess(gun_index);
}
if(time >= GUN_EV_WAIT_TIMEOUT)
{
LOG_INFO("********** Gun %d Wait Dispenser Timeout **********", gun_index + 1);
ChargingTerminalProcess(gun_index);
}
}
break;
case S_PREPARING_FOR_EVSE: // 等待 RB 通訊及測試，並將狀態回報， CSU 確認 Pass 後，開始進入充電
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_PREPARING_FOR_EVSE (%x) ================== \n", gun_index + 1);
//StopGunInfoTimeoutDet(gun_index);
//StartGunInfoTimeoutDet(gun_index, Timeout_EvseChargingDet);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
// only for test & debug purpose
if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
{
float voltage = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetVoltage / 10;
float current = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetCurrent / 10;
if(chargingInfo[gun_index]->EvBatterytargetVoltage != voltage || chargingInfo[gun_index]->EvBatterytargetCurrent != current)
{
LOG_INFO("Gun %d Set Force Charging Voltage %4d V, Current: %4d A", gun_index + 1, (int)voltage, (int)current);
}
chargingInfo[gun_index]->EvBatterytargetVoltage = voltage;
chargingInfo[gun_index]->EvBatterytargetCurrent = current;
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Charging)
{
setChargerMode(gun_index, MODE_CHARGING);
}
// only for test & debug purpose
else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
{
if(time >= FORCE_CHARGING_WAIT_EVSE)
{
LOG_INFO("Gun %d [Charging Simulation] S_PREPARING_FOR_EVSE OK", gun_index + 1);
setChargerMode(gun_index, MODE_CHARGING);
}
}
if (isEvBoardStopChargeFlag(gun_index) == YES)
{
// 板端或後臺要求停止
LOG_INFO("********** Gun %d Alarm Stop (S_PREPARING_FOR_EVSE) **********", gun_index + 1);
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
}
ChargingAlarmProcess(gun_index);
}
else if(isNormalStopChargeFlag(gun_index) == YES)
{
LOG_INFO("********** Gun %d Normal Stop (S_PREPARING_FOR_EVSE) %s**********", gun_index + 1,
chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
}
ChargingTerminalProcess(gun_index);
}
if(time >= GUN_EVSE_WAIT_TIMEOUT)
{
LOG_INFO("********** Gun %d GFD timeout **********", gun_index + 1);
ChargingTerminalProcess(gun_index);
}
}
break;
case S_CHARGING: // 剛進入充電狀態，等待 EV 小板要求的輸出電流後開始輸出
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_CHARGING (%x) ================== \n", gun_index + 1);
//StopGunInfoTimeoutDet(gun_index);
GetClockTime(&_SystemStatus_Time[gun_index]);
chargingInfo[gun_index]->PresentChargedDuration = 0;
ChangeStartOrStopDateTime(YES, gun_index);
OcppStartTransation(gun_index);
}
// only for test & debug purpose
if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
{
float voltage = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetVoltage / 10;
float current = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetCurrent / 10;
if(chargingInfo[gun_index]->EvBatterytargetVoltage != voltage || chargingInfo[gun_index]->EvBatterytargetCurrent != current)
{
LOG_INFO("Gun %d Set Force Charging Voltage %4d V, Current: %4d A", gun_index + 1, (int)voltage, (int)current);
}
chargingInfo[gun_index]->EvBatterytargetVoltage = voltage;
chargingInfo[gun_index]->EvBatterytargetCurrent = current;
}
time = GetSecTimeoutValue(_SystemStatus_Time[gun_index]);
// 計算 Power
//chargingInfo[gun_index]->PresentChargingPower = ((float)((chargingInfo[gun_index]->PresentChargingVoltage) * (chargingInfo[gun_index]->PresentChargingCurrent)) / 1000);
chargingInfo[gun_index]->PresentChargingPower = (((float)((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingVoltage) * (ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingCurrent))) / 1000 / 100);
if(time >= (chargingInfo[gun_index]->PresentChargedDuration + ENERAGY_INTERVAL))
{
chargingInfo[gun_index]->PresentChargedDuration++;
float changingPow = (chargingInfo[gun_index]->PresentChargingPower) / 3600;
if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
{
chargingInfo[gun_index]->ChargingFee += changingPow * ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee;
}
chargingInfo[gun_index]->PresentChargedEnergy += changingPow;
chargingInfo[gun_index]->PowerConsumption += changingPow;
}
if (isEvBoardStopChargeFlag(gun_index))
{
LOG_INFO("********** Gun %d Alarm Stop (S_CHARGING) **********", gun_index + 1);
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
}
ChargingAlarmProcess(gun_index);
}
else if(isNormalStopChargeFlag(gun_index) == YES)
{
LOG_INFO("********** Gun %d Normal Stop (S_CHARGING) %s**********", gun_index + 1,
chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
}
ChargingTerminalProcess(gun_index);
}
else if(CheckBackendChargingTimeout(gun_index) ||
CheckBackendChargingEnergy(gun_index))
{
LOG_INFO("********** Gun %d Backend Stop (S_CHARGING) **********", gun_index + 1);
// 板端或後臺要求停止
ChargingTerminalProcess(gun_index);
}
else if(ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf)
{
if(Ocpp_CheckInvalidId(gun_index))
{
LOG_INFO("********** Gun %d Backend InvalidId Stop (S_CHARGING) **********", gun_index + 1);
ChargingTerminalProcess(gun_index);
}
}
if(ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf)
{
ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf = NO;
if(strcmp((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "Accepted") == EQUAL)
{
LOG_INFO("Gun %d OCPP Start Transaction Accepted, Id = %d", gun_index + 1, ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId);
}
}
}
break;
case S_ALARM:
case S_TERMINATING:
{
if (isModeChange(gun_index))
{
if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
{
strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Other");
}
if (chargingInfo[gun_index]->SystemStatus == S_ALARM)
{
LOG_INFO("================== S_ALARM (%x) ================== \n", gun_index + 1);
UpdateErrorCodeToOcpp(gun_index);
if (strcmp((char *)chargingInfo[gun_index]->StartDateTime, "") != EQUAL)
{
OcppStopTransation(gun_index);
}
TheEndCharging(gun_index);
}
else
{
LOG_INFO("================== S_TERMINATING (%x) ================== \n", gun_index + 1);
}
//StopGunInfoTimeoutDet(gun_index);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if (chargingInfo[gun_index]->SystemStatus == S_ALARM)
{
if(time >= GUN_COMP_WAIT_TIMEOUT)
{
if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
{
LOG_INFO ("********** Gun %d psu is releasable **********\n", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;
}
}
if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Idle || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable == false) &&
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
{
setChargerMode(gun_index, MODE_IDLE);
}
}
else
{
setChargerMode(gun_index, MODE_COMPLETE);
}
}
break;
case S_COMPLETE:
{
if (isModeChange(gun_index))
{
LOG_INFO("================== S_COMPLETE (%x) ================== \n", gun_index + 1);
if (strcmp((char *)chargingInfo[gun_index]->StartDateTime, "") != EQUAL)
{
OcppStopTransation(gun_index);
}
TheEndCharging(gun_index);
GetClockTime(&_SystemStatus_Time[gun_index]);
}
time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;
if(time >= GUN_COMP_WAIT_TIMEOUT)
{
if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
{
LOG_INFO ("********** Gun %d psu is releasable **********", gun_index + 1);
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;
}
}
if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Idle || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable == false) &&
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
{
setChargerMode(gun_index, MODE_IDLE);
}
}
break;
case S_CCS_PRECHARGE_ST0:
if (isModeChange(gun_index))
{
LOG_INFO("CCS Precharge Processing 1....................%x \n", gun_index);
//StopGunInfoTimeoutDet(gun_index);
//StartGunInfoTimeoutDet(gun_index, Timeout_ForCcsPrechargeDet);
}
break;
case S_CCS_PRECHARGE_ST1:
if (isModeChange(gun_index))
{
LOG_INFO("CCS Precharge Processing 2....................%x \n", gun_index);
}
break;
}
}
if (ShmSysConfigAndInfo->SysInfo.SystemPage != _LCM_NONE)
{
ChangeLcmByIndex(ShmSysConfigAndInfo->SysInfo.SystemPage);
}
else
{
bool dcPageRun = true;
if (dcPageRun)
ChangeLcmByIndex(ShmSysConfigAndInfo->SysInfo.ConnectorPage);
}
TryFeedWatchdog();
usleep(whileLoopTime);
}
return FAIL;
}