/*
* Main.c
*
* Created on: 2019年8月6日
* Author: 7564
*/
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.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 <time.h>
#include <ctype.h>
#include <ifaddrs.h>
#include <math.h>
#include <stdbool.h>
#include "../../define.h"
#include "Config.h"
#include "Module_EvComm.h"
#include "Common.h"
typedef unsigned char byte;
#define NO_DEFINE 255
#define OPTION_CNT 4
#define STR_OPTION '-'
#define OPTION_REFLASH 0x00000001
#define OPTION_LOOP 0x00000002
#define OPTION_OUTPUT_FILE 0x00000004
#define OPTION_TIME 0x00000008
#define MAX_SUB_CMD_QUANTITY 16
#define MAX_SUB_CMD_LENGTH 128
#define STR_OPT_REFLASH 'f'
#define STR_OPT_LOOP 'l'
#define STR_OPT_OUTPUT_FILE 'o'
#define STR_OPT_TIME 't'
#define TTY_PATH "/dev/tty"
#define STTY_US "stty raw -echo -F "
#define STTY_DEF "stty -raw echo -F "
struct SysConfigAndInfo *ShmSysConfigAndInfo;
struct StatusCodeData *ShmStatusCodeData;
struct PrimaryMcuData *ShmPrimaryMcuData;
struct CHAdeMOData *ShmCHAdeMOData;
struct CcsData *ShmCcsData;
struct GBTData *ShmGBTData;
struct FanModuleData *ShmFanModuleData;
struct RelayModuleData *ShmRelayModuleData;
struct LedModuleData *ShmLedModuleData;
struct PsuData *ShmPsuData;
ChargerInfoData *ShmChargerInfo;
PsuPositionInfoData *ShmPsuPosition;
PsuGroupingInfoData *ShmPsuGrouping;
struct OCPP16Data *ShmOCPP16Data;
struct OCPP20Data *ShmOCPP20Data;
struct ChargingInfoData *_chargingData[CONNECTOR_QUANTITY];
struct ChargingInfoData *ac_chargingInfo[AC_QUANTITY];
char MultiSubCmd[MAX_SUB_CMD_QUANTITY][MAX_SUB_CMD_LENGTH];
int totalSubCnt = 0;
char *msg = "state : get gun state (index) \n"
"card : scanning card (x) : \n"
"gun : get gun plugit state (index) \n"
"lock : get gun locked state (index) \n"
"self : self test state (x) \n"
"ver : ver of board (407 or index or rb or fan) \n"
"ac : get ac relay state (x) \n"
"gunchg: set gun start charging \n"
"gunstp: set gun stop charging \n"
"gunext: extend gun capability \n";
bool FindChargingInfoData(byte target, struct ChargingInfoData **chargingData)
{
for (byte index = 0; index < CHAdeMO_QUANTITY; index++)
{
if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == target)
{
chargingData[target] = &ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index];
return true;
}
}
for (byte index = 0; index < CCS_QUANTITY; index++)
{
if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == target)
{
chargingData[target] = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[index];
return true;
}
}
for (byte index = 0; index < GB_QUANTITY; index++)
{
if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == target)
{
chargingData[target] = &ShmSysConfigAndInfo->SysInfo.GbChargingData[index];
return true;
}
}
if(GENERAL_GUN_QUANTITY > 0 && target < GENERAL_GUN_QUANTITY)
{
chargingData[target] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[target].GeneralChargingData;
return true;
}
return false;
}
bool FindAcChargingInfoData(byte target, struct ChargingInfoData **acChargingData)
{
if (target < AC_QUANTITY)
{
acChargingData[target] = &ShmSysConfigAndInfo->SysInfo.AcChargingData[target];
return true;
}
return false;
}
int InitShareMemory()
{
int result = PASS;
int MeterSMId;
//initial ShmSysConfigAndInfo
if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), 0777)) < 0)
{
result = FAIL;
}
else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
else
{}
//initial ShmStatusCodeData
if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), 0777)) < 0)
{
result = FAIL;
}
else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
else
{}
if (CHAdeMO_QUANTITY > 0) {
if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData),
IPC_CREAT | 0777)) < 0) {
result = FAIL;
} else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0))
== (void *) -1) {
result = FAIL;
} else {
}
}
if (CCS_QUANTITY > 0) {
if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),
IPC_CREAT | 0777)) < 0) {
result = FAIL;
} else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1) {
result = FAIL;
} else {
}
}
if (GB_QUANTITY > 0) {
if ((MeterSMId = shmget(ShmGBTCommKey, sizeof(struct GBTData),
IPC_CREAT | 0777)) < 0) {
return 0;
} else if ((ShmGBTData = shmat(MeterSMId, NULL, 0)) == (void *) -1) {
return 0;
}
memset(ShmGBTData, 0, sizeof(struct GBTData));
}
if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0)
{
result = FAIL;
}
else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData), IPC_CREAT | 0777)) < 0)
{
result = FAIL;
}
else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0)
{
result = FAIL;
}
else if ((ShmRelayModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmLedBdKey, sizeof(struct LedModuleData), 0777)) < 0)
{
result = FAIL;
}
else if ((ShmLedModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), IPC_CREAT | 0777)) < 0)
{
result = FAIL;
}
else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), IPC_CREAT | 0777)) < 0)
{
result = FAIL;
}
else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), 0777)) < 0)
{
result = FAIL;
}
else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if ((MeterSMId = shmget(ShmOcpp20ModuleKey, sizeof(struct OCPP20Data), 0777)) < 0)
{
result = FAIL;
}
else if ((ShmOCPP20Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
result = FAIL;
}
if(result == PASS)
{
ShmPsuPosition = &ShmChargerInfo->PsuPosition;
ShmPsuGrouping = &ShmChargerInfo->PsuGrouping;
}
return result;
}
void Get_Ocpp_TransactionId(int gun_index, char *transactionId)
{
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
{
sprintf(transactionId, "%d", ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId);
return;
}
if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
{
strcpy(transactionId, (char *)&ShmOCPP20Data->TransactionEvent [gun_index].transactionInfo.transactionId[0]);
return;
}
sprintf(transactionId, "%d", 0);
}
static void get_char(char *word)
{
fd_set rfds;
struct timeval tv;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 10; //wait input timout time
//if input
if (select(1, &rfds, NULL, NULL, &tv) > 0)
{
fgets(word, 128, stdin);
}
}
// return command length
int ParsingCmd(char *inputString, char *outputString)
{
bool valid = false, done = false;
int len = 0, start = 0;
for(int i = 0; i < strlen(inputString); i++)
{
if(!valid)
{
if(inputString[i] != ' ' && inputString[i] != '\0' && inputString[i] != '\r' && inputString[i] != '\n')
{
valid = true;
start = i;
}
}
else
{
if(inputString[i] == ' ' || inputString[i] == '\0' || inputString[i] == '\r' || inputString[i] == '\n' || len >= MAX_SUB_CMD_LENGTH)
{
done = true;
break;
}
}
len = (valid && !done) ? len + 1 : len;
}
if(valid)
{
memcpy(outputString, &inputString[start], len);
outputString[len] = '\0';
}
return len;
}
bool IsOption(char *strCmd, unsigned int *opt)
{
int len = 0;
char str_opt[OPTION_CNT] = {STR_OPT_REFLASH, STR_OPT_LOOP, STR_OPT_OUTPUT_FILE, STR_OPT_TIME};
unsigned int opt_value[OPTION_CNT] = {OPTION_REFLASH, OPTION_LOOP, OPTION_OUTPUT_FILE, OPTION_TIME};
len = strlen(strCmd);
if(len == 2)
{
if(strCmd[0] == STR_OPTION)
{
for(int i = 0; i < OPTION_CNT; i++)
{
if(strCmd[1] == str_opt[i])
{
*opt |= opt_value[i];
return true;
}
}
}
}
return false;
}
// inputCmdString: console input string
// outputCmdString: input string parsed
// return command quantity
int InputStringNormalize(char *inputCmdString, char *outputCmdString, unsigned int *opt)
{
int len = 0, cnt = 0, start = 0;
int cmdLen = 0, totalLen = 0;
len = strlen(inputCmdString);
*opt = 0;
if(len > 0)
{
while(start < len)
{
if(inputCmdString[start] != ' ' && inputCmdString[start] != '\0' &&
inputCmdString[start] != '\r' && inputCmdString[start] != '\n')
{
cmdLen = ParsingCmd(&inputCmdString[start], &outputCmdString[totalLen]);
if(cmdLen > 0)
{
//printf("Find %d Cmd: %s\r\n", cnt + 1, &outputCmdString[totalLen]);
if(!IsOption(&outputCmdString[totalLen], opt))
{
outputCmdString[totalLen + cmdLen] = ' ';
cnt++;
totalLen += cmdLen + 1;
}
start += cmdLen;
}
}
else
{
start++;
}
}
outputCmdString[totalLen - 1] = '\0';
}
return cnt;
}
int MainAndSubCommandParsing(char *normalCmd, char *mainCmd, char *subCmd)
{
int len = 0, totalLen = 0;
int quantity = 0;
strcpy(mainCmd, "");
strcpy(subCmd, "");
totalLen = strlen(normalCmd);
if(totalLen > 0)
{
len = ParsingCmd(normalCmd, mainCmd);
//printf("Find MainCmd: %s\r\n", mainCmd);
quantity = len > 0 ? (quantity + 1) : quantity;
if(len > 0 && totalLen > len)
{
strcpy(subCmd, &normalCmd[len + 1]);
//printf("Find SubCmd: %s\r\n", subCmd);
len = strlen(subCmd);
quantity = len > 0 ? (quantity + 1) : quantity;
}
}
return quantity;
}
int GetCommandSring(char *outputCmdString)
{
int len = 0, cnt = 0;
int cmdLen = 0, totalLen = 0;
char word[128];
memset(word, 0x00, sizeof(word));
get_char(word);
len = strlen(word);
if(len == 0)
{
return -1;
}
int start = 0;
while(start < len - 1)
{
if(word[start] != ' ' && word[start] != '\0')
{
cmdLen = ParsingCmd(&word[start], &outputCmdString[totalLen]);
char newCmd[MAX_SUB_CMD_LENGTH];
memset(newCmd, 0x00, MAX_SUB_CMD_LENGTH);
memcpy(newCmd, &outputCmdString[totalLen], cmdLen);
cnt = cmdLen > 0 ? cnt + 1 : cnt;
totalLen += cmdLen + 1;
start += cmdLen;
}
else
{
start++;
}
}
return cnt;
}
bool IsLoopStopCmd(void)
{
bool stop = false;
int cnt = 0;
char cmd[256];
char totalCmd[256];
memset(cmd, 0x00, 256);
memset(totalCmd, 0x00, 256);
cnt = GetCommandSring(totalCmd);
if(cnt > 0)
{
strcpy(&cmd[0], totalCmd);
if(strcmp(&cmd[0], "c") == 0)
{
stop = true;
}
}
return stop;
}
void ConsoleReflash(int groupCnt, int lineCnt)
{
for(int i = 0; i < groupCnt; i++)
{
for(int i = 0; i < lineCnt; i++)
{
printf("\033[1A");
printf("\033[K");
}
}
printf("\r");
}
int GetSubCommand(char *inputCmd)
{
unsigned int paraOpt = 0;
int loopLimit = 0;
char normalString[128];
totalSubCnt = InputStringNormalize(inputCmd, normalString, ¶Opt);
if(totalSubCnt > MAX_SUB_CMD_QUANTITY)
{
totalSubCnt = MAX_SUB_CMD_QUANTITY;
}
if(totalSubCnt > 0)
{
loopLimit = totalSubCnt > 1 ? totalSubCnt - 1 : 1;
for(int i = 0; i < loopLimit; i++)
{
memset(&MultiSubCmd[i][0], 0x00, MAX_SUB_CMD_LENGTH);
memset(&MultiSubCmd[i + 1][0], 0x00, MAX_SUB_CMD_LENGTH);
MainAndSubCommandParsing(normalString, &MultiSubCmd[i][0], &MultiSubCmd[i + 1][0]);
strcpy(normalString, &MultiSubCmd[i + 1][0]);
}
}
return totalSubCnt;
}
void RunStatusProc(char *v1, char *v2)
{
printf("OrderCharging = %d \n", ShmSysConfigAndInfo->SysInfo.OrderCharging);
printf("WaitForPlugit = %d \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
if (strcmp(v1, "ac") == 0)
{
if (!FindAcChargingInfoData(0, &ac_chargingInfo[0]))
{
printf("FindChargingInfoData (AC) false \n");
}
printf("AC Status = %d \n", ac_chargingInfo[0]->ConnectorPlugIn);
return;
}
int _index = atoi(v1);
if (_index <= 3)
{
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf ("FindChargingInfoData error\n");
return;
}
if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0)
{
// get
printf ("index = %x, status = %x (%d)\n", _index, _chargingData[_index]->SystemStatus, _chargingData[_index]->IsAvailable);
printf ("SystemTimeoutFlag = %d, PageIndex = %d\n",
ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag, ShmSysConfigAndInfo->SysInfo.PageIndex);
printf("ConnectorAlarmCode = %s \n", _chargingData[_index]->ConnectorAlarmCode);
printf("EvConnAlarmCode = %s \n", _chargingData[_index]->EvConnAlarmCode);
printf("RemotenAlarmCode = %s \n", ShmSysConfigAndInfo->SysInfo.ConnectorInfo[_index].RemotenAlarmCode);
}
else
{
// set
_chargingData[_index]->SystemStatus = atoi(v2);
}
}
else
{
if (!FindAcChargingInfoData(0, &ac_chargingInfo[0]))
{
printf("FindChargingInfoData (AC) false \n");
}
if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0)
{
// get
printf ("AC Type, status = %x (%d)\n", ac_chargingInfo[0]->SystemStatus, ac_chargingInfo[0]->IsAvailable);
}
else
{
// set
ac_chargingInfo[0]->SystemStatus = atoi(v2);
}
}
}
void RunCardProc(char *v1, char *v2)
{
if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0)
{
if (ShmSysConfigAndInfo->SysInfo.WaitForPlugit)
{
ShmSysConfigAndInfo->SysInfo.WaitForPlugit = 0x00;
printf ("SysInfo.WaitForPlugit = %x \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
}
else
{
ShmSysConfigAndInfo->SysInfo.WaitForPlugit = 0x01;
printf ("SysInfo.WaitForPlugit = %x \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
}
}
else
{
strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
memcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, v1, strlen(v1));
ShmSysConfigAndInfo->SysConfig.UserId[strlen(v1)] = '\0';
printf("StartUserId = %s \n", ShmSysConfigAndInfo->SysConfig.UserId);
}
}
void RunGunPlugitProc(char *v1, char *v2)
{
if (strcmp(v1, "ac") == 0)
{
if (!FindAcChargingInfoData(0, &ac_chargingInfo[0]))
{
printf("FindChargingInfoData (AC) false \n");
}
if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0)
{
// get
printf("ConnectorPlugIn = %d \n", ac_chargingInfo[0]->ConnectorPlugIn);
}
else
{
// set
ac_chargingInfo[0]->ConnectorPlugIn = atoi(v2);
}
return;
}
int _index = atoi(v1);
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf("FindChargingInfoData error\n");
return;
}
if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0)
{
// get
printf("index = %x, plug it = %x\n", _index, _chargingData[_index]->ConnectorPlugIn);
}
else
{
// set
_chargingData[_index]->ConnectorPlugIn = atoi(v2);
}
}
void GetGunLockStatusProc(char *v1, char *v2)
{
int _index = atoi(v1);
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf("FindChargingInfoData error\n");
return;
}
if (strcmp(v2, "-1") != 0 && strcmp(v2, "") != 0)
{
_chargingData[_index]->GunLocked = atoi(v2);
}
printf("Gun Locked Status = %d \n", _chargingData[_index]->GunLocked);
}
void SetSystemIDProc()
{
char *systemId = "Alston_Test";
memcpy(&ShmSysConfigAndInfo->SysConfig.SystemId, systemId, strlen(systemId));
}
void RunSelfProc()
{
printf("self test status = %x\n", ShmSysConfigAndInfo->SysInfo.SelfTestSeq);
}
void ShowFwVer(void)
{
printf("\r\nPower Cabinet, Model Name: %s, SN: %s", ShmSysConfigAndInfo->SysConfig.ModelName, ShmSysConfigAndInfo->SysConfig.SerialNumber);
printf("\r\n Csu Bootload: %s", ShmSysConfigAndInfo->SysInfo.CsuBootLoadFwRev);
//printf("\r\n Csu Kernel: %s", ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev);
printf("\r\n Csu Kernel: ");
for(int i = 0; i < strlen((char *)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev); i++)
{
if(ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev[i] != '\r' && ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev[i] != '\n')
{
printf("%c", ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev[i]);
}
}
printf("\r\n Csu Root Fs: %s [%s]", ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, ShmChargerInfo->SysMisc.SubVersion);
printf("\r\n Csu Primary: %s", ShmSysConfigAndInfo->SysInfo.CsuPrimFwRev);
printf("\r\n Fan Module: %s", ShmSysConfigAndInfo->SysInfo.FanModuleFwRev);
printf("\r\n Relay1 Module: %s", ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev);
printf("\r\n Relay2 Module: %s", ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev);
for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity; i++)
{
printf("\r\n\r\nDispenser[%d] Status: %d", i, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus);
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
{
printf(", Model Name: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ModelName);
printf("\r\n Csu Bootload: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuBootLoadFwRev);
//printf("\r\n Csu Kernel: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuKernelFwRev);
printf("\r\n Csu Kernel: ");
for(int j = 0; j < strlen((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuKernelFwRev); j++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuKernelFwRev[j] != '\r' &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuKernelFwRev[j] != '\n')
{
printf("%c", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuKernelFwRev[j]);
}
}
printf("\r\n Csu Root Fs: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuRootFsFwRev);
printf("\r\n Csu Primary: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].CsuPrimFwRev);
printf("\r\n Fan Module: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].FanModuleFwRev);
printf("\r\n Relay Module: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].RelayModuleFwRev);
printf("\r\n Connector 1: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Connector1FwRev);
printf("\r\n Connector 2: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Connector2FwRev);
printf("\r\n Led Module: %s", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LedModuleFwRev);
}
}
printf("\r\n\r\n");
}
void GetFwVerProc(char *v1)
{
if (strcmp(v1, "407") == 0)
{
printf("407 FW Version = %s \n", ShmPrimaryMcuData->version);
}
else if (strcmp(v1, "0") == 0 || strcmp(v1, "1") == 0 || strcmp(v1, "2") == 0 || strcmp(v1, "3") == 0)
{
int _index = atoi(v1);
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[_index].Enable)
{
int dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[_index].ParentDispensetIndex;
int ParentIndex = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[_index].GeneralChargingData.Index;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_Timeout)
{
if(ParentIndex == 0)
{
printf("Gun %d FW Version = %s \n", _index, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Connector1FwRev);
}
else
{
printf("Gun %d FW Version = %s \n", _index, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Connector1FwRev);
}
}
}
else
{
printf("Gun %d is disable\r\n", _index);
}
}
else if (strcmp(v1, "rb") == 0)
{
printf("RB1 Version = %s \n", ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev);
printf("RB2 Version = %s \n", ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev);
}
else if (strcmp(v1, "fan") == 0)
{
printf("FAN Version = %s \n", ShmSysConfigAndInfo->SysInfo.FanModuleFwRev);
}
else if (strcmp(v1, "dc") == 0)
{
printf("DC Main Version = %s \n", ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
}
else if (strcmp(v1, "led") == 0)
{
printf("LED Version = %s \n", ShmSysConfigAndInfo->SysInfo.LedModuleFwRev);
}
}
void CreateOneError(char *v1)
{
int value = atoi(v1);
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail = value;
ShmSysConfigAndInfo->SysConfig.BillingData.isBilling = value;
}
void GetAuthorizeFlag(char *v1)
{
if (strcmp(v1, "-1") == 0|| strcmp(v1, "") == 0)
printf("AuthorizeFlag = %d \n", ShmSysConfigAndInfo->SysInfo.AuthorizeFlag);
else
ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = atoi(v1);
}
void GetOrClearId(char *v1)
{
int _index = atoi(v1);
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf("FindChargingInfoData error\n");
return;
}
printf("Card Number = %s \n", _chargingData[_index]->StartUserId);
}
void FwUpdateFlagProc(char *inputCmd, unsigned int opt)
{
ShmSysConfigAndInfo->SysInfo.FirmwareUpdate = 0x01;
}
void CheckAcStatus(char *v1)
{
if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0)
{
printf(" AC Contactor Ctrl: %d\r\n", ShmChargerInfo->Control.RelayCtrl.bits.AcContactor);
printf(" AC Off By Psu : %d\r\n", ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu);
printf(" AC Off ByEmergency: %d\r\n", ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency);
printf("AC Contactor Status: %d\r\n", ShmSysConfigAndInfo->SysInfo.AcContactorStatus);
}
else
{
if(system("pidof -s main > /dev/null") != 0)
{
if(strcmp(v1, "0") == 0)
{
ShmChargerInfo->Control.RelayCtrl.bits.AcContactor = false;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = false;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = false;
printf("Set AC Contactor Off\r\n");
}
else
{
ShmChargerInfo->Control.RelayCtrl.bits.AcContactor = true;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = false;
ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = false;
printf("Set AC Contactor On\r\n");
}
}
else
{
printf("main task is running\r\n");
}
}
}
void SetCableChkStatus(char *v1, char *v2)
{
int _index = atoi(v1);
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf ("FindChargingInfoData error\n");
return;
}
_chargingData[_index]->GroundFaultStatus = atoi(v2);
}
void SetPowerValue(char *v1, char *v2)
{
int _index = atoi(v1);
float _Current = atof(v2);
// 盲沖的時候才允許使用~
if (_chargingData[_index]->Type != 9)
return;
if (!FindChargingInfoData(_index, &_chargingData[0]))
{
printf ("FindChargingInfoData error\n");
return;
}
_chargingData[_index]->EvBatterytargetCurrent = _Current;
}
void GetSystemInfo(void)
{
printf ("Power Cabinet\r\n");
printf (" -System ID: [%s]\r\n", (char *)&ShmSysConfigAndInfo->SysConfig.SystemId);
printf (" -ModelName: [%s], SerialNumber: [%s]\r\n",
(char *)&ShmSysConfigAndInfo->SysConfig.ModelName,
(char *)&ShmSysConfigAndInfo->SysConfig.SerialNumber);
printf (" -CSURootFs: %s [%s]\r\n", ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, ShmChargerInfo->SysMisc.SubVersion);
}
bool SetModelName(char *modelName);
void ModelNameCmd(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
printf("\r\n");
if(totalCnt == 0)
{
GetSystemInfo();
printf("\r\n");
return;
}
if(totalCnt != maxPara || strcmp(&MultiSubCmd[0][0], "set") != EQUAL)
{
printf("Input cmd fail ------ model [set] [model name]\r\n\r\n");
return;
}
if(SetModelName(&MultiSubCmd[0][0]))
{
printf("\r\n");
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashImmediately = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashAndReset = true;
}
}
bool SetSerialNumber(char *serialNumber);
void SerialNumberCmd(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
printf("\r\n");
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ model [set] [serial number]\r\n\r\n");
return;
}
if(SetSerialNumber(&MultiSubCmd[1][0]))
{
printf("\r\n");
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashImmediately = true;
}
}
void SetFanSpeed(char *v1)
{
int speed = atoi(v1);
ShmFanModuleData->TestFanSpeed = speed;
}
void GetFanSpeed()
{
printf("Target Speed = %d \n", ShmFanModuleData->TestFanSpeed);
printf("ShmFanModuleData->PresentFan1Speed = %d \n", ShmFanModuleData->PresentFan1Speed);
printf("ShmFanModuleData->PresentFan2Speed = %d \n", ShmFanModuleData->PresentFan2Speed);
printf("ShmFanModuleData->PresentFan3Speed = %d \n", ShmFanModuleData->PresentFan3Speed);
printf("ShmFanModuleData->PresentFan4Speed = %d \n", ShmFanModuleData->PresentFan4Speed);
}
void SetDebugMode(char *v1)
{
int mode = atoi(v1);
ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag = mode;
}
void SetGFDMode(char *v1)
{
int mode = atoi(v1);
ShmSysConfigAndInfo->SysConfig.AlwaysGfdFlag = mode;
}
// PSU 0 PSU 1 PSU 2 ...
// Gun Temp Chiller DD/PFC/Amb DD/PFC/Amb DD/PFC/Amb DD/PFC/Amb
// 1 XXX XXX XXX/XXX/XXX XXX/XXX/XXX XXX/XXX/XXX XXX/XXX/XXX
void GetTemperature(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
char strGunTemp[16], strChillerTemp[16];
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
printf("\r\n");
printf(" PSU 0 PSU 1 PSU 2 .....\r\n");
printf(" Gun Temp Chiller DD/PFC/Amb DD/PFC/Amb DD/PFC/Amb DD/PFC/Amb\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(CONNECTOR_QUANTITY, 1);
}
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
sprintf(strGunTemp, "N/A");
sprintf(strChillerTemp, "N/A");
if(_chargingData[i]->ConnectorTemp != 0 && _chargingData[i]->ConnectorTemp != 0xFF)
{
int _connectorTemp = (int)_chargingData[i]->ConnectorTemp - 60;
sprintf(strGunTemp, "%3d", _connectorTemp);
}
if(_chargingData[i]->ChillerTemp != 0 && _chargingData[i]->ChillerTemp != 0xFF)
{
int _chillerTemp = (int)_chargingData[i]->ChillerTemp - 60;
sprintf(strChillerTemp, "%3d", _chillerTemp);
}
printf(" %d %s %s ", i + 1, strGunTemp, strChillerTemp);
for(int j = 0; j < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; j++)
{
int ExletTemp = (int)ShmPsuData->PsuGroup[i].PsuModule[j].ExletTemp - 60;
int InletTemp = (int)ShmPsuData->PsuGroup[i].PsuModule[j].InletTemp - 60;
int CriticalTemp1 = (int)ShmPsuData->PsuGroup[i].PsuModule[j].CriticalTemp1 - 60;
printf(" %3d/%3d/%3d", ExletTemp, InletTemp, CriticalTemp1);
}
printf("\r\n");
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void GetInputVol(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
printf("\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(1, 1);
}
printf("L1N_L12 = %4.1f V, L2N_L23 = %4.1f V, L3N_L31 = %4.1f V, DC Input: %4.1f V\r\n",
ShmSysConfigAndInfo->SysInfo.InputVoltageR,
ShmSysConfigAndInfo->SysInfo.InputVoltageS,
ShmSysConfigAndInfo->SysInfo.InputVoltageT,
ShmSysConfigAndInfo->SysInfo.InputVoltageDc);
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void GetConnectorCapInfo(char *v1)
{
int _GunIndex = atoi(v1);
if (!FindChargingInfoData(_GunIndex, &_chargingData[0]))
{
printf ("FindChargingInfoData error\n");
return;
}
printf ("Charger Max Current = %d, Max Power = %d \n",
ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent * 10,
ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 10);
printf ("Index = %d, MaxPow = %f, MaxVol = %f, MaxCur = %f\n",
_GunIndex,
_chargingData[_GunIndex]->RealMaxPower,
_chargingData[_GunIndex]->RealMaxVoltage,
_chargingData[_GunIndex]->RealMaxCurrent);
}
void SetWiringInfo(char *v1, char *v2)
{
int dispenser = atoi(v1);
int connector = atoi(v2);
if(dispenser > 0 && dispenser <= GENERAL_GUN_QUANTITY && connector >= 0 && connector <= GENERAL_GUN_QUANTITY)
{
if(ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence == (dispenser - 1))
{
printf("\r\n");
printf("Set Dispenser %d, Connector Quantity = %d\r\n", dispenser, connector);
ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[dispenser - 1] = connector;
ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence = dispenser;
ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity += connector;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;
}
else if(ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence > (dispenser - 1))
{
printf("\r\n");
printf("Set Dispenser %d, Connector Quantity = %d\r\n", dispenser, connector);
ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[dispenser - 1] = connector;
int quantity = 0;
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
{
quantity += ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i];
}
ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity = quantity;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;
}
}
}
void ShowWiringInfo(void)
{
printf("\r\n");
printf("********** Wiring Info **********\r\n");
printf("Dispenser = %d, Connector = %d\r\n",
ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence,
ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity);
if(ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence > 0)
{
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
{
printf("Dispenser[%d] <=> %d\r\n", i, ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i]);
}
}
printf("\r\n");
}
void CleanWiringInfo(void)
{
printf("\r\n");
printf("******* Clean Wiring Info *******\r\n");
memset((char *)&ShmSysConfigAndInfo->SysConfig.WiringInfo, 0x00, sizeof(WiringInfoData));
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashImmediately = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashAndReset = true;
printf("\r\n");
}
void SetSystemSoftRest(void)
{
printf("\r\n");
printf("********* Set Soft Reset ********\r\n\r\n");
ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
}
void SetSystemHardReboot(void)
{
printf("\r\n");
printf("******** Set Hard Reboot ********\r\n\r\n");
ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset = true;
}
void SetGroupRole(byte group, byte role)
{
if(group < GENERAL_GUN_QUANTITY)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != role)
{
//printf("\r\nSet Group %d Role = %d", group, role);
}
ShmChargerInfo->PsuGrouping.GroupCollection[group].Role = role;
}
}
void SetGroupToIdle(byte group)
{
if(group < GENERAL_GUN_QUANTITY)
{
SetGroupRole(group, _GROLE_IDLE);
ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Quantity = 0;
memset(ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Member, 0x00, ARRAY_SIZE(ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Member));
ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup = 0;
//printf("\r\n Reset Group %02X To Idle", group);
}
}
void SetGroupToMaster(byte group)
{
if(group < GENERAL_GUN_QUANTITY)
{
SetGroupRole(group, _GROLE_MASTER);
ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup = group + 1;
//printf("\r\n Set Group %02X As Master", group);
}
}
void SetGroupToSlave(byte group, byte target)
{
if(group < GENERAL_GUN_QUANTITY && target < GENERAL_GUN_QUANTITY)
{
SetGroupRole(group, _GROLE_SLAVE);
ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup = target + 1;
//printf("\r\n Set Group %02X As Slave", group);
}
}
// group: group index, target: target index
// add group to target's member
void AddGroupCollection(byte group, byte target)
{
int ParallelConfig = 0;
if(group < GENERAL_GUN_QUANTITY && target < GENERAL_GUN_QUANTITY)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[target].Role != _GROLE_MASTER)
{
return;
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_IDLE &&
ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_WAIT_IDLE &&
ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_PRECHARGE_READY)
{
return;
}
SetGroupToSlave(group, target);
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity++] = group;
ParallelConfig = ShmChargerInfo->PsuGrouping.GroupCollection[target].ParallelConfig[group];
if(ParallelConfig != 0)
{
ShmPsuGrouping->ParallelRelayConfig.CtrlValue |= (1 << (ParallelConfig - 1));
}
//printf("\r\n Add Group %02X To Gun %d (Quantity %d), Set Parallel Relay %d On", group, target + 1, ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity, ParallelConfig);
}
}
// group: group index, target: target index
// remove group out of target's member
void RemoveGroupCollection(byte group, byte target)
{
int location = 0, slave = 0;
bool find = false;
int ParallelConfig = 0;
if(group < GENERAL_GUN_QUANTITY && target < GENERAL_GUN_QUANTITY)
{
for(int i = 0; i < ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity; i++)
{
if(group == ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[i])
{
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[i] = 0;
location = i;
find = true;
break;
}
}
if(find)
{
for(int i = location + 1; i < ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity; i++)
{
slave = ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[i];
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[i] = 0;
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[i - 1] = slave;
}
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity--;
SetGroupToIdle(group);
ParallelConfig = ShmChargerInfo->PsuGrouping.GroupCollection[target].ParallelConfig[group];
if(ParallelConfig != 0)
{
ShmPsuGrouping->ParallelRelayConfig.CtrlValue &= ~(1 << (ParallelConfig - 1));
}
//printf("\r\n Remove Group %02X From Gun %d (Quantity %d), Clean Parallel Relay %d Off", group, target + 1, ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity, ParallelConfig);
}
}
}
// Gun(Status)(Ro)(Q) Master Member OutputVol OutputCur AvaiPower AvaiCur StabCur K1K2 ParaRelay
// 1 (00) 00 3 00 [00] [00] [00] 0000 V 0000 A 0000 kW 0000 A 0000 A 00 XX
void ShowGroupingInfo(void)
{
byte target = 0;
printf("\r\n Gun(Status)(Ro)(Q) Master Member OutputVol OutputCur AvaiPower AvaiCur StabCur K1K2 ParaRelay");
for(int i = 0; i < 4; i++)
{
target = ShmPsuGrouping->Layout[i];
printf("\r\n %d (%2d) %2d %d %02X ",
target + 1, _chargingData[target]->SystemStatus, ShmChargerInfo->PsuGrouping.GroupCollection[target].Role,
ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity, ShmChargerInfo->PsuGrouping.GroupCollection[target].TargetGroup);
for(int j = 0; j < 3; j++)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[target].Role == 1 && j < ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity)
{
printf("[%02X] ", ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Member[j]);
}
else
{
printf(" ");
}
}
printf(" %4d V %4d A %4d kW %4d A %4d A ",
(int)_chargingData[target]->PresentChargingVoltage, (int)_chargingData[target]->PresentChargingCurrent,
(int)(_chargingData[target]->AvailableChargingPower / 10), (int)(_chargingData[target]->AvailableChargingCurrent / 10),
(int)(_chargingData[target]->DeratingChargingCurrent / 10));
printf("%02X %02X",ShmPsuGrouping->OutputRelayConfig[target].CtrlValue, ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
}
printf("\r\n\r\nSystem Capability Current = %4d.%01d A, Power = %3d.%01d kW",
(ShmPsuData->SystemAvailableCurrent / 10), (ShmPsuData->SystemAvailableCurrent % 10),
(ShmPsuData->SystemAvailablePower / 10), (ShmPsuData->SystemAvailablePower % 10));
printf("\r\n\r\n");
}
void PsuGroupSwitchToIdle(byte group)
{
int master = 0, quantity = 0, location = 0, total = 0;
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_SLAVE)
{
return;
}
master = ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup - 1;
quantity = ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Quantity;
//printf("\r\n Search Group %02X From Gun %d", group, master + 1);
for(int i = 0; i < quantity; i++)
{
if(total == 0)
{
if(group == ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[i])
{
location = i;
total++;
//printf("\r\n Find Group %02X At Member Index = %d", group, location);
}
}
else
{
// find other group in the same direction
if(ShmPsuGrouping->Location[ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[location]] < ShmPsuGrouping->Location[master])
{
if(ShmPsuGrouping->Location[ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[i]] < ShmPsuGrouping->Location[master])
{
total++;
//printf("\r\n Find Other Group %02X In The Same Direction", ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[i]);
}
}
if(ShmPsuGrouping->Location[ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[location]] > ShmPsuGrouping->Location[master])
{
if(ShmPsuGrouping->Location[ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[i]] > ShmPsuGrouping->Location[master])
{
total++;
//printf("\r\n Find Other Group %02X In The Same Direction", ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member[i]);
}
}
}
}
if(total > 0)
{
unsigned char collection[GENERAL_GUN_QUANTITY];
//printf("\r\n There are %d Group Need To Switch Idle:", total);
memcpy(collection, ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member, ARRAY_SIZE(ShmChargerInfo->PsuGrouping.GroupCollection[master].Partner.Member));
for(int i = 0; i < total; i++)
{
//printf(" %02X", collection[i + location]);
}
for(int i = 0; i < total; i++)
{
RemoveGroupCollection(collection[i + location], master);
}
}
}
void FindPsuGroupPartner(byte master, byte quantity, PsuGroupPartner *tPartner)
{
int slave = 0, location = 0;
PsuGroupPartner partner;
memset(&partner, 0x00, sizeof(PsuGroupPartner));
// search from left
location = ShmChargerInfo->PsuGrouping.GroupCollection[master].Location - 1;
for(int i = location; i >= 0; i--)
{
if(partner.Quantity >= quantity)
{
break;
}
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
//printf("\r\n Find Group %02X From Left", slave);
partner.Member[partner.Quantity++] = slave;
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && master == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
// search from right
location = ShmChargerInfo->PsuGrouping.GroupCollection[master].Location + 1;
for(int i = location; i < 4; i++)
{
if(partner.Quantity >= quantity)
{
break;
}
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
//printf("\r\n Find Group %02X From Right", slave);
partner.Member[partner.Quantity++] = slave;
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && master == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
memcpy(tPartner, &partner, sizeof(PsuGroupPartner));
}
int GetPsuGroupAvailable(byte group)
{
//int slave = 0, location = 0, available = 0;
PsuGroupPartner partner;
FindPsuGroupPartner(group, MAX_GROUP_QUANTITY, &partner);
//printf("\r\n Gun %d Available Quantity = %d", group + 1, partner.Quantity);
return partner.Quantity;
#if 0
// search from left
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location - 1;
for(int i = location; i >= 0; i--)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
available++;
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && group == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
// search from right
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location + 1;
for(int i = location; i < 4; i++)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
available++;
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && group == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
return available;
#endif
}
void PsuGroupShareCheck(byte group)
{
int slave = 0, target = 0, location = 0, share = 0, total = 0;
total = GetPsuGroupAvailable(group) + 1;
//printf("\r\n Gun %d Total Group = %d", group + 1, total);
// search from left
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location - 1;
for(int i = location; i >= 0; i--)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE)
{
target = ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1;
if((ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity + 1) > total)
{
share = (ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity + 1 - total) / 2;
}
//printf("\r\n Find Group %02X Have %d Resource Can Shared %d From Left", target, ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity, share);
break;
}
else
{
break;
}
}
if(share == 0)
{
// search from right
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location + 1;
for(int i = location; i < 4; i++)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE)
{
target = ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1;
if((ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity + 1) > total)
{
share = (ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity + 1 - total) / 2;
}
//printf("\r\n Find Group %02X Have %d Resource Can Shared %d From Left", target, ShmChargerInfo->PsuGrouping.GroupCollection[target].Partner.Quantity, share);
break;
}
else
{
break;
}
}
}
if(share > 0)
{
//printf("\r\n Grab %02X", slave);
PsuGroupSwitchToIdle(slave);
}
else
{
//printf("\r\n No Need To Grab");
}
}
void SimplePsuGroupStartCharging(byte group)
{
//int slave = 0, location = 0;
int available = 0;
PsuGroupPartner partner;
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role == _GROLE_SLAVE)
{
return;
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_IDLE && ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_MASTER)
{
return;
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role == _GROLE_IDLE)
{
SetGroupToMaster(group);
PsuGroupShareCheck(group);
}
else
{
available = GetPsuGroupAvailable(group);
//printf("\r\nGun %d is already master, there are %d available group", group + 1, available);
if(available == 0)
{
return;
}
}
FindPsuGroupPartner(group, MAX_GROUP_QUANTITY, &partner);
for(int i = 0; i < partner.Quantity; i++)
{
AddGroupCollection(partner.Member[i], group);
}
ShmPsuGrouping->OutputRelayConfig[group].bits.Output_N = true;
ShmPsuGrouping->OutputRelayConfig[group].bits.Output_P = true;
#if 0
// search from left
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location - 1;
for(int i = location; i >= 0; i--)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
//printf("\r\n Find %02X From Left", slave);
AddGroupCollection(slave, group);
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && group == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
// search from right
location = ShmChargerInfo->PsuGrouping.GroupCollection[group].Location + 1;
for(int i = location; i < 4; i++)
{
slave = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_IDLE)
{
//printf("\r\n Find %02X From Right", slave);
AddGroupCollection(slave, group);
}
else
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[slave].Role == _GROLE_SLAVE && group == (ShmChargerInfo->PsuGrouping.GroupCollection[slave].TargetGroup - 1))
{
continue;
}
break;
}
}
#endif
}
void PsuGroupStopCharging(byte group)
{
int total = 0;
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role != _GROLE_MASTER)
{
return;
}
total = ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Quantity;
if(total > 0)
{
unsigned char collection[GENERAL_GUN_QUANTITY];
//printf("\r\n There are %d Group Need To Stop:", ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Quantity);
memcpy(collection, ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Member, ARRAY_SIZE(ShmChargerInfo->PsuGrouping.GroupCollection[group].Partner.Member));
for(int i = 0; i < total; i++)
{
//printf(" %02X", collection[i]);
}
for(int i = 0; i < total; i++)
{
RemoveGroupCollection(collection[i], group);
}
}
SetGroupToIdle(group);
ShmPsuGrouping->OutputRelayConfig[group].bits.Output_N = false;
ShmPsuGrouping->OutputRelayConfig[group].bits.Output_P = false;
}
void RunSimplePsuGrouping(char *v1, char *v2)
{
int group = 0, charging = 0;
group = atoi(v1);
charging = atoi(v2);
group -= 1;
if(group >= 0 && group < 4)
{
if(charging > 0)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role == _GROLE_SLAVE)
{
//printf("\r\nGroup %02X Is In Use, Need To Stop Charging", group);
PsuGroupSwitchToIdle(group);
}
SimplePsuGroupStartCharging(group);
}
if(charging == 0)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role == _GROLE_MASTER)
{
PsuGroupStopCharging(group);
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[group].Role == _GROLE_SLAVE)
{
PsuGroupSwitchToIdle(group);
}
}
ShowGroupingInfo();
}
}
void ConnectionInfo(void)
{
int address = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
address = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress;
printf(" Connection[%d] Status: %d, DispenserIndex: %d, IP: %d.%d.%d.%d\r\n", i,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex,
((address >> 0) & 0xFF), ((address >> 8) & 0xFF), ((address >> 16) & 0xFF), ((address >> 24) & 0xFF));
}
}
void GunEnableInfo(int gunIndex)
{
printf(" Gun %d Index: %2X, Status = %2d , %7s, MeterValue: %10.4f, Local: : %10.4f, Gun: : %10.4f\r\n", gunIndex + 1, _chargingData[gunIndex]->Index, _chargingData[gunIndex]->SystemStatus,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Enable ? "Enable" : "Disable",
_chargingData[gunIndex]->PowerConsumption,
ShmChargerInfo->MeterValue[gunIndex].LocalConsumption,
ShmChargerInfo->MeterValue[gunIndex].GunConsumption);
}
int FindDispenserIpAddress(int dispenser)
{
int address = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_DispenserMatched &&
dispenser == ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex)
{
address = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress;
}
}
return address;
}
int DispenserInfo(int dispenser)
{
int ipAddress = 0;
int gunCnt = 0;
printf(" Dispenser %d Status: %d", dispenser + 1, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus);
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_Timeout)
{
ipAddress = FindDispenserIpAddress(dispenser);
gunCnt = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].ConnectorQuantity;
printf(", ModelName: %s, IP: %d.%d.%d.%d\r\n", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].ModelName,
((ipAddress >> 0) & 0xFF), ((ipAddress >> 8) & 0xFF), ((ipAddress >> 16) & 0xFF), ((ipAddress >> 24) & 0xFF));
for(int i = 0; i < gunCnt; i++)
{
unsigned char gun = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].ConnectorID[i];
printf(" - Connector[%d] Gun %d, %s\r\n", i, gun, _chargingData[gun - 1]->ConnectorPlugIn ? "Plugged" : "Unplugged");
}
}
else
{
printf(", No Information\r\n");
}
return gunCnt;
}
void ShowCabinetInfo(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int time = 0;
int dispenserLine = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
printf("\r\n");
printf("Power Cabinet & Dispenser Info\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(1, 2);
ConsoleReflash(CONNECTOR_QUANTITY, 1);
dispenserLine = dispenserLine > 0 ? (dispenserLine + 1) : dispenserLine;
ConsoleReflash(1, dispenserLine);
dispenserLine = 0;
}
printf(" Dispenser: %d / %d, Connector: %d / %d\r\n",
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity);
printf("\r\n");
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
GunEnableInfo(i);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity > 0)
{
printf("\r\n");
for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity; i++)
{
dispenserLine += DispenserInfo(i) + 1;
}
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void SetTestControl(char *v1, char *v2)
{
int testItem = 0;
int testItemLen = 5;
int enable = 0;
char strTest[32][32] = {"tbl", "tfsb", "chgsm", "fcre", "ubill"};
char strItem[32][32] = {"Balance", "Fast Standby Time", "Charging Simulation", "FCharging Release Extend", "Undisposed Bill"};
enable = atoi(v2);
if(enable < 0)
{
return;
}
for(int i = 0; i < testItemLen; i++)
{
if(strcmp((char *)&strTest[i][0], v1) == 0)
{
testItem = i + 1;
break;
}
}
if(testItem != 0)
{
if(enable)
{
ShmChargerInfo->Control.TestCtrl.CtrlValue |= (1 << (testItem - 1));
}
else
{
ShmChargerInfo->Control.TestCtrl.CtrlValue &= ~(1 << (testItem - 1));
}
printf("%s %s Test Item, Test Control Value = %08X\n",
enable ? "Enable" : "Disable", strItem[testItem - 1], ShmChargerInfo->Control.TestCtrl.CtrlValue);
}
else
{
printf("Test Item %s Not Found\n", v1);
for(int i = 0; i < testItemLen; i++)
{
printf(" [%s] -> %s Test\n", strTest[i], strItem[i]);
}
}
printf("\r\n");
}
// Group Gun Available Psu Group Control
// Gun Role Master K1K2 GTVol GTCur StableCur Loading Loading DiffP_Ava DiffP_Cap DiffP_Lim Partner IdleCtrl Master Stop Derating Extend Slave
// 1 00 00 0 0000 V 000.0 A 0000 A XXX.XX XXX.XX XXX kw XXX kW XXX kW XX 0xXXXX 0xXXXX 0xXXXX 0xXXXX 0xXXXX 0xXXXX
// Group Gun DiffP Available Psu Group Control
// Gun Role Master K1K2 GTVol GTCur StableCur Loading Loading DiffP_Ava DiffP_Cap DiffP_Lim ConfigLim Partner IdleCtrl Master Stop Derating Extend Slave
// 1 00 00 0 0000 V 000.0 A 0000 A XXX.XX XXX.XX XXX kw XXX kW XXX kW XXX kW XX 0xXXXX 0xXXXX 0xXXXX 0xXXXX 0xXXXX 0xXXXX
void ShowGroupingDemand(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
bool outputFile = false;
bool allRoleIdle = false;
bool fullInfo = false;
int totalCnt = 0;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt == 1)
{
if(strcmp(&MultiSubCmd[0][0], "full") == 0)
{
fullInfo = true;
}
}
int time = 0;
struct timespec _Loop_time;
char lineString[512];
char tempString[128];
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
if((opt & OPTION_OUTPUT_FILE) > 0)
{
outputFile = true;
}
byte target = 0;
unsigned char k1k2 = 0;
//printf(" Group Gun Available Psu Group Control\r\n");
//printf(" Gun Role Master K1K2 GTVol GTCur StableCur Loading Loading DiffP_Ava DiffP_Cap DiffP_Lim Partner IdleCtrl Master Stop Derating Extend Slave\r\n");
memset(lineString, 0x00, sizeof(lineString));
sprintf(lineString, " Group Gun DiffP");
if(fullInfo)
{
sprintf(tempString, " Available Psu Group Control");
strcat(lineString, tempString);
}
if(!outputFile)
{
printf("%s\r\n", lineString);
}
else
{
ReadCmd_INFO("%s", lineString);
}
sprintf(lineString, " Gun Role Master K1K2 GTVol GTCur StableCur Loading Loading DiffP_Ava DiffP_Cap DiffP_Lim ConfigLim");
if(fullInfo)
{
sprintf(tempString, " Partner IdleCtrl Master Stop Derating Extend Slave");
strcat(lineString, tempString);
}
if(!outputFile)
{
printf("%s\r\n", lineString);
}
else
{
ReadCmd_INFO("%s", lineString);
}
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(MAX_GROUP_QUANTITY, 1);
}
for(int i = 0; i < MAX_GROUP_QUANTITY; i++)
{
target = ShmPsuGrouping->Layout[i];
if(ShmChargerInfo->PsuGrouping.GroupCollection[target].TargetGroup != 0)
{
k1k2 = _chargingData[ShmChargerInfo->PsuGrouping.GroupCollection[target].TargetGroup - 1]->RelayK1K2Status;
}
else
{
k1k2 = _chargingData[target]->RelayK1K2Status;
}
memset(lineString, 0x00, sizeof(lineString));
sprintf(tempString, " %d %2d %02X %d %4d V %3d.%d A %4d A %3d.%02d",
target + 1, ShmChargerInfo->PsuGrouping.GroupCollection[target].Role, ShmChargerInfo->PsuGrouping.GroupCollection[target].TargetGroup, k1k2,
(ShmPsuGrouping->GroupOutput[target].GTargetVoltage / 10),
(ShmPsuGrouping->GroupOutput[target].GTargetCurrent / 10),
(ShmPsuGrouping->GroupOutput[target].GTargetCurrent % 10),
(int)(_chargingData[target]->AvailableChargingCurrent / 10),
(ShmPsuGrouping->GroupOutput[target].OutputLoading / 100),
(ShmPsuGrouping->GroupOutput[target].OutputLoading % 100));
strcat(lineString, tempString);
//if(ShmChargerInfo->PsuGrouping.GroupCollection[target].TargetGroup == target + 1)
//{
sprintf(tempString, " %3d.%02d", (ShmChargerInfo->PsuGrouping.GroupCollection[target].GunLoading / 100), (ShmChargerInfo->PsuGrouping.GroupCollection[target].GunLoading % 100));
strcat(lineString, tempString);
sprintf(tempString, " %3d kW %3d kW %3d kW %3d kW",
(int)ShmPsuGrouping->GroupCollection[target].DiffPower_Available,
(int)ShmPsuGrouping->GroupCollection[target].DiffPower_Capability,
(int)ShmPsuGrouping->GroupCollection[target].DiffPower_PhysicalLimit,
(int)ShmPsuGrouping->GroupCollection[target].DiffPower_ConfigLimit);
strcat(lineString, tempString);
if(fullInfo)
{
int partner_quantity = GetPsuGroupAvailable(target);
sprintf(tempString, " %2d 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X 0x%04X",
partner_quantity,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.IdleCtrlValue,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.MasterCtrlValue,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.StopChargingCtrlValue,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.DeratingCtrlValue,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue,
ShmPsuGrouping->GroupCollection[target].GroupCtrl.RoleCtrl.SlaveCtrlValue);
strcat(lineString, tempString);
}
//}
if(!outputFile)
{
printf("%s\r\n", lineString);
}
else
{
if(!allRoleIdle)
{
ReadCmd_INFO("%s", lineString);
}
}
}
allRoleIdle = true;
for(int i = 0; i < MAX_GROUP_QUANTITY; i++)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role != _GROLE_IDLE)
{
allRoleIdle = false;
}
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0 && !outputFile)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
// v1: gun
// v2: voltage
// v3: current
void SetGunStartCharging(char *inputCmd, unsigned int opt, unsigned char isWeb)
{
int totalCnt = 0, maxPara = 0;
maxPara = 3;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ gunchg [gun 1-4] [voltage 0-1000] [current 0-100]\r\n\r\n");
return;
}
int gun = 0;
float _voltage = 0, _current = 0;
gun = atoi(&MultiSubCmd[0][0]);
_voltage = atof(&MultiSubCmd[1][0]);
_current = atof(&MultiSubCmd[2][0]);
if(gun <= 0 || gun > GENERAL_GUN_QUANTITY || _voltage < 0 || _voltage > 1000 || _current < 0 || _current > 1200)
{
printf("\r\n");
printf("Gun Start Charging Input parameter %d, %.1f, %.1f out of range\r\n", gun, _voltage, _current);
printf("\r\n");
return;
}
bool wait = true;
int time = 0;
struct timespec _Wait_time;
unsigned char PreviousSystemStatus = 0xFF;
unsigned short _targetVoltage = 0, _targetCurrent = 0;
printf("\r\n");
while(wait)
{
switch(_chargingData[gun - 1]->SystemStatus)
{
case S_IDLE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_IDLE\r\n", gun);
printf("Set Gun %d Start Charging > Voltage: %4d, Current: %d\r\n", gun, (int)_voltage, (int)_current);
ShmChargerInfo->Control.FCharging[gun - 1].FCtrl.bits.EnableForceCharging = true;
ShmChargerInfo->Control.FCharging[gun - 1].FCtrl.bits.StartForceCharging = true;
ShmChargerInfo->Control.FCharging[gun - 1].FTargetVoltage = _voltage * 10;
ShmChargerInfo->Control.FCharging[gun - 1].FTargetCurrent = _current * 10;
if(isWeb)
{
ShmChargerInfo->Control.FCharging[gun - 1].FCtrl.bits.WebApiTrigger = true;
}
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_REASSIGN_CHECK:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_REASSIGN_CHECK, Wait For Request Charging\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_REASSIGN:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_REASSIGN, Wait For Grouping\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_PREPARNING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARNING\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_PREPARING_FOR_EV:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARING_FOR_EV\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_PREPARING_FOR_EVSE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARING_FOR_EVSE, Wait For EVSE\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
if(_targetVoltage != (int)_chargingData[gun - 1]->EvBatterytargetVoltage ||
_targetCurrent != (int)_chargingData[gun - 1]->EvBatterytargetCurrent)
{
_targetVoltage = (int)_chargingData[gun - 1]->EvBatterytargetVoltage;
_targetCurrent = (int)_chargingData[gun - 1]->EvBatterytargetCurrent;
printf("Gun %d Set Voltage: %4d, Current: %d\r\n", gun, _targetVoltage, _targetCurrent);
}
break;
case S_CHARGING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_CHARGING\r\n", gun);
if(PreviousSystemStatus == 0xFF)
{
_targetVoltage = (int)_chargingData[gun - 1]->EvBatterytargetVoltage;
_targetCurrent = (int)_chargingData[gun - 1]->EvBatterytargetCurrent;
printf("Gun %d Voltage: %4d, Current: %d\r\n", gun, _targetVoltage, _targetCurrent);
if(ShmChargerInfo->Control.FCharging[gun - 1].FCtrl.bits.EnableForceCharging)
{
printf("Set Gun %d Force Charging > Voltage: %4d, Current: %d\r\n", gun, (int)_voltage, (int)_current);
ShmChargerInfo->Control.FCharging[gun - 1].FTargetVoltage = _voltage * 10;
ShmChargerInfo->Control.FCharging[gun - 1].FTargetCurrent = _current * 10;
}
}
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GetClockTime(&_Wait_time);
}
if(_targetVoltage != (int)_chargingData[gun - 1]->EvBatterytargetVoltage ||
_targetCurrent != (int)_chargingData[gun - 1]->EvBatterytargetCurrent)
{
_targetVoltage = (int)_chargingData[gun - 1]->EvBatterytargetVoltage;
_targetCurrent = (int)_chargingData[gun - 1]->EvBatterytargetCurrent;
printf("Gun %d Set Voltage: %4d, Current: %d\r\n", gun, _targetVoltage, _targetCurrent);
}
time = GetTimeoutValue(_Wait_time) / uSEC_VAL;
if(time >= 1)
{
wait = false;
printf("Done\r\n");
}
break;
case S_TERMINATING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_TERMINATING\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
wait = false;
break;
case S_COMPLETE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_COMPLETE\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
wait = false;
break;
case S_ALARM:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_ALARM\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
wait = false;
break;
default:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun SystemStatus %d Unknown(%d)\r\n", gun, _chargingData[gun - 1]->SystemStatus);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
printf("Gun %d SystemStatus(%d) Is Not Available\r\n", gun, _chargingData[gun - 1]->SystemStatus);
wait = false;
break;
}
char word[128];
char newString[7][10];
int i,j,ctr;
memset(word, 0x00, sizeof(word));
get_char(word);
if (strlen(word) == 0)
{
continue;
}
j=0; ctr=0;
strcpy(newString[1], "-1");
strcpy(newString[2], "-1");
for (i = 0; i <= (strlen(word)); i++)
{
if (word[i] == ' ' || word[i] == '\0' || word[i] == 10)
{
newString[ctr][j] = '\0';
ctr++;
j = 0;
}
else
{
newString[ctr][j] = word[i];
j++;
}
}
if(strcmp(newString[0], "c") == 0)
{
printf("Stop\r\n");
wait = false;
}
usleep(100000);
}
printf("\r\n");
}
void GenerateManualStop(int gunIndex, bool isAlarm, char *alarmCode)
{
if(isAlarm)
{
if(!_chargingData[gunIndex]->ChargingStopFlag.bits.AlarmStop)
{
if(strncmp((char *)_chargingData[gunIndex]->ConnectorAlarmCode, "", 6) == EQUAL)
{
memcpy((char *)_chargingData[gunIndex]->ConnectorAlarmCode, alarmCode, 6);
}
_chargingData[gunIndex]->ChargingStopFlag.bits.AlarmStop = true;
printf("Set Gun %d Stop Charging(ManualAlarm)\r\n", gunIndex + 1);
}
}
else
{
if(!_chargingData[gunIndex]->ChargingStopFlag.bits.ManualStop)
{
_chargingData[gunIndex]->ChargingStopFlag.bits.ManualStop = true;
printf("Set Gun %d Stop Charging(ManualStop)\r\n", gunIndex + 1);
}
}
}
// v1: gun
void SetGunStopCharging(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt > maxPara || totalCnt == 0)
{
printf("Input cmd fail ------ gunstp [gun 1-4] [status code]\r\n\r\n");
return;
}
int gun = 0;
gun = atoi(&MultiSubCmd[0][0]);
if(gun <= 0 || gun > GENERAL_GUN_QUANTITY)
{
printf("\r\n");
printf("Gun Stop Charging Input parameter %d over range\r\n", gun);
printf("\r\n");
return;
}
bool isAlarmStop = false;
char manualAlarm[7];
if(totalCnt == 2)
{
if((strlen(&MultiSubCmd[1][0]) == 6) && atoi(&MultiSubCmd[1][0]) != 0)
{
memset(manualAlarm, 0x00, sizeof(manualAlarm));
memcpy(manualAlarm, &MultiSubCmd[1][0], 6);
isAlarmStop = true;
}
}
bool wait = true;
int time = 0;
struct timespec _Wait_time;
unsigned char PreviousSystemStatus = 0xFF;
printf("\r\n");
while(wait)
{
switch(_chargingData[gun - 1]->SystemStatus)
{
case S_IDLE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_IDLE\r\n", gun);
if(PreviousSystemStatus == 0xFF)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[gun - 1].Role == _GROLE_SLAVE)
{
printf("Set Group [%02X] Stop\r\n", gun - 1);
ShmChargerInfo->PsuGrouping.GroupCollection[gun - 1].GroupCtrl.bits.SlavePowerOffRequest = true;
}
}
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GetClockTime(&_Wait_time);
}
time = GetTimeoutValue(_Wait_time) / uSEC_VAL;
if(time >= 1)
{
wait = false;
printf("Done\r\n");
}
break;
case S_REASSIGN_CHECK:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_REASSIGN_CHECK, Wait For Request Charging\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_REASSIGN:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_REASSIGN, Wait For Grouping\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_PREPARNING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARNING\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_PREPARING_FOR_EV:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARING_FOR_EV\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_PREPARING_FOR_EVSE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_PREPARING_FOR_EVSE, Wait For EVSE\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_CHARGING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_CHARGING\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
GenerateManualStop(gun - 1, isAlarmStop, manualAlarm);
}
break;
case S_TERMINATING:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_TERMINATING\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_COMPLETE:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_COMPLETE\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
case S_ALARM:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun %d S_ALARM\r\n", gun);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
break;
default:
if(PreviousSystemStatus != _chargingData[gun - 1]->SystemStatus)
{
printf("Gun SystemStatus %d Unknown(%d)\r\n", gun, _chargingData[gun - 1]->SystemStatus);
PreviousSystemStatus = _chargingData[gun - 1]->SystemStatus;
}
printf("Gun %d SystemStatus(%d) Is Not Available\r\n", gun, _chargingData[gun - 1]->SystemStatus);
wait = false;
break;
}
char word[128];
char newString[7][10];
int i,j,ctr;
memset(word, 0x00, sizeof(word));
get_char(word);
if (strlen(word) == 0)
{
continue;
}
j=0; ctr=0;
strcpy(newString[1], "-1");
strcpy(newString[2], "-1");
for (i = 0; i <= (strlen(word)); i++)
{
if (word[i] == ' ' || word[i] == '\0' || word[i] == 10)
{
newString[ctr][j] = '\0';
ctr++;
j = 0;
}
else
{
newString[ctr][j] = word[i];
j++;
}
}
if(strcmp(newString[0], "c") == 0)
{
printf("Stop\r\n");
wait = false;
}
usleep(100000);
}
printf("\r\n");
}
void SetGunExtend(char *v1)
{
int gun = 0;
gun = atoi(v1);
if(_chargingData[gun - 1]->SystemStatus == S_CHARGING && ShmChargerInfo->PsuGrouping.GroupCollection[gun - 1].Role == _GROLE_MASTER)
{
printf("\r\nSet Group [%02X] Extend Capability", gun - 1);
ShmChargerInfo->PsuGrouping.GroupCollection[gun - 1].GroupCtrl.bits.MorePowerRequest = true;
}
else
{
printf("\r\nGun %d Extend Capability Is Not Available, SystemStatus(%d)", gun, _chargingData[gun - 1]->SystemStatus);
}
printf("\r\n\r\n");
}
// Gun TargetV TargetC GTargetV GTargetC OutputV OutputC G_Psu_V G_Psu_C Psu 0_V Psu 0_C Psu 1_V Psu 1_C Psu 2_V Psu 2_C ...
// X XXXX.X V XXX.X A XXXX.X V XXX.X A XXXX.X V XXX.X A XXXX.X V XXX.X A XXXX.X V XXX.X A XXXX.X V XXX.X A XXXX.X V XXX.X A
void ShowGunOutput(void)
{
byte target = 0;
unsigned short voltage = 0, current = 0;
printf("\r\n Gun TargetV TargetC GTargetV GTargetC OutputV OutputC G_Psu_V G_Psu_C Psu 0_V Psu 0_C Psu 1_V Psu 1_C Psu 2_V Psu 2_C ...");
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
target = ShmPsuGrouping->Layout[i];
// "\r\n %d %4d.%d V %3d.%d A %4d.%d V %3d.%d A %4d.%d V %3d.%d A %4d.%d V %3d.%d A %4d.%d V %3d.%d A %4d.%d V %3d.%d A"
voltage = (unsigned short)(_chargingData[target]->EvBatterytargetVoltage * 10);
current = (unsigned short)(_chargingData[target]->EvBatterytargetCurrent * 10);
printf("\r\n %d %4d.%d V %3d.%d A", target + 1, (voltage / 10), (voltage % 10), (current / 10), (current % 10));
voltage = ShmPsuGrouping->GroupOutput[target].GTargetVoltage;
current = ShmPsuGrouping->GroupOutput[target].GTargetCurrent;
printf(" %4d.%d V %3d.%d A", (voltage / 10), (voltage % 10), (current / 10), (current % 10));
voltage = (unsigned short)(_chargingData[target]->PresentChargingVoltage * 10);
current = (unsigned short)(_chargingData[target]->PresentChargingCurrent * 10);
printf(" %4d.%d V %3d.%d A", (voltage / 10), (voltage % 10), (current / 10), (current % 10));
voltage = ShmPsuData->PsuGroup[target].GroupPresentOutputVoltage;
current = ShmPsuData->PsuGroup[target].GroupPresentOutputCurrent;
printf(" %4d.%d V %3d.%d A", (voltage / 10), (voltage % 10), (current / 10), (current % 10));
/*
for(int j = 0; j < ShmPsuData->PsuGroup[target].GroupPresentPsuQuantity; j++)
{
printf(" %4d.%d V %3d.%d A", (voltage / 10), (voltage % 10), (current / 10), (current % 10));
}
*/
}
printf("\r\n\r\n");
}
void SetGpio(char *v1, char *v2)
{
int testItem = 0;
int testItemLen = 1;
int ioOutput = 0;
char strTest[32][32] = {"4g"};
char strItem[32][32] = {"4G Reset"};
ioOutput = atoi(v2);
if(ioOutput < 0)
{
return;
}
for(int i = 0; i < testItemLen; i++)
{
if(strcmp((char *)&strTest[i][0], v1) == 0)
{
testItem = i + 1;
break;
}
}
if(testItem != 0)
{
if(ioOutput)
{
system("echo 1 > /sys/class/gpio/gpio104/value");
}
else
{
system("echo 0 > /sys/class/gpio/gpio104/value");
}
printf("Set %s %s\n",
strItem[testItem - 1], ioOutput > 0 ? "High" : "Low");
}
else
{
printf("Gpio Item %s Not Found\n", v1);
}
printf("\r\n");
}
void ShowStatus(void)
{
char *str_cabinet_role[] = {STR_CABINET_ROLE_NONE, STR_CABINET_ROLE_MASTER, STR_CABINET_ROLE_SLAVE};
for(int i = 0; i < ShmChargerInfo->Control.MaxConnector; i++)
{
printf("\r\nGun %d Status = %d, IsAvailable = %d, GunEnable = %d",
i + 1,
_chargingData[i]->SystemStatus,
_chargingData[i]->IsAvailable,
ShmChargerInfo->Control.GunAvailable[i]);
printf("\r\nAlarmCode");
printf("\r\n Connector = %6s, EvConn = %6s, Remote = %6s, Vendor = %6s",
strncmp((char *)_chargingData[i]->ConnectorAlarmCode, "", 6) != 0 ?
(char *)_chargingData[i]->ConnectorAlarmCode : "No Err",
strncmp((char *)_chargingData[i]->EvConnAlarmCode, "", 6) != 0 ?
(char *)_chargingData[i]->ConnectorAlarmCode : "No Err",
strncmp((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].RemotenAlarmCode, "", 6) != 0 ?
(char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].RemotenAlarmCode : "No Err",
strncmp((char *)ShmOCPP16Data->StatusNotification[i].VendorErrorCode, "", 6) != 0 ?
(char *)ShmOCPP16Data->StatusNotification[i].VendorErrorCode : "No Err");
}
printf("\r\n");
printf("\r\nPower Cabinet Role: %s, Switch Value: %d, ",
ShmChargerInfo->Control.CabinetSwitch <= _CROLE_SLAVE ? str_cabinet_role[ShmChargerInfo->Control.CabinetSwitch] : "Unknown",
ShmChargerInfo->Control.CabinetSwitch);
printf("\r\nStatus Code Len = %d", ShmSysConfigAndInfo->SysWarningInfo.WarningCount);
if(ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 0)
{
printf("\r\n WarningCode:");
for(int i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++)
{
printf(" %s", (char *)&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0]);
}
}
printf("\r\n\r\n");
}
void ShowWhiteCardList(void)
{
printf("\r\nWhite Card List");
for(int i = 0; i < 10; i++)
{
printf("\r\n White Card [%2d]: %s", i + 1, (char *)ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[i]);
}
printf("\r\n\r\n");
}
void WriteWhiteCard(char *v1, char *v2)
{
int cardIndex = 0;
cardIndex = atoi(v1);
if(cardIndex < 1 || cardIndex > 10)
{
printf("\r\n White Card Index Fail\r\n\r\n");
return;
}
if(strlen(v2) == 0 || strlen(v2) > 31)
{
printf("\r\n White Card Fail\r\n\r\n");
return;
}
printf("\r\n Str Len = %d = %s", strlen(v2), v2);
printf("\r\n Set White Card Index %d = %s", cardIndex, v2);
memcpy((char *)&ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[cardIndex - 1][0], v2, strlen(v2));
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
printf("\r\n\r\n");
}
void EraseWhiteCard(char *v1)
{
int cardIndex = 0;
cardIndex = atoi(v1);
if(cardIndex < 1 || cardIndex > 10)
{
printf("\r\n White Card Index Fail\r\n\r\n");
return;
}
printf("\r\n Erase White Card Index = %d", cardIndex);
memset((char *)&ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[cardIndex - 1][0], 0x00, 32);
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
printf("\r\n\r\n");
}
// MaxChargingProfile: %s
// Offline MaxPower: %s
// LocalPowerSharing: %s
// Max Total Power: XXXX kW, Total Current: XXXX A, MaxSoc: XXX %
// Total Energy: XXXX kWh, Duration: XXXX Minute(s)
void ShowMaxLimit(void)
{
char tempString[64];
//************************************************************************************************
memset(tempString, 0x00, sizeof(tempString));
if(ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower == -1)
{
sprintf(tempString, " %s", "Unlimited");
}
else
{
sprintf(tempString, " %4d kW", (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower / 1000);
}
printf(" MaxChargingProfile: %s\r\n", tempString);
//************************************************************************************************
memset(tempString, 0x00, sizeof(tempString));
if(ShmChargerInfo->OutputLimit.Offline_MaxChargingPower <= 0)
{
sprintf(tempString, " %s", "Unlimited");
}
else
{
sprintf(tempString, " %4d kW", ShmChargerInfo->OutputLimit.Offline_MaxChargingPower / 1000);
}
printf(" Offline MaxPower: %s\r\n", tempString);
//************************************************************************************************
memset(tempString, 0x00, sizeof(tempString));
if(ShmSysConfigAndInfo->SysConfig.isEnableLocalPowerSharing == _SYS_POWER_SHARING_MODE_DISABLE)
{
sprintf(tempString, " %s", "Disable");
}
else
{
if(ShmSysConfigAndInfo->SysConfig.isEnableLocalPowerSharing == _SYS_POWER_SHARING_MODE_MASTER)
{
sprintf(tempString, " %s, PowerSharingPower: %d W", "Master", ShmSysConfigAndInfo->SysConfig.PowerSharingCapacityPower);
}
else
{
sprintf(tempString, " %s", "Slave");
}
}
printf(" LocalPowerSharing: %s\r\n", tempString);
//************************************************************************************************
printf(" Max Total Power: %4d kW, Total Current: %4d A, MaxSoc: %3d %%\r\n",
ShmSysConfigAndInfo->SysConfig.MaxChargingPower,
ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent,
ShmSysConfigAndInfo->SysConfig.MaxChargingSoc);
//************************************************************************************************
printf(" Total Energy: %4d kWh, Duration: %4d Minute(s)\r\n",
ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy, ShmSysConfigAndInfo->SysConfig.MaxChargingDuration);
}
void ShowGunLimit(int gun_index)
{
char *str_gun_type[] = {STR_GUN_TYPE_CHADEMO, STR_GUN_TYPE_CCS, STR_GUN_TYPE_GBT};
// Gun Enable Type Psu Phy_Vol Phy_Cur Config_Ocpp_MaxOcpp_Pow Config_Ocpp_MaxOcpp_Cur LocalPowerSharing
// 1 0 CHAdeMO 00 0000 V 0000 A 0000 / 0000 / 0000 kW 0000 / 0000 A 0000 >> 0000 A
printf(" %d %d ", gun_index + 1, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable);
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable)
{
printf(" %7s %2d",
_chargingData[gun_index]->Type <= _Type_GB ? str_gun_type[_chargingData[gun_index]->Type] : "???",
ShmChargerInfo->PsuGrouping.GroupCollection[gun_index].GunPsuQuantity);
printf(" %4d V %4d A",
(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteMaxPhysicalVoltage / 10),
(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteMaxPhysicalCurrent / 10));
printf(" %4d / %4d / %4d kW",
(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingPower / 10),
_chargingData[gun_index]->ChargingProfilePower == -1 ? (int)_chargingData[gun_index]->ChargingProfilePower : ((int)_chargingData[gun_index]->ChargingProfilePower / 1000),
ShmChargerInfo->OutputLimit.GunMaxProfilePower[gun_index] == 0 ? (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower : (ShmChargerInfo->OutputLimit.GunMaxProfilePower[gun_index] / 1000));
printf(" %4d / %4d A",
((int)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingCurrent / 10),
_chargingData[gun_index]->ChargingProfileCurrent == -1 ? (int)_chargingData[gun_index]->ChargingProfileCurrent : ((int)_chargingData[gun_index]->ChargingProfileCurrent / 10));
printf(" %4d >> %4d A", ShmSysConfigAndInfo->SysInfo.localSharingInfo.AvailableShargingCurrent[gun_index], (int)_chargingData[gun_index]->LocalPowerLimitCurrent);
}
printf("\r\n");
}
void ShowChargerLimit(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
printf("\r\n");
printf("Charger Limit\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(1, 7);
ConsoleReflash(CONNECTOR_QUANTITY, 1);
}
ShowMaxLimit();
printf("\r\n");
printf(" Gun Enable Type Psu Phy_Vol Phy_Cur Config_Ocpp_MaxOcpp_Pow Config_Ocpp_MaxOcpp_Cur LocalPowerSharing\r\n");
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
ShowGunLimit(i);
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void SetPsuCommand(char *inputCmd, unsigned int opt)
{
}
void SetGunCommand(char *v1, char *v2, char *v3)
{
int cmdItem = 0;
int cmdItemLen = 2;
int gunID = 0;
int enable = 0;
char strGunCmd[32][32] = {"enable", "operative"};
char strDescription[32][32] = {"Available", "Operative"};
gunID = atoi(v2);
enable = atoi(v3);
if(gunID <= 0 || gunID > CONNECTOR_QUANTITY || enable < 0)
{
return;
}
for(int i = 0; i < cmdItemLen; i++)
{
if(strcmp((char *)&strGunCmd[i][0], v1) == 0)
{
cmdItem = i + 1;
break;
}
}
if(cmdItem != 0)
{
switch(cmdItem)
{
case 1:
ShmChargerInfo->Control.GunAvailable[gunID - 1] = enable > 0 ? YES : NO;
ShmChargerInfo->ConnectorMiscReq[gunID - 1].bits.Availability = true;
break;
case 2:
_chargingData[gunID - 1]->IsAvailable = enable > 0 ? YES : NO;
ShmChargerInfo->ConnectorMiscReq[gunID - 1].bits.Availability = true;
break;
}
printf("Gun cmd [%s] [%s]\n", strDescription[cmdItem - 1], enable ? "Enable" : "Disable");
}
else
{
printf("Gun cmd %s not found\n", v1);
for(int i = 0; i < cmdItemLen; i++)
{
printf(" [%s] -> %s Test\n", strGunCmd[i], strDescription[i]);
}
}
printf("\r\n");
}
void ShowWebSystemInfo(void)
{
char *str_led_intensity[] = {STR_DARKEST, STR_MEDIUM, STR_BRIGHTEST};
char *str_qr_code_made[] = {STR_QR_DEFAULT, STR_QR_CUSTOMIZED, STR_QR_CHARGEBOXID};
char *str_rfid_endian[] = {STR_LITTLE_ENDIAN, STR_BIG_ENDIAN};
printf("\r\n");
printf("Web [System]\r\n");
printf(" *System ID: %s\r\n", ShmSysConfigAndInfo->SysConfig.SystemId);
printf(" *AuthorisationMode[%7s]\r\n",
ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE ? "Enable" : "Disable");
printf(" - APP [%7s]\r\n", ShmSysConfigAndInfo->SysConfig.isAPP > 0 ? "Enable" : "Disable");
printf(" - QRCode [%7s]\r\n", ShmSysConfigAndInfo->SysConfig.isQRCode > 0 ? "Enable" : "Disable");
printf(" - RFID [%7s]\r\n", ShmSysConfigAndInfo->SysConfig.isRFID > 0 ? "Enable" : "Disable");
printf(" - EVCCID [%7s]\r\n", ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID > 0 ? "Enable" : "Disable");
if(ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian <= RFID_ENDIAN_BIG)
{
printf(" *RfidCardNumEndian [%s]\r\n", str_rfid_endian[ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian]);
}
else
{
printf(" *RfidCardNumEndian: %d\r\n", ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian);
}
if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode <= _QR_MODE_Customized)
{
printf(" *QR Code Made [%s]\r\n", str_qr_code_made[ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode]);
}
else
{
printf(" *QR Code Made: %d\r\n", ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode);
}
if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == _QR_MODE_Customized)
{
printf(" - QR Code Content: %s\r\n", ShmSysConfigAndInfo->SysConfig.QRCodeContent);
}
if(ShmChargerInfo->AuthInfo.QRCodeMode <= _QR_MODE_ChargeBoxId)
{
printf(" *QR Code Mode [%s]\r\n", str_qr_code_made[ShmChargerInfo->AuthInfo.QRCodeMode]);
}
else
{
printf(" *QR Code Mode: %d\r\n", ShmChargerInfo->AuthInfo.QRCodeMode);
}
if(ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity <= _LED_INTENSITY_BRIGHTEST)
{
printf(" *LED Intensity[%s]\r\n", str_led_intensity[ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity]);
}
else
{
printf(" *LED Intensity[%d]\r\n", ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity);
}
}
void ShowWebChargingInfo(void)
{
printf("\r\n");
printf("Web [Charging]\r\n");
printf(" *Max Charging Energy : %4d kWh\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy);
printf(" *Max Charging Power : %4d kW\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingPower);
printf(" *Max Charging Current : %4d A\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent);
printf(" *Max Charging Duration: %4d Minutes\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingDuration);
printf(" *Max Charging Soc : %4d %%\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingSoc);
printf(" *StopCharging By Button[%7s]\r\n", ShmSysConfigAndInfo->SysConfig.StopChargingByButton > 0 ? "Enable" : "Disable");
printf(" *Billing[%7s]\r\n", ShmSysConfigAndInfo->SysConfig.BillingData.isBilling > 0 ? "Enable" : "Disable");
printf(" - Currency[%2d]\r\n", ShmSysConfigAndInfo->SysConfig.BillingData.Currency);
}
// *DHCP Client [Enable]
// - MAC Add [%s]
// - IP Add [%s]
// - Submask [%s]
// - Gateway [%s]
void ShowEthernetInfo(void)
{
printf(" *DHCP Client [%s]\r\n", ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0 ? "Enable" : "Disable");
printf(" - MAC Add [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthMacAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthMacAddress : "NULL");
printf(" - IP Add [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress : "NULL");
printf(" - SubMask [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress : "NULL");
printf(" - Gateway [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress : "NULL");
}
// *WiFi Mode [Station]
// - SSID [%s]
// - PWD [%s]
// - TargetMac [%s]
// - RSSI [%s]
// - DHCP [%s]
// - MAC Add [%s]
// - IP Add [%s]
// - Submask [%s]
// - Gateway [%s]
// - ConnStatus [Connected]
void ShowWiFiInfo(void)
{
char *str_wifi_mode[] = {"Disable", "Station", "AP Mode"};
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode <= _SYS_WIFI_MODE_AP)
{
printf(" *WiFi Mode [%s]\r\n", str_wifi_mode[ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode]);
}
else
{
printf(" *WiFi Mode [%d]\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode);
}
if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == _SYS_WIFI_MODE_STATION)
{
printf(" - SSID [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSsid) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSsid : "NULL");
printf(" - PWD [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiPassword) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiPassword : "NULL");
printf(" - TargetMac [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiTargetBssidMac) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiTargetBssidMac : "NULL");
printf(" - RSSI [%d dBm]\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi);
printf(" - DHCP [%s]\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiDhcpClient == 0 ? "Enable" : "Disable");
printf(" - MAC Add [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMacAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMacAddress : "NULL");
printf(" - IP Add [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiIpAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiIpAddress : "NULL");
printf(" - SubMask [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSubmaskAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSubmaskAddress : "NULL");
printf(" - Gateway [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiGatewayAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiGatewayAddress : "NULL");
printf(" - ConnStatus [%s]\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiNetworkConn == YES ? "Connected" : "Disconnected");
}
}
// *3G/4G Mode [%s]
// - APN [%s]
// - NetworkType[%s]
// - RSSI [%d dBm]
// - ChapPapId [%s]
// - ChapPapPwd [%s]
// - Modem IMEI [%s]
// - SIM IMSI [%s]
// - SIM ICCID [%s]
// - SIM Status [%s]
// - Modem Mode [%s]
// - IP Add [%s]
// - ConnStatus [%s]
void Show3G4GInfo(void)
{
char *strNetworkType[] = {"Auto", "CDMA", "WCDMA", "LTE", "TD-SCDMA", "UMTS", "CDMA", "HDR", "CDMA/HDR"};
char *strSimStatus[] = {"No SIM Card", "Valid SIM Card", "Invalid SIM Card"};
char *strModemMode[] = {"No Services", "CDMA", "GSM/GPRS", "WCDMA", "GSM/WCDMA", "TD_SCDMA", "HSPA", "LTE", "Mode 8", "Unknown"};
printf(" *3G/4G Mode [%s]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES ? "Enable" : "Disable");
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
{
printf(" - APN [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomApn) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomApn : "NULL");
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkType <= 8)
{
printf(" - NetworkType[%s]\r\n", strNetworkType[ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkType]);
}
else
{
printf(" - NetworkType[%d]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkType);
}
printf(" - RSSI [%d dBm]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi);
printf(" - ChapPapId [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapId) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapId : "NULL");
printf(" - ChapPapPwd [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapPwd) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapPwd : "NULL");
printf(" - Modem IMEI [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemImei) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemImei : "NULL");
printf(" - SIM IMSI [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimImsi) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimImsi : "NULL");
printf(" - SIM ICCID [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimIccid) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimIccid : "NULL");
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimStatus <= 2)
{
printf(" - SIM Status [%s]\r\n", strSimStatus[ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimStatus]);
}
else
{
printf(" - SIM Status [%d]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimStatus);
}
if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemMode <= 9)
{
printf(" - Modem Mode [%s]\r\n", strModemMode[ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemMode]);
}
else
{
printf(" - Modem Mode [%d]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemMode);
}
printf(" - IP Add [%s]\r\n", strlen((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomIpAddress) > 0 ? (char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomIpAddress : "NULL");
printf(" - ConnStatus [%s]\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES ? "Connected" : "Disconnected");
}
}
void ShowWebNetworkInfo(void)
{
printf("\r\n");
printf("Web [Network]\r\n");
printf(" *NetworkStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.InternetConn > 0 ? "Connected" : "Disconnected");
ShowEthernetInfo();
ShowWiFiInfo();
Show3G4GInfo();
}
void ShowWebEthernetOnly(void)
{
printf("\r\n");
printf("Web [Network]\r\n");
printf(" *NetworkStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.InternetConn > 0 ? "Connected" : "Disconnected");
ShowEthernetInfo();
}
void ShowWebWiFiOnly(void)
{
printf("\r\n");
printf("Web [Network]\r\n");
printf(" *NetworkStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.InternetConn > 0 ? "Connected" : "Disconnected");
ShowWiFiInfo();
}
void ShowWeb3G4GOnly(void)
{
printf("\r\n");
printf("Web [Network]\r\n");
printf(" *NetworkStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.InternetConn > 0 ? "Connected" : "Disconnected");
Show3G4GInfo();
}
void ShowWebBackendInfo(void)
{
char *str_offline_policy[] = {"Local List", "Phihong RFID", "Free Charging", "No Charging"};
char *str_security_profile[] = {
"None security",
"Unsecured Transport with Basic Atuentication",
"TLS with Basic Authentication",
"TLS with Client Side Certificates"
};
printf("\r\n");
printf("Web [Backend]\r\n");
printf(" *Common\r\n");
printf(" - Backend Timeout : %d s\r\n", ShmSysConfigAndInfo->SysConfig.BackendConnTimeout);
if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy <= _OFFLINE_POLICY_NO_CHARGING)
{
printf(" - Offline Policy : %s\r\n", str_offline_policy[ShmSysConfigAndInfo->SysConfig.OfflinePolicy]);
}
else
{
printf(" - Offline Policy : %d\r\n", ShmSysConfigAndInfo->SysConfig.OfflinePolicy);
}
printf(" - OfflineMaxEnergy : %4d kWh\r\n", ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy);
printf(" - OfflineMaxDuration: %4d Minutes\r\n", ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration);
printf(" *OCPP\r\n");
printf(" - OcppStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES ? "Connected" : "Disconnected");
printf(" - OcppURL : %s\r\n", ShmSysConfigAndInfo->SysConfig.OcppServerURL);
printf(" - ChargeBoxId: %s\r\n", ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
printf(" - Vendor : %s\r\n", ShmSysConfigAndInfo->SysConfig.chargePointVendor);
if(ShmSysConfigAndInfo->SysConfig.OcppSecurityProfile <= 3)
{
printf(" - Security : %s\r\n", str_security_profile[ShmSysConfigAndInfo->SysConfig.OcppSecurityProfile]);
}
else
{
printf(" - Security : %d\r\n", ShmSysConfigAndInfo->SysConfig.OcppSecurityProfile);
}
printf(" - MaintainStatus[%s]\r\n", ShmSysConfigAndInfo->SysInfo.MaintainServerConnStatus == YES ? "Connected" : "Disconnected");
printf(" - MaintainURL : %s\r\n", ShmSysConfigAndInfo->SysConfig.MaintainServerURL);
if(ShmSysConfigAndInfo->SysConfig.MaintainServerSecurityProfile <= 3)
{
printf(" - MaintainSecurity: %s\r\n", str_security_profile[ShmSysConfigAndInfo->SysConfig.MaintainServerSecurityProfile]);
}
else
{
printf(" - MaintainSecurity: %d\r\n", ShmSysConfigAndInfo->SysConfig.MaintainServerSecurityProfile);
}
printf(" *TTIA[%7s]\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.isEnableTTIA == YES ? "Enable" : "Disable");
if(ShmSysConfigAndInfo->SysConfig.TTIA_Info.isEnableTTIA == YES)
{
printf(" - ServerAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.server_addr);
printf(" - ServerPort : %d\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.server_port);
printf(" - BusVenderId : %d\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.busVenderId);
printf(" - Provider : %s\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.EquipmentProvider);
printf(" - CompanyNo : %d\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.TransportationCompanyNo);
printf(" - ChargeBoxId : %d\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.ChargeBoxId);
printf(" - EVSEStation : %s\r\n", ShmSysConfigAndInfo->SysConfig.TTIA_Info.evseStation);
}
}
void ShowWebAllInfo(void)
{
ShowWebSystemInfo();
ShowWebChargingInfo();
ShowWebNetworkInfo();
ShowWebBackendInfo();
}
void ShowWebInfo(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 1;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt > maxPara)
{
printf("Input cmd fail ------ web [cmd]\r\n\r\n");
return;
}
bool find = false;
int showItem = 0;
int itemLen = 8;
char strItem[32][32] = {"system", "charging", "network", "backend", "all", "eth", "wifi", "4g"};
void *actionList[32] = {
&ShowWebSystemInfo, &ShowWebChargingInfo, &ShowWebNetworkInfo, &ShowWebBackendInfo,
&ShowWebAllInfo, &ShowWebEthernetOnly, &ShowWebWiFiOnly, &ShowWeb3G4GOnly};
void (*ItemAction)();
for(showItem = 0; showItem < itemLen; showItem++)
{
if(strcmp((char *)&strItem[showItem][0], &MultiSubCmd[0][0]) == 0)
{
find = true;
break;
}
}
if(find)
{
ItemAction = actionList[showItem];
ItemAction();
}
else
{
printf("\r\n");
printf ("Input cmd fail ------ web [cmd]\r\n");
for(int i = 0; i < itemLen; i++)
{
printf(" [cmd] %s\r\n", (char *)&strItem[i][0]);
}
}
printf("\r\n");
}
// Gun 1 ( CCS ) Soc: XXX %, Energy: XXXXXXX.XXX kWh, IdTag: [XXXXXXXXXX]
// (XX) (X) Target: XXXX V, XXXX A, Cap: XXXX A, XXXX kW, TxId: [XXXXXXXXXX]
// PSU: XXXX V, XXXX A, Limit: XXXX A, XXXX kW, Local: XXXXXXX.XXX kWh
// Start: [0000-00-00 00:00:00] PSU: XXXX V, XXXX A, Limit: XXXX A, XXXX kW, Local: XXXXXXX.XXX kWh
// Gun: XXXX V, XXXX A, Remote: XXXXXXX.XXX kWh, Meter: XXXXXXX.XXX kWh
// Stop: [0000-00-00 00:00:00] Gun: XXXX V, XXXX A, Remote: XXXXXXX.XXX kWh, Meter: XXXXXXX.XXX kWh
// Gun 1 ( CCS ) Soc: XXX %, Energy: XXXXXXX.XXX kWh, IdTag: [XXXXXXXXXX]
// (XX) (X) Target: XXXX V, XXXX A, Cap: XXXX A, XXXX kW, TxId: [XXXXXXXXXX]
// Start: [0000-00-00 00:00:00] PSU: XXXX V, XXXX A, Limit: XXXX A, XXXX kW, Ratio: X.XX %
// Stop: [0000-00-00 00:00:00] Gun: XXXX V, XXXX A, Power: XXXX.X kW, FireV: XXXX.X V
// Remote: XXXXXXX.XXX kWh, Local: XXXXXXX.XXX kWh, Meter: XXXXXXX.XXX kWh
void ShowGunInfo(int gun)
{
char *str_gun_type[] = {"CHAdeMO", " CCS ", " GBT "};
#if 0
printf(" Gun %d (%s) Soc: %3d %s, Energy: %10.3f kWh, IdTag [%20s] Transaction [%d], TotalCost: %.2f\r\n",
gun + 1,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Enable ? str_gun_type[_chargingData[gun]->Type] : "Disable",
_chargingData[gun]->EvBatterySoc, "%",
_chargingData[gun]->PresentChargedEnergy,
_chargingData[gun]->StartUserId,
ShmChargerInfo->UserTransaction[gun].TransactionId,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].TotalCost);
#endif
//************************************************************************************************
printf(" Gun %d (%s) Soc: %3d %s, Energy: %11.3f kWh",
gun + 1,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Enable ? str_gun_type[_chargingData[gun]->Type] : "Disable",
_chargingData[gun]->EvBatterySoc, "%",
_chargingData[gun]->PresentChargedEnergy);
if(strlen((char *)_chargingData[gun]->StartUserId) > 0)
{
printf(", IdTag: [%s]", _chargingData[gun]->StartUserId);
}
printf("\r\n");
//************************************************************************************************
printf(" (%2d) (%s) Target: %4d V, %4d A, Cap: %4d A, %4d kW",
_chargingData[gun]->SystemStatus,
_chargingData[gun]->ConnectorPlugIn ? "O" : "X",
(int)_chargingData[gun]->EvBatterytargetVoltage,
(int)_chargingData[gun]->EvBatterytargetCurrent,
(int)(_chargingData[gun]->AvailableChargingCurrent / 10),
(int)(_chargingData[gun]->AvailableChargingPower / 10));
if(ShmChargerInfo->UserTransaction[gun].TransactionId > 0)
{
printf(", TxId: [%d]", ShmChargerInfo->UserTransaction[gun].TransactionId);
}
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].TotalCost > 0)
{
printf(", $: %.2f", ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].TotalCost);
}
printf("\r\n");
//************************************************************************************************
if(strlen(ShmChargerInfo->Timestamp[gun].StartCharging) > 0)
{
printf(" Start: [%s] ", ShmChargerInfo->Timestamp[gun].StartCharging);
}
else
{
printf(" ");
}
printf("PSU: %4d V, %4d A, Limit: %4d A, %4d kW, Ratio: %4.2f %%\r\n",
(int)(_chargingData[gun]->PresentChargingVoltage),
(int)(_chargingData[gun]->PresentChargingCurrent),
(int)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].CapabilityCurrent / 10),
(int)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].CapabilityPower / 10),
ShmPsuGrouping->GroupCollection[gun].MaxOutputRatio);
//************************************************************************************************
if(strlen(ShmChargerInfo->Timestamp[gun].StopCharging) > 0)
{
printf(" Stop: [%s] ", ShmChargerInfo->Timestamp[gun].StopCharging);
}
else
{
printf(" ");
}
printf("Gun: %4d V, %4d A, Power: %6.1f kW, FireV: %6.1f V\r\n",
(int)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage / 10),
(int)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent / 10),
_chargingData[gun]->PresentChargingPower,
(_chargingData[gun]->FireChargingVoltage / 10));
//************************************************************************************************
printf(" Remote: %11.3f kWh, Local: %11.3f kWh, Meter: %11.3f kWh\r\n",
ShmChargerInfo->MeterValue[gun].GunConsumption,
ShmChargerInfo->MeterValue[gun].LocalConsumption,
_chargingData[gun]->PowerConsumption);
}
void ShowInfo(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(CONNECTOR_QUANTITY, 6);
}
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
printf("\r\n");
ShowGunInfo(i);
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void RtcSyncCmd(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
char hostAdd[32];
int dispenser = 0, offset = 0;
memset(hostAdd, 0x00, sizeof(hostAdd));
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ rtc [dispenser 1-4] [offset minute]\r\n\r\n");
return;
}
printf("\r\n");
dispenser = atoi(&MultiSubCmd[0][0]);
offset = atoi(&MultiSubCmd[1][0]);
if(dispenser <= 0 || dispenser > CONNECTOR_QUANTITY)
{
printf("dispenser %d over range\r\n\r\n", dispenser);
return;
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser - 1].LocalStatus == _DS_None ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser - 1].LocalStatus == _DS_Timeout)
{
printf("dispenser %d is not available\r\n\r\n", dispenser);
return;
}
// find dispenser ip address
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_DispenserMatched)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex == (dispenser - 1))
{
sprintf(hostAdd, "%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));
}
}
}
if(strlen(hostAdd) == 0)
{
printf("dispenser %d ip is not available\r\n\r\n", dispenser);
return;
}
printf("try sycn dispenser %d [%s] rtc, offset: %d minutes\r\n", dispenser, hostAdd, offset);
// get current time and create offset time
time_t timep;
struct tm *tm;
time(&timep);
tm = localtime(&timep);
printf(" NowTime: %d/%02d/%02d %02d:%02d:%02d\r\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
if(offset != 0)
{
timep += (offset * 60);
tm = localtime(&timep);
printf("OffsetTime: %d/%02d/%02d %02d:%02d:%02d\r\n\r\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
}
// create send socket
int rtcfd = 0;
struct sockaddr_in serverInfo;
struct timeval tv;
char rtcTxBuffer[64];
char rtcRxBuffer[64];
int txLen = 0, rxLen = 0;
unsigned char chksum = 0x00;
rtcfd = socket(AF_INET, SOCK_STREAM, 0);
if (rtcfd < 0)
{
printf("create rtc socket fail\r\n\r\n");
return;
}
memset(rtcTxBuffer, 0x00, sizeof(rtcTxBuffer));
memset(rtcRxBuffer, 0x00, sizeof(rtcRxBuffer));
tv.tv_sec = 3;
tv.tv_usec = 0;
setsockopt(rtcfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval)); //設定等待3s
setsockopt(rtcfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval)); //設定傳送3s
bzero(&serverInfo,sizeof(serverInfo));
serverInfo.sin_family = AF_INET;
serverInfo.sin_addr.s_addr = inet_addr(hostAdd);
serverInfo.sin_port = htons(8234);
if(connect(rtcfd, (struct sockaddr *)&serverInfo, sizeof(serverInfo)) < 0)
{
printf("connect to host: %s fail\r\n\r\n", hostAdd);
close(rtcfd);
return;
}
// set tx header & data
rtcTxBuffer[0] = 0xAA; // Frame ID
rtcTxBuffer[1] = 0x00; // Master address
rtcTxBuffer[2] = 0xFF; // Slave address
rtcTxBuffer[3] = 0x87; // 0x87
rtcTxBuffer[4] = 0x0E; // Length_Low
rtcTxBuffer[5] = 0x00; // Length_High
sprintf(&rtcTxBuffer[6], "%04d%02d%02d%02d%02d%02d",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
txLen = rtcTxBuffer[4] + (rtcTxBuffer[5] << 8);
chksum = 0;
for(int i = 0; i < txLen; i++)
{
chksum ^= rtcTxBuffer[6 + i];
}
rtcTxBuffer[6 + txLen] = chksum;
send(rtcfd, rtcTxBuffer, txLen + 7, MSG_NOSIGNAL);
// receive
if(recv(rtcfd, &rtcRxBuffer[0], 6, MSG_WAITALL) < 0)
{
printf("read head fail\r\n\r\n");
close(rtcfd);
return;
}
rxLen = rtcRxBuffer[4] + (rtcRxBuffer[5] << 8);
if(recv(rtcfd, &rtcRxBuffer[6], rxLen + 1, MSG_WAITALL) < 0)
{
printf("read data fail\r\n\r\n");
close(rtcfd);
return;
}
chksum = 0;
for(int i = 0; i < rxLen; i++)
{
chksum ^= rtcRxBuffer[6 + i];
}
if(chksum == rtcRxBuffer[6 + rxLen])
{
printf("set %s rtc: ", hostAdd);
for(int i = 0; i < txLen; i++)
{
printf("%c", rtcTxBuffer[6 + i]);
}
printf(" %s\r\n\r\n", rtcRxBuffer[6] == 0x01 ? "success" : "fail");
}
else
{
printf("receive rtc checksum fail\r\n\r\n");
}
close(rtcfd);
}
void ParsingModelName(char *modelName)
{
ParsingRatedCur parsingRatedCur = {0};
RateCurInfo *pRatedCurInfo = NULL;
if(RatedCurrentParsing(modelName, &parsingRatedCur) != PASS)
{
printf("Parsing [%s] failed\r\n", modelName);
return;
}
printf("Model Name: [%s]\r\n", modelName);
for(int i = 0; i < 2; i++)
{
pRatedCurInfo = (RateCurInfo *)&parsingRatedCur.ParsingInfo[i];
printf(" Gun %d Type %d, MaxVol: %d, MaxCur: %d\r\n",
i + 1, pRatedCurInfo->GunType, pRatedCurInfo->Voltage, pRatedCurInfo->Current);
}
}
void ParsingModelNameCmd(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 1;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt > maxPara)
{
printf("Input cmd fail ------ pmodel [model_name]\r\n\r\n");
return;
}
printf("\r\n");
if(totalCnt != 0)
{
ParsingModelName(&MultiSubCmd[0][0]);
}
else
{
printf("Cabinet\r\n");
ParsingModelName((char *)&ShmSysConfigAndInfo->SysConfig.ModelName[0]);
for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
{
printf("\r\n");
printf("Dispenser %d\r\n", i + 1);
ParsingModelName((char *)&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ModelName[0]);
}
}
}
printf("\r\n");
}
void CustomerPriceTest(char *inputCmd, unsigned int opt)
{
#if 0
char priceString[512];
float price = 0;
printf("\r\n");
// running cost
printf("Running Cost\r\n");
strcpy(priceString, "Connection Fee: $0 NTD; Session Fee: $15.96 NTD; Occupancy Fee: $0 NTD; Total Cost: $15.96 NTD; Account Balance: $37693 NTD");
price = PriceParsing((char *)priceString, "Connection Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Connection Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Session Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Session Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Occupancy Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Occupancy Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Total Cost", _AUDI_PRICE_SPLIT_KEY);
printf("Total Cost: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Account Balance", _AUDI_PRICE_SPLIT_KEY);
printf("Account Balance: %.2f\r\n", price);
// final cost
printf("Final Cost\r\n");
strcpy(priceString, "Connection Fee: $0 NTD; Session Fee: $283.68 NTD; Occupancy Fee: $0 NTD; Total Cost: $283.68 NTD; Account Balance: $37410 NTD");
price = PriceParsing((char *)priceString, "Connection Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Connection Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Session Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Session Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Occupancy Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Occupancy Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Total Cost", _AUDI_PRICE_SPLIT_KEY);
printf("Total Cost: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Account Balance", _AUDI_PRICE_SPLIT_KEY);
printf("Account Balance: %.2f\r\n", price);
// user price
printf("User Price\r\n");
strcpy(priceString, "Connection Fee: $0 NTD/time; Current Rate: $12 NTD/kWh; Occupancy Fee: $0 NTD/hr; Account Balance: $17553 NTD");
price = PriceParsing((char *)priceString, "Connection Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Connection Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Current Rate", _AUDI_PRICE_SPLIT_KEY);
printf("Current Rate: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Occupancy Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Occupancy Fee: %.2f\r\n", price);
price = PriceParsing((char *)priceString, "Account Balance", _AUDI_PRICE_SPLIT_KEY);
printf("Account Balance: %.2f\r\n", price);
// default price
printf("Default Price\r\n");
strcpy(priceString, "Connection Fee: $0 NTD/time; Current Rate: $12 NTD/kWh; Occupancy Fee: $0 NTD/hr");
price = PriceParsing(priceString, "Connection Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Connection Fee: %.2f\r\n", price);
price = PriceParsing(priceString, "Current Rate", _AUDI_PRICE_SPLIT_KEY);
printf("Current Rate: %.2f\r\n", price);
price = PriceParsing(priceString, "Occupancy Fee", _AUDI_PRICE_SPLIT_KEY);
printf("Occupancy Fee: %.2f\r\n", price);
printf("\r\n");
printf("TCC Default Price\r\n");
strcpy(priceString, "$ 12/kWh");
price = PriceParsing(priceString, "", "");
printf("Default: %.2f\r\n", price);
printf("\r\n");
char userPrice[512];
printf("Shell Default Price\r\n");
strcpy(priceString, "100.0 kW\nPrice\nTransaction Fee: $0.6165/Flat\nIdle Fee: $0.5/Flat\n\n100.0 kW\nPrice\nTransaction Fee: $0.6165/Flat\nIdle Fee: $0.5/Flat\n\n");
ShellPriceParsing(priceString, userPrice);
printf("DefaultPrice: %s\r\n", userPrice);
printf("\r\n");
printf("Shell User Price\r\n");
ShellPriceParsing(priceString, userPrice);
printf("UserPrice: %s\r\n", userPrice);
printf("\r\n");
strcpy(priceString, "Current Period Price:$0.35/kWh\nCurrent Idle Fee: $5.0/hr\nCurrent Total: 2.70kWh $2.53 ConnectorId: 1\nLast update: 2021-06-28T11:22:31");
price = ShellRunningCostParsing(priceString);
printf("Shell Running Cost\r\n");
printf("Cost: %.2f\r\n", price);
printf("\r\n");
strcpy(priceString, "2022-01-18 07:00:00-2022-01-18 08:15:30\n07:00 AM $1.00/kWh 4.30kWh Cost: $4.300\n07:30 AM $2.00/kWh 0.00kWh Cost: $4.300\n07:46 AM $0.00/Flat 10m Cost: $0.000\n07:56 AM $0.50/Flat 19m Cost: $0.500\nTotal\nSale: $4.80\nTax: $0.00\nTransaction Fee: $0.62\nDiscount: $0.00\nCost: $5.42\nEnergy: 4.3000kWh\nTime: 1 Hrs 15 Mins\nPayment: RFID\nReceipt: https://qa.qa.greenlotstest-qa.com/greenlots/receipt.jsf?session5658739 | Call 1 800 Greenlots or check app for more detailed receipt\nEV_DISCONNECTED");
printf("Shell Final Cost\r\n");
int urlLen = 0;
char url[512];
price = ShellFinalCostParsing(priceString);
urlLen = GetShellReceiptInfo(priceString, url);
printf("Cost: %.2f\r\n", price);
if(urlLen > 0)
{
printf("Receipt: [%s]\r\n", url);
}
#endif
}
void EvCommMsgDebug(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
printf("\r\n");
if(totalCnt == 1)
{
if(strcmp(&MultiSubCmd[0][0], "clean") == 0)
{
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[0] = 0;
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[1] = 0;
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[2] = 0;
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[3] = 0;
ShmChargerInfo->Control.DebugCtrl.bits.MsgEvComm = false;
printf("Clean All EvComm Msg Flag\r\n");
printf("Disable MsgEvComm Flag Debug\r\n\r\n");
return;
}
}
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ evmsg [reg] [enable 0-1]\r\n\r\n");
return;
}
bool find = false;
int reg = 0, enable = 0;
if(strcmp(&MultiSubCmd[0][0], "0x") == EQUAL && strlen(&MultiSubCmd[0][0]) > 2)
{
reg = (int)strtol(&MultiSubCmd[0][0], NULL, 16);
}
else
{
reg = atoi(&MultiSubCmd[0][0]);
}
enable = atoi(&MultiSubCmd[1][0]);
if(enable > 1 || enable < 0)
{
printf("enable(%d) out of range\r\n\r\n", enable);
return;
}
if(reg >= _Reg_Dispenser_Model_Name && reg < _Reg_None)
{
find = true;
if(enable)
{
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[reg / 32] |= (1 << (reg % 32));
printf("Set EvComm Msg Flag: 0x%02X\r\n", reg);
}
else
{
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[reg / 32] &= ~(1 << (reg % 32));
printf("Clean EvComm Msg Flag: 0x%02X\r\n", reg);
}
}
else
{
if(strcmp(&MultiSubCmd[0][0], "all") == 0)
{
find = true;
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.bits.RegDbg_All = enable;
printf("%s EvComm All Msg Flag\r\n", enable ? "Enable" : "Disable");
}
}
if(find)
{
printf("EvCommMsg[0]: %08X\r\n", ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[0]);
printf("EvCommMsg[1]: %08X\r\n", ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[1]);
printf("EvCommMsg[2]: %08X\r\n", ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[2]);
printf("EvCommMsg[3]: %08X\r\n", ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[3]);
printf("\r\n");
if(ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[0] ||
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[1] ||
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[2] ||
ShmChargerInfo->Control.EvCommCtrl.MsgFlag.DebugVal[3])
{
if(!ShmChargerInfo->Control.DebugCtrl.bits.MsgEvComm)
{
printf("Enable MsgEvComm Flag Debug\r\n\r\n");
}
ShmChargerInfo->Control.DebugCtrl.bits.MsgEvComm = true;
}
else
{
if(ShmChargerInfo->Control.DebugCtrl.bits.MsgEvComm)
{
printf("Disable MsgEvComm Flag Debug\r\n\r\n");
}
ShmChargerInfo->Control.DebugCtrl.bits.MsgEvComm = false;
}
}
else
{
printf("reg: 0x%02X out of range\r\n", reg);
printf("\r\n");
}
}
void EvCommIdDebug(char *inputCmd, unsigned int opt)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
printf("\r\n");
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ evid [id] [enable 0-1]\r\n\r\n");
return;
}
int id = 0, enable = 0;
id = atoi(&MultiSubCmd[0][0]);
enable = atoi(&MultiSubCmd[1][0]);
if(enable > 1 || enable < 0)
{
printf("enable(%d) out of range\r\n\r\n", enable);
return;
}
if(id > 0 && id <= CONNECTOR_QUANTITY)
{
if(enable)
{
ShmChargerInfo->Control.EvCommCtrl.IdFlag.DebugVal |= (1 << id);
printf("Set EvComm ID %d Enable\r\n", id);
}
else
{
ShmChargerInfo->Control.EvCommCtrl.IdFlag.DebugVal &= ~(1 << id);
printf("Clean EvComm ID %d\r\n", id);
}
printf("EvComm ID: %08X\r\n", ShmChargerInfo->Control.EvCommCtrl.IdFlag.DebugVal);
printf("\r\n");
}
else
{
printf("id(%d) out of range\r\n\r\n", id);
}
}
bool SetModelName(char *modelName)
{
if(!IsCabinetModelNameLegal(modelName))
{
printf("Model Name: [%s] is Illegal\r\n", modelName);
return false;
}
memcpy((char *)&ShmSysConfigAndInfo->SysConfig.ModelName, modelName, MODELNAME_LENGTH);
printf("Set Model Name: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.ModelName);
return true;
}
bool SetSerialNumber(char *serialNumber)
{
if(!IsSerialNumberLegal(serialNumber))
{
printf("Serial Number: [%s] is Illegal\r\n", serialNumber);
return false;
}
memcpy((char *)&ShmSysConfigAndInfo->SysConfig.SerialNumber, serialNumber, SERIAL_NUMBER_LENGTH);
printf("Set Serial Number: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.SerialNumber);
return true;
}
bool SetSystemID(char *systemId)
{
if(!IsSystemIdLegal(systemId))
{
printf("System ID: [%s] is Illegal\r\n", systemId);
return false;
}
memcpy((char *)&ShmSysConfigAndInfo->SysConfig.SystemId, systemId, strlen(systemId));
printf("Set System ID: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.SystemId);
return true;
}
bool CleanSystemID(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.SystemId, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.SystemId));
printf("Clean System ID OK\r\n");
return true;
}
bool SetAuthorisationMode(char *mode)
{
bool disable = false;
if(strcmp(mode, "disable") == EQUAL)
{
disable = true;
}
else
{
if(strcmp(mode, "enable") != EQUAL)
{
printf("Authorisation Mode: [%s] is Illegal\r\n", mode);
printf(" [value] enable | disable\r\n");
return false;
}
}
ShmSysConfigAndInfo->SysConfig.AuthorisationMode = disable;
printf("Set Authorisation Mode: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.AuthorisationMode == 0 ? "Enable" : "Disable");
if(disable && ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID)
{
printf("AuthorisationMode Is Disable, AuthrizeByEVCCID Need To Set Disable\r\n");
ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID = false;
}
return true;
}
bool SetAuthrizeByEVCCID(char *isEVCCID)
{
bool enable = false;
if(strcmp(isEVCCID, "enable") == EQUAL)
{
enable = true;
}
else
{
if(strcmp(isEVCCID, "disable") != EQUAL)
{
printf("Authrize By EVCCID: [%s] is Illegal\r\n", isEVCCID);
printf(" [value] enable | disable\r\n");
return false;
}
}
if(enable && ShmSysConfigAndInfo->SysConfig.AuthorisationMode == 1)
{
printf("AuthorisationMode Is Disable, Reset AuthrizeByEVCCID To Disable\r\n");
enable = false;
}
ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID = enable;
printf("Set AuthrizeByEVCCID: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID ? "Enable" : "Disable");
return true;
}
bool SetQRCodeMadeMode(char *qrCodeMode)
{
bool customized = false;
if(strcmp(qrCodeMode, "customized") == EQUAL)
{
customized = true;
}
else
{
if(strcmp(qrCodeMode, "default") != EQUAL)
{
printf("QR Code Made Mode: [%s] is Illegal\r\n", qrCodeMode);
printf(" [value] default | customized\r\n");
return false;
}
}
ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode = customized;
printf("Set QRCodeMadeMode: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode ? "Customized" : "Default");
return true;
}
bool SetQRCodeContent(char *content)
{
if(strlen(content) >= sizeof(ShmSysConfigAndInfo->SysConfig.QRCodeContent))
{
printf("QR Code Content: [%s] is Out Of Length\r\n", content);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.QRCodeContent, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.QRCodeContent));
memcpy((char *)&ShmSysConfigAndInfo->SysConfig.QRCodeContent, content, strlen(content));
printf("Set QRCodeContent: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.QRCodeContent);
return true;
}
bool CleanQRCodeContent(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.QRCodeContent, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.QRCodeContent));
printf("Clean QRCode Content OK\r\n");
return true;
}
bool SetLEDIntensity(char *intensity)
{
int ledIntensity = _LED_INTENSITY_DARKEST;
char *strIntensity[] = {STR_DARKEST, STR_MEDIUM, STR_BRIGHTEST};
if(strcmp(intensity, "brightest") == EQUAL)
{
ledIntensity = _LED_INTENSITY_BRIGHTEST;
}
else if(strcmp(intensity, "medium") == EQUAL)
{
ledIntensity = _LED_INTENSITY_MEDIUM;
}
else if(strcmp(intensity, "darkest") != EQUAL)
{
printf("LED Intensity: [%s] is Illegal\r\n", intensity);
printf(" [value] darkest | medium | brightest\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity = ledIntensity;
printf("Set LED Intensity: [%s] OK\r\n", strIntensity[ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity]);
return true;
}
bool SetMaxChargingEnergy(char *energy)
{
int _energy = 0;
_energy = atoi(energy);
if(_energy < 0)
{
printf("MaxChargingEnergy: [%s] is Illegal\r\n", energy);
printf(" [value] > 0\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy = _energy;
printf("Set MaxChargingEnergy: [%d] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy);
return true;
}
bool SetMaxChargingPower(char *power)
{
int _power = 0;
_power = atoi(power);
if(_power < 0)
{
printf("MaxChargingEnergy: [%s] is Illegal\r\n", power);
printf(" [value] > 0\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.MaxChargingPower = _power;
printf("Set MaxChargingPower: [%d] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingPower);
return true;
}
bool SetMaxChargingCurrent(char *current)
{
int _current = 0;
_current = atoi(current);
if(_current < 0)
{
printf("MaxChargingEnergy: [%s] is Illegal\r\n", current);
printf(" [value] > 0\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent = _current;
printf("Set MaxChargingCurrent: [%d] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent);
return true;
}
bool SetMaxChargingDuration(char *duration)
{
int _duration = 0;
_duration = atoi(duration);
if(_duration < 0)
{
printf("MaxChargingDuration: [%s] is Illegal\r\n", duration);
printf(" [value] > 0\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.MaxChargingDuration = _duration;
printf("Set MaxChargingDuration: [%d] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingDuration);
return true;
}
bool SetMaxChargingSoc(char *soc)
{
int _soc = 0;
_soc = atoi(soc);
if(_soc < 0 || _soc > 100)
{
printf("MaxChargingSoc: [%s] is Illegal\r\n", soc);
printf(" [value] 0 ~ 100\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.MaxChargingSoc = _soc;
printf("Set MaxChargingSoc: [%d] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaxChargingSoc);
return true;
}
bool SetStopChargingByButton(char *btn)
{
bool enable = false;
if(strcmp(btn, "enable") == EQUAL)
{
enable = true;
}
else
{
if(strcmp(btn, "disable") != EQUAL)
{
printf("Stop Charging By Button: [%s] is Illegal\r\n", btn);
printf(" [value] enable | disable\r\n");
return false;
}
}
ShmSysConfigAndInfo->SysConfig.StopChargingByButton = enable;
printf("Set Stop Charging By Button: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.StopChargingByButton ? "Enable" : "Disable");
return true;
}
bool SetOfflinePolicy(char *policy)
{
int offlinePolicy = _OFFLINE_POLICY_LOCAL_LIST;
char *str_offline_policy[] = {"Local List", "Phihong RFID", "Free Charging", "No Charging"};
if(strcmp(policy, "free") == EQUAL)
{
offlinePolicy = _OFFLINE_POLICY_FREE_CHARGING;
}
else if(strcmp(policy, "nocharging") == EQUAL)
{
offlinePolicy = _OFFLINE_POLICY_NO_CHARGING;
}
else if(strcmp(policy, "local") != EQUAL)
{
printf("Offline Policy: [%s] is Illegal\r\n", policy);
printf(" [value] local | rfid | free | nocharging\r\n");
return false;
}
ShmSysConfigAndInfo->SysConfig.OfflinePolicy = offlinePolicy;
printf("Set Offline Policy: [%s] OK\r\n", str_offline_policy[ShmSysConfigAndInfo->SysConfig.OfflinePolicy]);
return true;
}
bool SetOcppServerURL(char *url)
{
if(strlen(url) >= sizeof(ShmSysConfigAndInfo->SysConfig.OcppServerURL))
{
printf("Ocpp Server URL: [%s] is Out Of Length\r\n", url);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.OcppServerURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.OcppServerURL));
strcpy((char *)&ShmSysConfigAndInfo->SysConfig.OcppServerURL, url);
printf("Set Ocpp Server URL: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.OcppServerURL);
return true;
}
bool CleanOcppServerURL(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.OcppServerURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.OcppServerURL));
printf("Clean Ocpp Server URL OK\r\n");
return true;
}
bool SetChargeBoxId(char *boxId)
{
if(strlen(boxId) >= sizeof(ShmSysConfigAndInfo->SysConfig.ChargeBoxId))
{
printf("Charge Box Id: [%s] is Out Of Length\r\n", boxId);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.ChargeBoxId, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.ChargeBoxId));
strcpy((char *)&ShmSysConfigAndInfo->SysConfig.ChargeBoxId, boxId);
printf("Set Charge Box Id: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
return true;
}
bool CleanChargeBoxId(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.ChargeBoxId, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.ChargeBoxId));
printf("Clean Charge Box Id OK\r\n");
return true;
}
bool SetChargePointVendor(char *vendor)
{
if(strlen(vendor) >= sizeof(ShmSysConfigAndInfo->SysConfig.chargePointVendor))
{
printf("Charge Point Vendor: [%s] is Out Of Length\r\n", vendor);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.chargePointVendor, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.chargePointVendor));
strcpy((char *)&ShmSysConfigAndInfo->SysConfig.chargePointVendor, vendor);
printf("Set Charge Point Vendor: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.chargePointVendor);
return true;
}
bool CleanChargePointVendor(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.chargePointVendor, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.chargePointVendor));
printf("Clean Charge Point Vendor OK\r\n");
return true;
}
bool SetOcppReceiptrURL(char *receipt)
{
if(strlen(receipt) >= sizeof(ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL))
{
printf("Ocpp Receiptr URL: [%s] is Out Of Length\r\n", receipt);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL));
strcpy((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, receipt);
printf("Set Ocpp Receiptr URL: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL);
return true;
}
bool CleanOcppReceiptrURL(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL));
printf("Clean Ocpp Receiptr URL OK\r\n");
return true;
}
bool SetMaintainServerURL(char *url)
{
if(strlen(url) >= sizeof(ShmSysConfigAndInfo->SysConfig.MaintainServerURL))
{
printf("Maintain Server URL: [%s] is Out Of Length\r\n", url);
return false;
}
memset((char *)&ShmSysConfigAndInfo->SysConfig.MaintainServerURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.MaintainServerURL));
strcpy((char *)&ShmSysConfigAndInfo->SysConfig.MaintainServerURL, url);
printf("Set Maintain Server URL: [%s] OK\r\n", ShmSysConfigAndInfo->SysConfig.MaintainServerURL);
return true;
}
bool CleanMaintainServerURL(void)
{
memset((char *)&ShmSysConfigAndInfo->SysConfig.MaintainServerURL, 0x00, sizeof(ShmSysConfigAndInfo->SysConfig.MaintainServerURL));
printf("Clean Maintain Server URL OK\r\n");
return true;
}
void FlashSetCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
bool find = false;
int actIndex = 0;
int maxLen = 20;
char strWriteItem[32][32] = {
"model", "sn", "sysid", "auth", "evccid", "qrmode", "qrcode", "led",
"energy", "power", "current", "time", "soc", "stopbtn", "policy", "backend",
"boxid", "vendor", "receipt", "maintain"};
bool (*writeFlashList[32])(char *) = {
&SetModelName, &SetSerialNumber, &SetSystemID, &SetAuthorisationMode,
&SetAuthrizeByEVCCID, &SetQRCodeMadeMode, &SetQRCodeContent, &SetLEDIntensity,
&SetMaxChargingEnergy, &SetMaxChargingPower, &SetMaxChargingCurrent, &SetMaxChargingDuration,
&SetMaxChargingSoc, &SetStopChargingByButton, &SetOfflinePolicy, &SetOcppServerURL,
&SetChargeBoxId, &SetChargePointVendor, &SetOcppReceiptrURL, &SetMaintainServerURL};
bool (*WriteFlashAct)(char *);
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
for(actIndex = 0; actIndex < maxLen; actIndex++)
{
if(strcmp((char *)&strWriteItem[actIndex][0], subMain) == 0)
{
find = true;
break;
}
}
if(find)
{
printf("\r\n");
WriteFlashAct = writeFlashList[actIndex];
WriteFlashAct(subSub);
printf("\r\n");
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ model [set] [cmd] [value]\r\n");
printf(" [cmd]");
for(actIndex = 0; actIndex < maxLen; actIndex++)
{
printf("%s%s", actIndex == 0 ? " " : " | ", &strWriteItem[actIndex][0]);
}
printf("\r\n\r\n");
}
void FlashCleanCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
bool find = false;
int actIndex = 0;
int maxLen = 7;
char strCleanItem[32][32] = {
"sysid", "qrcode", "backend", "boxid", "vendor", "receipt", "maintain"};
bool (*cleanFlashList[32])() = {
&CleanSystemID, &CleanQRCodeContent, &CleanOcppServerURL, &CleanChargeBoxId,
&CleanChargePointVendor, &CleanOcppReceiptrURL, &CleanMaintainServerURL};
bool (*CleanFlashAct)();
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
for(actIndex = 0; actIndex < maxLen; actIndex++)
{
if(strcmp((char *)&strCleanItem[actIndex][0], subMain) == 0)
{
find = true;
break;
}
}
if(find)
{
printf("\r\n");
CleanFlashAct = cleanFlashList[actIndex];
CleanFlashAct();
printf("\r\n");
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ model [clean] [cmd]\r\n");
printf(" [cmd]");
for(actIndex = 0; actIndex < maxLen; actIndex++)
{
printf("%s%s", actIndex == 0 ? " " : " | ", &strCleanItem[actIndex][0]);
}
printf("\r\n\r\n");
}
void FlashWriteCmd(char *inputCmd, unsigned int opt)
{
if(strcmp(inputCmd, "now") == EQUAL)
{
printf("\r\n");
printf("Write Flash Immediately\r\n\r\n");
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashEnable = true;
ShmChargerInfo->Control.SysCtrl.bits.WriteFlashImmediately = true;
}
else
{
printf("\r\n");
printf("Write Flash Command Not Available\r\n\r\n");
}
}
void FlashCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
if(strcmp(subMain, "set") == EQUAL)
{
FlashSetCmd(subSub, opt);
return;
}
if(strcmp(subMain, "write") == EQUAL)
{
FlashWriteCmd(subSub, opt);
return;
}
if(strcmp(subMain, "clean") == EQUAL)
{
FlashCleanCmd(subSub, opt);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ flash [set | write | clean] [cmd] [...]\r\n\r\n");
}
void EnableAbnormalRelay(void)
{
ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay = true;
printf("\r\n");
printf("Enable Abnormal Relay Cmd\r\n\r\n");
}
void DisableAbnormalRelay(void)
{
ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay = NO;
printf("\r\n");
printf("Disable Abnormal Relay Cmd\r\n\r\n");
}
void RelayWriteOutputCmd(char *inputCmd)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
int value = 0;
value = atoi(&subMain[0]);
if(value > 0 && value <= MAX_GUN_QUANTITY && (strcmp(subSub, "on") == 0 || strcmp(subSub, "off") == 0))
{
int OnOff = 0;
if(!ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay)
{
EnableAbnormalRelay();
}
OnOff = strcmp(subSub, "on") == 0 ? YES : NO;
ShmChargerInfo->PsuGrouping.OutputRelayConfig[value - 1].bits.Output_N = OnOff;
ShmChargerInfo->PsuGrouping.OutputRelayConfig[value - 1].bits.Output_P = OnOff;
printf("\r\n");
printf("Write Gun %d OutputRelay %s\r\n\r\n", value, subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ relay [write] [output] [value 1-4] [on | off]\r\n\r\n");
}
void RelayWriteParallelCmd(char *inputCmd)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
int value = 0;
value = atoi(&subMain[0]);
if(value > 0 && value <= PARALLEL_RELAY_COUNT && (strcmp(subSub, "on") == 0 || strcmp(subSub, "off") == 0))
{
int OnOff = 0;
if(!ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay)
{
EnableAbnormalRelay();
}
OnOff = strcmp(subSub, "on") == 0 ? YES : NO;
if(OnOff)
{
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue |= 1 << (value - 1);
}
else
{
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue &= ~(1 << (value - 1));
}
printf("\r\n");
printf("Write ParallelRelay %d %s\r\n\r\n", value, subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ relay [write] [parallel] [value 1-6] [on | off]\r\n\r\n");
}
void AbnormalRelayCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
if(strcmp(subMain, "enable") == 0)
{
EnableAbnormalRelay();
return;
}
if(strcmp(subMain, "disable") == 0)
{
DisableAbnormalRelay();
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ relay [abnormal] [enable | disable]\r\n\r\n");
}
void RelayWriteCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
if(strcmp(subMain, "output") == 0)
{
RelayWriteOutputCmd(subSub);
return;
}
if(strcmp(subMain, "parallel") == 0)
{
RelayWriteParallelCmd(subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ relay [write] [output | parallel] [value] [on | off]\r\n\r\n");
}
void RelayReadCmd(char *inputCmd, unsigned int opt)
{
}
void RelayStatusCmd(char *inputCmd, unsigned int opt)
{
}
void OutputRelayAutoTest(void)
{
int MaxGunCount = 0;
struct timespec _Loop_time;
int time = 0;
MaxGunCount = ShmChargerInfo->Control.MaxConnector;
for(int i = 0; i < MaxGunCount; i++)
{
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N = YES;
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N == ShmChargerInfo->PsuGrouping.OutputRelayConfirmed[i].bits.Output_N)
{
printf("Gun %d Output Relay N Driving Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Gun %d Output Relay N Driving Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P = YES;
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P == ShmChargerInfo->PsuGrouping.OutputRelayConfirmed[i].bits.Output_P)
{
printf("Gun %d Output Relay P Driving Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Gun %d Output Relay P Driving Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N = NO;
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N == ShmChargerInfo->PsuGrouping.OutputRelayConfirmed[i].bits.Output_N)
{
printf("Gun %d Output Relay N Welding Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Gun %d Output Relay N Welding Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P = NO;
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P == ShmChargerInfo->PsuGrouping.OutputRelayConfirmed[i].bits.Output_P)
{
printf("Gun %d Output Relay P Welding Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Gun %d Output Relay P Welding Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
}
}
void ParallelRelayAutoTest(void)
{
int ParallelRelayCount = 0;
struct timespec _Loop_time;
int time = 0;
if(ShmChargerInfo->Control.MaxConnector == GENERAL_GUN_QUANTITY)
{
ParallelRelayCount = ShmChargerInfo->Control.SysCtrl.bits.Enable6ParallelRelay == 1 ? PARALLEL_RELAY_COUNT : 3;
}
else
{
ParallelRelayCount = 1;
}
for(int i = 0; i < ParallelRelayCount; i++)
{
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue |= 1 << i;
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue == ShmChargerInfo->PsuGrouping.ParallelRelayConfirmed.CtrlValue)
{
printf("Location %d Parallel Relay Driving Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Location %d Parallel Relay Driving Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue &= ~(1 << i);
GetClockTime(&_Loop_time);
while(1)
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue == ShmChargerInfo->PsuGrouping.ParallelRelayConfirmed.CtrlValue)
{
printf("Location %d Parallel Relay Welding Check OK\r\n", i + 1);
break;
}
if(time >= 3000)
{
printf("Location %d Parallel Relay Welding Check Fault\r\n", i + 1);
break;
}
usleep(10000);
}
}
}
void RelayAutoTest(char *inputCmd)
{
if(strcmp(inputCmd, "now") != EQUAL)
{
printf("\r\n");
printf("Input cmd fail ------ relay [autotest] [now]\r\n\r\n");
return;
}
if(!ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay)
{
EnableAbnormalRelay();
}
OutputRelayAutoTest();
ParallelRelayAutoTest();
printf("Relay Auto Test Completed\r\n");
DisableAbnormalRelay();
}
void RelayAllOn(void)
{
int MaxGunCount = 0;
MaxGunCount = ShmChargerInfo->Control.MaxConnector;
for(int i = 0; i < MaxGunCount; i++)
{
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N = YES;
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P = YES;
}
int ParallelRelayCount = 0;
if(ShmChargerInfo->Control.MaxConnector == GENERAL_GUN_QUANTITY)
{
ParallelRelayCount = ShmChargerInfo->Control.SysCtrl.bits.Enable6ParallelRelay == 1 ? PARALLEL_RELAY_COUNT : 3;
}
else
{
ParallelRelayCount = 1;
}
for(int i = 0; i < ParallelRelayCount; i++)
{
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue |= 1 << i;
}
}
void RelayAllOff(void)
{
int MaxGunCount = 0;
MaxGunCount = ShmChargerInfo->Control.MaxConnector;
for(int i = 0; i < MaxGunCount; i++)
{
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_N = NO;
ShmChargerInfo->PsuGrouping.OutputRelayConfig[i].bits.Output_P = NO;
}
int ParallelRelayCount = 0;
if(ShmChargerInfo->Control.MaxConnector == GENERAL_GUN_QUANTITY)
{
ParallelRelayCount = ShmChargerInfo->Control.SysCtrl.bits.Enable6ParallelRelay == 1 ? PARALLEL_RELAY_COUNT : 3;
}
else
{
ParallelRelayCount = 1;
}
for(int i = 0; i < ParallelRelayCount; i++)
{
ShmChargerInfo->PsuGrouping.ParallelRelayConfig.CtrlValue &= ~(1 << i);
}
}
void RelayLongTimeTest(char *inputCmd)
{
int time = 0;
struct timespec _Loop_time;
bool keepRun = true;
bool _relayOn = false;
if(strcmp(inputCmd, "now") != EQUAL)
{
printf("\r\n");
printf("Input cmd fail ------ relay [timetest] [now]\r\n\r\n");
return;
}
if(!ShmChargerInfo->Control.RelayCtrl.bits.AbnormalRelay)
{
EnableAbnormalRelay();
}
printf("Relay Long Time Test Start\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 10000)
{
if(!_relayOn)
{
printf("Set Relay All On\r\n");
RelayAllOn();
_relayOn = true;
}
else
{
printf("Set Relay All Off\r\n");
RelayAllOff();
_relayOn = false;
}
GetClockTime(&_Loop_time);
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
DisableAbnormalRelay();
}
void RelayCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
if(strcmp(subMain, "abnormal") == EQUAL)
{
AbnormalRelayCmd(subSub, opt);
return;
}
if(strcmp(subMain, "write") == EQUAL)
{
RelayWriteCmd(subSub, opt);
return;
}
if(strcmp(subMain, "read") == EQUAL)
{
RelayReadCmd(subSub, opt);
return;
}
if(strcmp(subMain, "status") == EQUAL)
{
RelayStatusCmd(subSub, opt);
return;
}
if(strcmp(subMain, "autotest") == EQUAL)
{
RelayAutoTest(subSub);
return;
}
if(strcmp(subMain, "longtime") == EQUAL)
{
RelayLongTimeTest(subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ relay [abnormal | write | read | autotest] [...]\r\n\r\n");
}
// Sys CurrentRate: [XX.XX]
// TimeOfDayPrice: [00-01: XX.XX] [01-02: XX.XX] [02-03: XX.XX] [03-04: XX.XX] [04-05: XX.XX] [05-06: XX.XX]
// : [06-07: XX.XX] [07-08: XX.XX] [08-09: XX.XX] [09-10: XX.XX] [10-11: XX.XX] [11-12: XX.XX]
// : [12-13: XX.XX] [13-14: XX.XX] [14-15: XX.XX] [15-16: XX.XX] [16-17: XX.XX] [17-18: XX.XX]
// : [18-19: XX.XX] [19-20: XX.XX] [20-21: XX.XX] [21-22: XX.XX] [22-23: XX.XX] [23-24: XX.XX]
int ShowSysPriceInfo(void)
{
int showLine = 1;
char priceString[1024];
//************************************************************************************************
printf(" Sys CurrentRate: [%5.2f]\r\n", ShmChargerInfo->PriceAndReceiptInfo.CurrentRate);
if(ShmChargerInfo->Control.CustomerCode == _CUSTOMER_CODE_TCC)
{
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
for(int i = 0; i < 6; i++)
{
char strTemp[64];
sprintf(strTemp, " [%02d-%02d: %5.2f]", i, i + 1, ShmChargerInfo->PriceAndReceiptInfo.TimeOfDayPricing[i]);
strcat(priceString, strTemp);
}
printf(" TimeOfDayPrice:%s\r\n", priceString);
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
for(int i = 6; i < 12; i++)
{
char strTemp[64];
sprintf(strTemp, " [%02d-%02d: %5.2f]", i, i + 1, ShmChargerInfo->PriceAndReceiptInfo.TimeOfDayPricing[i]);
strcat(priceString, strTemp);
}
printf(" :%s\r\n", priceString);
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
for(int i = 12; i < 18; i++)
{
char strTemp[64];
sprintf(strTemp, " [%02d-%02d: %5.2f]", i, i + 1, ShmChargerInfo->PriceAndReceiptInfo.TimeOfDayPricing[i]);
strcat(priceString, strTemp);
}
printf(" :%s\r\n", priceString);
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
for(int i = 18; i < 24; i++)
{
char strTemp[64];
sprintf(strTemp, " [%02d-%02d: %5.2f]", i, i + 1, ShmChargerInfo->PriceAndReceiptInfo.TimeOfDayPricing[i]);
strcat(priceString, strTemp);
}
printf(" :%s\r\n", priceString);
showLine += 4;
}
return showLine;
}
// Gun X UserPrice: [%s]
// Receipt: [%s]
int ShowGunPriceInfo(int gun)
{
int showLine = 2;
char priceString[1024];
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
if(strlen(&ShmChargerInfo->PriceAndReceiptInfo.UserPriceString[gun][0]) > 0)
{
strcpy(priceString, &ShmChargerInfo->PriceAndReceiptInfo.UserPriceString[gun][0]);
}
else
{
strcpy(priceString, "NULL");
}
printf(" Gun %d UserPrice: [%s]\r\n", gun + 1, priceString);
//************************************************************************************************
memset(priceString, 0x00, sizeof(priceString));
if(strlen(&ShmChargerInfo->PriceAndReceiptInfo.ReceiptUrl[gun][0]) > 0)
{
strcpy(priceString, &ShmChargerInfo->PriceAndReceiptInfo.ReceiptUrl[gun][0]);
}
else
{
strcpy(priceString, "NULL");
}
printf(" Receipt: [%s]\r\n", priceString);
return showLine;
}
void ShowPrice(char *inputCmd, unsigned int opt)
{
int totalLine = 0;
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(1, totalLine);
}
totalLine = 0;
printf("\r\n");
totalLine += ShowSysPriceInfo() + 1;
printf("\r\n");
totalLine += 1;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
totalLine += ShowGunPriceInfo(i);
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void SetOccupancyNotifyDisplay(char *inputCmd)
{
int gun = 0;
float fee = 0;
int totalCnt = 0;
char *str_occupancy_status[] = {STR_NO_OCCUPANCY, STR_SYNC_OCCUPANCY, STR_OCCUPIED, STR_REQUEST_FEE, STR_WAIT_TO_PAY, STR_PAID_ONLINE_OK, STR_PAID_ONLINE_FAIL};
char _sn[37];
char cmdBuf[32];
struct timeb nowTime;
struct tm *tm;
memset(_sn, 0x00, sizeof(_sn));
totalCnt = GetSubCommand(inputCmd);
if(totalCnt == 3)
{
gun = atoi(&MultiSubCmd[0][0]);
if(gun <= 0 || gun > GENERAL_GUN_QUANTITY)
{
printf("\r\n");
printf("Gun [%s] out of range\r\n\r\n", &MultiSubCmd[0][0]);
return;
}
strncpy(_sn, &MultiSubCmd[1][0], strlen(&MultiSubCmd[1][0]) >= (sizeof(_sn) - 1) ? (sizeof(_sn) - 1) : strlen(&MultiSubCmd[1][0]));
fee = atof(&MultiSubCmd[2][0]);
if(fee <= 0)
{
printf("\r\n");
printf("Fee [%s] out of range\r\n\r\n", &MultiSubCmd[2][0]);
return;
}
ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].Status = _Parking_Occupied;
memcpy(ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].OccupancyBill.Sn, _sn, sizeof(_sn));
ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].OccupancyBill.Fee = fee;
ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].OccupancyBill.Duration = 5;
ftime(&nowTime);
tm = localtime(&nowTime.time);
// StartTime: [2022/09/27 13:50]
sprintf(cmdBuf, "%04d//%02d//%02d %02d:%02d",
tm->tm_year + 1900,
tm->tm_mon + 1,
tm->tm_mday,
tm->tm_hour,
tm->tm_min);
memcpy(ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].OccupancyBill.StartTime, cmdBuf, sizeof(cmdBuf));
ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].OccupancyReq.bits.SelfReq = true;
printf("\r\n");
printf("Set Gun [%s] [%s], SN: [%s], Fee: [%.2f]\r\n\r\n", &MultiSubCmd[0][0], str_occupancy_status[_Parking_Occupied], _sn, fee);
return;
}
printf("\r\n");
printf("Input cmd fail ------ parking notify display [gun 1-4] [sn] [fee]\r\n\r\n");
}
void SetOccupancyNotifyCancel(char *inputCmd)
{
int gun = 0;
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
char *str_occupancy_status[] = {STR_NO_OCCUPANCY, STR_SYNC_OCCUPANCY, STR_OCCUPIED, STR_REQUEST_FEE, STR_WAIT_TO_PAY, STR_PAID_ONLINE_OK, STR_PAID_ONLINE_FAIL};
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
gun = atoi(subMain);
if(gun <= 0 || gun > GENERAL_GUN_QUANTITY)
{
printf("\r\n");
printf("Gun [%s] out of range\r\n\r\n", subMain);
return;
}
ShmChargerInfo->AllBill.OccupancyInfo[gun - 1].Status = _Parking_NoOccupancy;
printf("\r\n");
printf("Set Gun [%s] [%s]\r\n\r\n", subMain, str_occupancy_status[_Parking_NoOccupancy]);
return;
}
printf("\r\n");
printf("Input cmd fail ------ parking notify cancel [gun 1-4]\r\n\r\n");
}
void OccupancyNotifyCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 2)
{
if(strcmp(subMain, "display") == 0)
{
SetOccupancyNotifyDisplay(subSub);
return;
}
if(strcmp(subMain, "cancel") == 0)
{
SetOccupancyNotifyCancel(subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ parking notify [display | cancel] [gun 1-4] [...]\r\n\r\n");
}
void OccupancySetCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
float _price = 0;
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
_price = atof(subMain);
if(_price > 0)
{
ShmChargerInfo->CabinetMiscValue.ParkingPrice = _price;
for(int i = 0; i < MAX_DISPENSER_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
{
ShmChargerInfo->DispenserMiscReq[i].bits.ParkingPrice = true;
printf("Set Dispenser %d Parking price [%s]\r\n\r\n", i + 1, subMain);
}
}
return;
}
else
{
printf("\r\n");
printf("Parking price [%s] out of range\r\n\r\n", subMain);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ parking set [price]\r\n\r\n");
}
void OccupancyCmd(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) >= 2)
{
if(strcmp(subMain, "notify") == EQUAL)
{
OccupancyNotifyCmd(subSub, opt);
return;
}
if(strcmp(subMain, "set") == EQUAL)
{
OccupancySetCmd(subSub, opt);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ parking [set | notify] [...]\r\n\r\n");
}
// Status SN Fee StartTime Duration
// 4fb5beab-c1dc-4fa8-8f80-aee1a26df705 XXXXX.XX
// Gun 1 NoOccupancy XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX.XX YYYY/MM/DD HH:MM XXXX
int ShowOccupancyInfo(int gun)
{
int showLine = 1;
char *str_occupancy_status[] = {STR_NO_OCCUPANCY, STR_SYNC_OCCUPANCY, STR_OCCUPIED, STR_REQUEST_FEE, STR_WAIT_TO_PAY, STR_PAID_ONLINE_OK, STR_PAID_ONLINE_FAIL};
char _sn[37], _time[32];
if(ShmChargerInfo->AllBill.OccupancyInfo[gun].Status == _Parking_NoOccupancy)
{
sprintf(_sn, " N/A ");
}
else
{
sprintf(_sn, "%s", ShmChargerInfo->AllBill.OccupancyInfo[gun].OccupancyBill.Sn);
}
if(ShmChargerInfo->AllBill.OccupancyInfo[gun].Status == _Parking_WaitToPay)
{
sprintf(_time, "%s", ShmChargerInfo->AllBill.OccupancyInfo[gun].OccupancyBill.StartTime);
}
else
{
sprintf(_time, " N/A ");
}
//************************************************************************************************
printf(" Gun %d %11s %36s %8.2f %16s %4d\r\n",
gun + 1,
str_occupancy_status[ShmChargerInfo->AllBill.OccupancyInfo[gun].Status],
_sn,
ShmChargerInfo->AllBill.OccupancyInfo[gun].OccupancyBill.Fee,
_time,
ShmChargerInfo->AllBill.OccupancyInfo[gun].OccupancyBill.Duration
);
return showLine;
}
void ShowOccupancy(char *inputCmd, unsigned int opt)
{
int totalLine = 0;
bool keepRun = false;
bool reflash = false;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
printf("\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash)
{
ConsoleReflash(1, 2);
ConsoleReflash(CONNECTOR_QUANTITY, 1);
}
printf("OccupancyPrice: [%.2f]\r\n", ShmChargerInfo->CabinetMiscValue.ParkingPrice);
printf(" Status SN Fee StartTime Duration\r\n");
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
totalLine += ShowOccupancyInfo(i);
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
void SetCustomizedFlag(int shift, bool enable)
{
if(enable)
{
ShmChargerInfo->Control.CustomizedInfo.Flag.CtrlValue |= (1 << shift);
}
else
{
ShmChargerInfo->Control.CustomizedInfo.Flag.CtrlValue &= ~(1 << shift);
}
}
// super customized standby [enable/disable]
// super customized tccstandby [enable/disable]
// super customized standbyfast [enable/disable]
// super customized freestandby [enable/disable]
// super customized tilt [enable/disable]
void SetCustomizedCmd(char *inputCmd)
{
int totalCnt = 0, maxPara = 0;
maxPara = 2;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt != maxPara)
{
printf("Input cmd fail ------ super [customized] [disstandby | tccstandby | standbyfast | cstandby | tilt] [enable | disable]\r\n\r\n");
return;
}
int maxCustomized = 5;
int shift = 0;
bool enable = false, find = false;;
enable = strcmp(&MultiSubCmd[1][0], "enable") == EQUAL ? true : false;
char *str_customized[] = {"disstandby", "tccstandby", "standbyfast", "freestandby", "tilt"};
for(int i = 0; i < maxCustomized; i++)
{
if(strcmp(&MultiSubCmd[0][0], str_customized[i]) == EQUAL)
{
shift = i;
find = true;
break;
}
}
if(find)
{
SetCustomizedFlag(shift, enable);
printf("\r\n");
printf("%s %s customized flag\r\n\r\n", enable ? "Enable" : "Disable", str_customized[shift]);
return;
}
printf("\r\n");
printf("Input cmd fail ------ super [customized] [disstandby | tccstandby | standbyfast | cstandby | tilt] [enable | disable]\r\n\r\n");
}
void TiltSensorTrigger(void)
{
ShmChargerInfo->Control.CustomizedInfo.TiltSensorStep = _TILT_SENSOR_NONE;
printf("\r\n");
printf("Reset tilt sensor step\r\n\r\n");
}
void TiltSensorCmd(char *inputCmd)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
if(strcmp(subMain, "test") == 0)
{
TiltSensorTrigger();
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ super [tilt] [test]\r\n\r\n");
}
void SetStandbyTime(int time)
{
if(time != 0)
{
ShmChargerInfo->Control.CustomizedInfo.StandbyTime = time;
printf("\r\n");
printf("Set standby time [%d] (s)\r\n\r\n", ShmChargerInfo->Control.CustomizedInfo.StandbyTime);
}
else
{
printf("\r\n");
printf("Unavailable value, standby time [%d] (s)\r\n\r\n", ShmChargerInfo->Control.CustomizedInfo.StandbyTime);
}
}
void StandbyTimeCmd(char *inputCmd)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
int _time = atoi(subMain);
SetStandbyTime(_time);
return;
}
printf("\r\n");
printf("Input cmd fail ------ super [standby] [value(seconds)]\r\n\r\n");
}
void DiagnosticsEnable(void)
{
ShmChargerInfo->Control.Diagnostics.DiagnosticsType = DIAGNOSTICS_TYPE_ALL;
printf("\r\n");
printf("Dispenser Diagnostics Enable\r\n\r\n");
}
void DiagnosticsCmd(char *inputCmd)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) == 1)
{
if(strcmp(subMain, "enable") == 0)
{
DiagnosticsEnable();
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ super [diagnostics] [enable]\r\n\r\n");
}
void SuperMode(char *inputCmd, unsigned int opt)
{
char subMain[MAX_SUB_CMD_LENGTH];
char subSub[MAX_SUB_CMD_LENGTH];
memset(subMain, 0x00, sizeof(subMain));
memset(subSub, 0x00, sizeof(subSub));
if(MainAndSubCommandParsing(inputCmd, subMain, subSub) >= 1)
{
if(strcmp(subMain, "customized") == 0)
{
SetCustomizedCmd(subSub);
return;
}
if(strcmp(subMain, "tilt") == 0)
{
TiltSensorCmd(subSub);
return;
}
if(strcmp(subMain, "standby") == 0)
{
StandbyTimeCmd(subSub);
return;
}
if(strcmp(subMain, "diagnostics") == 0)
{
DiagnosticsCmd(subSub);
return;
}
}
printf("\r\n");
printf("Input cmd fail ------ super [customized | tilt | standby | diagnostics] [...]\r\n\r\n");
}
int ShowPsuCount(void)
{
int line = 0;
for(int i = 0; i < MAX_GROUP_QUANTITY; i++)
{
printf("Group Index = %d, Module Count = %2d\r\n", i, ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity);
line++;
}
return line;
}
int ShowPsuVersion(void)
{
int line = 0;
for(int i = 0; i < ShmPsuData->SystemInitialPsuQuantity; i++)
{
printf("Psu Index = %2d, PriVersion = %s, SecVersion = %s\r\n",
i, ShmPsuData->PsuVersion[i].FwPrimaryVersion, ShmPsuData->PsuVersion[i].FwSecondVersion);
line++;
}
for(int i = 0; i < ShmPsuData->GroupCount; i++)
{
for (int j = 0; j < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; j++)
{
printf("Group Index = %d, Psu Index = %2d, Version = %s\r\n",
i, j, ShmPsuData->PsuGroup[i].PsuModule[j].FwVersion);
line++;
}
}
return line;
}
int ShowPsuCap(void)
{
int line = 0;
for(int i = 0; i < ShmPsuData->GroupCount; i++)
{
printf("Group Index = %d, MaxCur = %4d.%d A, Power = %d kW\r\n",
i,
(ShmPsuData->PsuGroup[i].GroupAvailableCurrent / 10),
(ShmPsuData->PsuGroup[i].GroupAvailableCurrent % 10),
(ShmPsuData->PsuGroup[i].GroupAvailablePower / 10));
line++;
}
return line;
}
int ShowPsuInput(void)
{
int line = 0;
for(int i = 0; i < ShmPsuData->GroupCount; i++)
{
for(byte count = 0; count < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; count++)
{
printf("Group[%d] Index = %2d, VolR = %d, VolS = %d, VolT = %d\r\n",
i, count,
ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL1,
ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL2,
ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL3);
line++;
}
}
return line;
}
int ShowPsuOutput(void)
{
int line = 0;
for(int i = 0; i < ShmPsuData->GroupCount; i++)
{
printf("Group Index = %d, OutputV = %4d.%d V, OutputC = %4d.%d A\r\n",
i,
(ShmPsuData->PsuGroup[i].GroupPresentOutputVoltage / 10),
(ShmPsuData->PsuGroup[i].GroupPresentOutputVoltage % 10),
(ShmPsuData->PsuGroup[i].GroupPresentOutputCurrent / 10),
(ShmPsuData->PsuGroup[i].GroupPresentOutputCurrent % 10));
line++;
}
return line;
}
int ShowPsuGroupInfo(int group)
{
if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
{
printf(" G-%d %2d %4d.%d V %4d.%d A %4d kW",
group + 1,
ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity,
(ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10),
(ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage % 10),
(ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent / 10),
(ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent % 10),
(ShmPsuData->PsuGroup[group].GroupPresentOutputPower / 10));
printf(" %4d V %4d A %4d A %4d kW",
(ShmPsuGrouping->GroupOutput[group].GTargetVoltage / 10),
(ShmPsuGrouping->GroupOutput[group].GTargetCurrent / 10),
(ShmPsuData->PsuGroup[group].GroupAvailableCurrent / 10),
(ShmPsuData->PsuGroup[group].GroupAvailablePower / 10));
printf(" | %d%d%d%d | %d%d%d%d\r\n",
ShmChargerInfo->PsuGrouping.GroupPsuStatus_OR[group].bits.Lock,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_OR[group].bits.Alarm,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_OR[group].bits.Fault,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_OR[group].bits.Output,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_AND[group].bits.Lock,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_AND[group].bits.Alarm,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_AND[group].bits.Fault,
ShmChargerInfo->PsuGrouping.GroupPsuStatus_AND[group].bits.Output);
}
else
{
printf(" G-%d %2d N/A N/A N/A N/A N/A\r\n", group + 1, ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity);
}
return 1;
}
int ShowSinglePsuInfo(int psu_index)
{
int group = 0, gIndex = 0;
unsigned int _power = 0;
group = ShmPsuPosition->PsuAddressInfo[psu_index].GroupNo;
gIndex = ShmPsuPosition->PsuAddressInfo[psu_index].GIndex;
printf(" %2d %2d %4d.%d V %4d.%d A %4d kW %4d A %4d kW",
gIndex + 1,
psu_index,
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].PresentOutputVoltage / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].PresentOutputVoltage % 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].PresentOutputCurrent / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].PresentOutputCurrent % 10),
_power,
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].IAvailableCurrent / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].AvailablePower / 10));
printf(" %3d.%d V %3d.%d V %3d.%d V",
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL1 / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL1 % 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL2 / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL2 % 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL3 / 10),
(ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL3 % 10));
printf(" | %d%d%d%d",
ShmPsuPosition->SinglePsuStatus[psu_index].bits.Lock,
ShmPsuPosition->SinglePsuStatus[psu_index].bits.Alarm,
ShmPsuPosition->SinglePsuStatus[psu_index].bits.Fault,
ShmPsuPosition->SinglePsuStatus[psu_index].bits.Output);
printf("\r\n");
return 1;
}
// Group Psu Out_Vol Out_Cur Out_Pow TargetV TargetC Ava_Cur Ava_Pow Ambient Liq_In_Out DD_In 1 & 2 DD_Out 1 & 2 OR_LAFO AND_LAFO InVol L1 InVol L2 InVol L3
// G-X 4 XXXX.X V XXXX.X A XXXX kW XXXX V XXXX A XXXX A XXXX kW | XXXX | XXXX
// G-X 0 N/A N/A N/A N/A N/A
// X 0 XXXX.X V XXXX.X A XXXX kW XXXX A XXXX kW XXXX XXXX / XXXX XXXX / XXXX XXXX / XXXX | XXXX | XXXX XXX.X V XXX.X V XXX.X V
// Group Psu Out_Vol Out_Cur Out_Pow TargetV TargetC Ava_Cur Ava_Pow InVol L1 InVol L2 InVol L3 OR_LAFO AND_LAFO
// G-X 4 XXXX.X V XXXX.X A XXXX kW XXXX V XXXX A XXXX A XXXX kW | XXXX | XXXX
// G-X 0 N/A N/A N/A N/A N/A N/A N/A
// X 0 XXXX.X V XXXX.X A XXXX kW XXXX A XXXX kW XXX.X V XXX.X V XXX.X V | XXXX | XXXX
int ShowPsuInfo(void)
{
int line = 1;
//printf(" Group Psu Out_Vol Out_Cur Out_Pow Ava_Cur Ava_Pow InVol L1 InVol L2 InVol L3 OR_LAFO AND_LAFO\r\n");
printf(" Group Psu Out_Vol Out_Cur Out_Pow TargetV TargetC Ava_Cur Ava_Pow InVol L1 InVol L2 InVol L3 OR_LAFO AND_LAFO\r\n");
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
line += ShowPsuGroupInfo(i);
if(ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity > 0)
{
for(int j = 0; j < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; j++)
{
int psu_index = ShmPsuPosition->GroupLocationInfo[i].PsuIndex[j];
line += ShowSinglePsuInfo(psu_index);
}
}
}
return line;
}
int ShowSinglePsuTemperature(int psu_index)
{
int group = 0, gIndex = 0;
group = ShmPsuPosition->PsuAddressInfo[psu_index].GroupNo;
gIndex = ShmPsuPosition->PsuAddressInfo[psu_index].GIndex;
int CriticalTemp1 = 0, CriticalTemp2 = 0, CriticalTemp3 = 0, InletTemp = 0, OutletTemp = 0, InletTemp_1 = 0, InletTemp_2 = 0;
CriticalTemp1 = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp1 - 60;
CriticalTemp2 = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp2 - 60;
CriticalTemp3 = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp3 - 60;
InletTemp = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].InletTemp - 60;
OutletTemp = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].OutletTemp - 60;
InletTemp_1 = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].InletTemp_1 - 60;
InletTemp_2 = (int)ShmPsuData->PsuGroup[group].PsuModule[gIndex].InletTemp_2 - 60;
printf(" %d %2d %4d %4d / %4d %4d / %4d %4d / %4d\r\n",
group, psu_index, CriticalTemp1, InletTemp, OutletTemp, InletTemp_1, InletTemp_2, CriticalTemp2, CriticalTemp3);
return 1;
}
// PFC & DD
// Group Psu Ambi Liq_In_Out DD_In 1 & 2 DD_Out 1 & 2
// X XX XXXX XXXX / XXXX XXXX / XXXX XXXX / XXXX
int ShowPsuTemperature(void)
{
int line = 2;
printf(" PFC & DD\r\n");
printf(" Group Psu Ambi Liq_In_Out DD_In 1 & 2 DD_Out 1 & 2\r\n");
for(int i = 0; i < MAX_GROUP_QUANTITY; i++)
{
if(ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity > 0)
{
for(int j = 0; j < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; j++)
{
int psu_index = ShmPsuPosition->GroupLocationInfo[i].PsuIndex[j];
line += ShowSinglePsuTemperature(psu_index);
}
}
}
return line;
}
void SetPsuIndication(int psuIndex)
{
if(psuIndex >= MAX_PSU_MODULE_QUANTITY)
{
printf("psu index(%d) over range(%d)\r\n", psuIndex, MAX_PSU_MODULE_QUANTITY);
return;
}
if(ShmChargerInfo->Control.LibCtrl.bits.InfyPwrLib)
{
ShmPsuPosition->SingleInfyPwrState[psuIndex].InfyPwrStateFlag.bits.Indicated = true;
printf("Set Psu[%2d] Led Blinking\r\n", psuIndex);
}
if(ShmChargerInfo->Control.LibCtrl.bits.PhPwrLib)
{
printf("PhPwer not support this function\r\n");
}
}
void PsuCmd(char *inputCmd, unsigned int opt)
{
bool keepRun = false;
bool reflash = false;
int reflashLine = 0;
int time = 0;
struct timespec _Loop_time;
if((opt & OPTION_REFLASH) || (opt & OPTION_LOOP) > 0)
{
keepRun = true;
}
int totalCnt = 0, maxPara = 0;
maxPara = 1;
totalCnt = GetSubCommand(inputCmd);
if(totalCnt < maxPara)
{
printf("Input cmd fail ------ psu [count | ver | cap | input | output | info | temp | indi]\r\n\r\n");
return;
}
printf("\r\n");
do
{
time = GetTimeoutValue(_Loop_time) / mSEC_VAL;
if(time >= 1000)
{
if(reflash && reflashLine > 0)
{
ConsoleReflash(1, reflashLine);
}
if(strcmp(&MultiSubCmd[0][0], "info") == EQUAL)
{
reflashLine = ShowPsuInfo();
}
else if(strcmp(&MultiSubCmd[0][0], "temp") == EQUAL)
{
reflashLine = ShowPsuTemperature();
}
else if(strcmp(&MultiSubCmd[0][0], "count") == EQUAL)
{
reflashLine = ShowPsuCount();
}
else if(strcmp(&MultiSubCmd[0][0], "ver") == EQUAL)
{
reflashLine = ShowPsuVersion();
}
else if(strcmp(&MultiSubCmd[0][0], "cap") == EQUAL)
{
reflashLine = ShowPsuCap();
}
else if(strcmp(&MultiSubCmd[0][0], "input") == EQUAL)
{
reflashLine = ShowPsuInput();
}
else if(strcmp(&MultiSubCmd[0][0], "output") == EQUAL)
{
reflashLine = ShowPsuOutput();
}
else if(strcmp(&MultiSubCmd[0][0], "indi") == EQUAL)
{
int psuIndex = 0;
if(totalCnt == 2)
{
psuIndex = atoi(&MultiSubCmd[1][0]);
SetPsuIndication(psuIndex);
}
else
{
printf("Input cmd parsing fail ------ psu [indi] [index]\r\n");
}
keepRun = false;
}
else
{
printf("Input cmd parsing fail ------ psu [count | ver | cap | input | output | info | temp | indi]\r\n");
keepRun = false;
}
GetClockTime(&_Loop_time);
if((opt & OPTION_REFLASH) > 0)
{
reflash = true;
}
}
if(keepRun)
{
keepRun = IsLoopStopCmd() ? false : true;
usleep(10000);
}
}while(keepRun);
printf("\r\n");
}
int main(int argc, char *argv[])
{
char newString[32][MAX_SUB_CMD_LENGTH];
char inputString[MAX_SUB_CMD_LENGTH], normalCmd[MAX_SUB_CMD_LENGTH];
char mainCmd[MAX_SUB_CMD_LENGTH], subCmd[MAX_SUB_CMD_LENGTH], multiCmd[MAX_SUB_CMD_LENGTH];
int cmdCnt = 0, parseCnt = 0;
unsigned int option = 0;
if(InitShareMemory() == FAIL)
{
printf ("InitShareMemory = FAIL \n");
if(ShmStatusCodeData != NULL)
{
ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
}
sleep(5);
return 0;
}
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if (!FindChargingInfoData(i, &_chargingData[0]))
{
return 0;
}
}
// clean command
memset(mainCmd, 0x00, sizeof(mainCmd));
memset(subCmd, 0x00, sizeof(subCmd));
for(int i = 0; i < 32; i++)
{
memset(&newString[i], 0x00, 32);
}
memset(inputString, 0x00, sizeof(inputString));
memset(normalCmd, 0x00, sizeof(normalCmd));
if(argc > 1)
{
for(int i = 0; i < argc - 1; i++)
{
strcat(inputString, argv[i + 1]);
if(i + 1 < argc - 1)
{
strcat(inputString, " ");
}
}
}
for(;;)
{
if(argc == 1)
{
memset(inputString, 0x00, sizeof(inputString));
memset(normalCmd, 0x00, sizeof(normalCmd));
get_char(inputString);
}
cmdCnt = InputStringNormalize(inputString, normalCmd, &option);
if(cmdCnt > 0)
{
// clean command
memset(mainCmd, 0x00, sizeof(mainCmd));
memset(subCmd, 0x00, sizeof(subCmd));
for(int i = 0; i < 32; i++)
{
memset(&newString[i], 0x00, MAX_SUB_CMD_LENGTH);
}
//printf("CmdCnt: %d\r\n", cmdCnt);
//printf("Input: %s", inputString);
//printf("Normalize: %s\r\n", normalCmd);
//printf("option: %08X\r\n", option);
MainAndSubCommandParsing(normalCmd, mainCmd, subCmd);
//printf("MainCmd: %s\r\n", mainCmd);
//printf("SubCmd: %s\r\n", subCmd);
parseCnt = 0;
strcpy(multiCmd, normalCmd);
do
{
MainAndSubCommandParsing(multiCmd, &newString[parseCnt][0], &newString[parseCnt + 1][0]);
strcpy(multiCmd, &newString[parseCnt + 1][0]);
//printf("MultiCmd Parse %d\r\n", parseCnt + 1);
//printf("MainCmd: %s\r\n", &newString[parseCnt][0]);
//printf("SubCmd: %s\r\n", &newString[parseCnt + 1][0]);
parseCnt++;
}while(parseCnt < cmdCnt - 1);
//printf("\r\n");
//for(int i = 0; i < cmdCnt; i++)
//{
// printf("MultiCmd %d: [%s]\r\n", i + 1, &newString[i][0]);
//}
}
else
{
usleep(100000);
continue;
}
if(strcmp(newString[0], "state") == 0)
{
if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
continue;
// 槍狀態
RunStatusProc(newString[1], newString[2]);
}
else if(strcmp(newString[0], "card") == 0)
{
// 刷卡狀態
RunCardProc(newString[1], newString[2]);
}
else if(strcmp(newString[0], "gun") == 0)
{
if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
continue;
// 插槍狀態
RunGunPlugitProc(newString[1], newString[2]);
}
else if(strcmp(newString[0], "lock") == 0)
{
if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
continue;
// 插槍狀態
GetGunLockStatusProc(newString[1], newString[2]);
}
else if(strcmp(newString[0], "sysid") == 0)
{
// 測試 sys id
SetSystemIDProc();
}
else if(strcmp(newString[0], "self") == 0)
{
// CSU 自我檢測狀態
RunSelfProc(newString[1]);
}
else if(strcmp(newString[0], "ver") == 0)
{
//if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
// continue;
// 取 FW 版號
//GetFwVerProc(newString[1]);
ShowFwVer();
}
else if(strcmp(mainCmd, "update") == 0)
{
// 更新
FwUpdateFlagProc(subCmd, option);
}
else if (strcmp(newString[0], "ac") == 0)
{
// AC contactor 狀態
CheckAcStatus(newString[1]);
}
else if (strcmp(newString[0], "cable") == 0)
{
if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
continue;
// cable check pass
SetCableChkStatus(newString[1], newString[2]);
}
else if (strcmp(newString[0], "pow") == 0)
{
if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
continue;
// cable check pass
SetPowerValue(newString[1], newString[2]);
}
else if(strcmp(mainCmd, "model") == 0)
{
ModelNameCmd(subCmd, option);
}
else if(strcmp(mainCmd, "sn") == 0)
{
SerialNumberCmd(subCmd, option);
}
else if(strcmp(newString[0], "fan") == 0)
{
// 設定風扇速度
SetFanSpeed(newString[1]);
}
else if(strcmp(newString[0], "speed") == 0)
{
// 取得風扇速度
GetFanSpeed();
}
else if(strcmp(newString[0], "debug") == 0)
{
// 設定 debug mode
SetDebugMode(newString[1]);
}
else if (strcmp(newString[0], "gfd") == 0)
{
// 設定盲沖使用 GFD 功能
SetGFDMode(newString[1]);
}
else if(strcmp(mainCmd, "temp") == 0)
{
// 取得溫度
GetTemperature(subCmd, option);
}
else if(strcmp(mainCmd, "acin") == 0 || strcmp(mainCmd, "input") == 0)
{
// 取得三向輸入電壓
GetInputVol(subCmd, option);
}
else if(strcmp(mainCmd, "psu") == 0)
{
PsuCmd(subCmd, option);
}
else if (strcmp(newString[0], "cap") == 0)
{
GetConnectorCapInfo(newString[1]);
}
else if(strcmp(newString[0], "error") == 0)
{
CreateOneError(newString[1]);
}
else if (strcmp(newString[0], "auth") == 0)
{
GetAuthorizeFlag(newString[1]);
}
else if (strcmp(newString[0], "id") == 0)
{
GetOrClearId(newString[1]);
}
else if(strcmp(newString[0], "wiring") == 0)
{
if(strcmp(newString[1], "-1") != 0 && strcmp(newString[1], "") != 0 &&
strcmp(newString[2], "-1") != 0 && strcmp(newString[2], "") != 0)
{
SetWiringInfo(newString[1], newString[2]);
}
ShowWiringInfo();
}
else if(strcmp(newString[0], "cwiring") == 0)
{
CleanWiringInfo();
}
else if(strcmp(newString[0], "reset") == 0)
{
SetSystemSoftRest();
}
else if(strcmp(newString[0], "reboot") == 0)
{
SetSystemHardReboot();
}
else if(strcmp(newString[0], "sgroup") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
{
ShowGroupingInfo();
continue;
}
RunSimplePsuGrouping(newString[1], newString[2]);
}
else if(strcmp(mainCmd, "cabinet") == 0)
{
ShowCabinetInfo(subCmd, option);
}
else if(strcmp(newString[0], "tctl") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0)
{
printf("Test Control Value = %08X\n",ShmChargerInfo->Control.TestCtrl.CtrlValue);
printf ("Input cmd fail ------ tctl [tcmd] [value]\n\n");
continue;
}
SetTestControl(newString[1], newString[2]);
}
else if(strcmp(newString[0], "group") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
{
ShowGroupingInfo();
continue;
}
}
else if(strcmp(mainCmd, "gdmd") == 0)
{
ShowGroupingDemand(subCmd, option);
}
else if(strcmp(mainCmd, "gunchg") == 0)
{
SetGunStartCharging(subCmd, option, NO);
}
else if(strcmp(mainCmd, "webchg") == 0)
{
SetGunStartCharging(subCmd, option, YES);
}
else if(strcmp(mainCmd, "gunstp") == 0)
{
SetGunStopCharging(subCmd, option);
}
else if(strcmp(newString[0], "gunext") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
{
printf ("Input cmd fail ------ gunext [gun 1-4]\n\n");
continue;
}
SetGunExtend(newString[1]);
}
else if(strcmp(newString[0], "output") == 0)
{
ShowGunOutput();
}
else if(strcmp(newString[0], "gio") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0)
{
printf ("Input cmd fail ------ gio [io] [on-off 0-1]\n\n");
continue;
}
SetGpio(newString[1], newString[2]);
}
else if(strcmp(newString[0], "status") == 0)
{
ShowStatus();
}
else if(strcmp(newString[0], "whiteR") == 0)
{
ShowWhiteCardList();
}
else if(strcmp(newString[0], "whiteW") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0)
{
printf ("Input cmd fail ------ whiteW [index 1-10] [card id]\n\n");
continue;
}
WriteWhiteCard(newString[1], newString[2]);
}
else if(strcmp(newString[0], "whiteE") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0)
{
printf ("Input cmd fail ------ whiteE [index 1-10]\n\n");
continue;
}
EraseWhiteCard(newString[1]);
}
else if(strcmp(mainCmd, "limit") == 0)
{
ShowChargerLimit(subCmd, option);
}
else if(strcmp(mainCmd, "pcmd") == 0)
{
SetPsuCommand(subCmd, option);
}
else if(strcmp(newString[0], "gcmd") == 0)
{
if(strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0 ||
strcmp(newString[3], "-1") == 0 || strcmp(newString[3], "") == 0)
{
printf ("Input cmd fail ------ gcmd [cmd] [gun] [value]\n\n");
continue;
}
SetGunCommand(newString[1], newString[2], newString[3]);
}
else if(strcmp(mainCmd, "web") == 0)
{
ShowWebInfo(subCmd, option);
}
else if(strcmp(mainCmd, "info") == 0)
{
ShowInfo(subCmd, option);
}
else if(strcmp(mainCmd, "rtcsync") == 0)
{
RtcSyncCmd(subCmd, option);
}
else if(strcmp(mainCmd, "pmodel") == 0)
{
ParsingModelNameCmd(subCmd, option);
}
else if(strcmp(mainCmd, "pt") == 0)
{
CustomerPriceTest(subCmd, option);
}
else if(strcmp(mainCmd, "evmsg") == 0)
{
EvCommMsgDebug(subCmd, option);
}
else if(strcmp(mainCmd, "evid") == 0)
{
EvCommIdDebug(subCmd, option);
}
else if(strcmp(mainCmd, "flash") == 0)
{
FlashCmd(subCmd, option);
}
else if(strcmp(mainCmd, "relay") == 0)
{
RelayCmd(subCmd, option);
}
else if(strcmp(mainCmd, "price") == 0)
{
ShowPrice(subCmd, option);
}
else if(strcmp(mainCmd, "parking") == 0)
{
OccupancyCmd(subCmd, option);
}
else if(strcmp(mainCmd, "occupancy") == 0)
{
ShowOccupancy(subCmd, option);
}
else if(strcmp(mainCmd, "super") == 0)
{
SuperMode(subCmd, option);
}
else
{
printf ("%s\n", msg);
}
usleep(100000);
if(argc > 1)
{
break;
}
}
return 0;
}