/* * Module_EvComm.c * * Created on: 2020年9月14日 * Author: Wendell */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /*標準輸入輸出定義*/ #include /*標準函數庫定義*/ #include /*Unix 標準函數定義*/ #include /*檔控制定義*/ #include /*PPSIX 終端控制定義*/ #include /*錯誤號定義*/ #include #include #include #include #include #include #include #include "../../define.h" #include "Module_EvComm.h" #include "Config.h" #define ARRAY_SIZE(A) (sizeof(A) / sizeof(A[0])) #define PASS 1 #define FAIL -1 #define YES 1 #define NO 0 #define ON 1 #define OFF 0 #define true 1 #define false 0 struct SysConfigAndInfo *ShmSysConfigAndInfo; //struct WARNING_CODE_INFO LastWarningInfo[GENERAL_GUN_QUANTITY]; void PRINTF_FUNC(char *string, ...); int StoreLogMsg(const char *fmt, ...); #define DEBUG_INFO(format, args...) StoreLogMsg("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args) #define DEBUG_WARN(format, args...) StoreLogMsg("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args) #define DEBUG_ERROR(format, args...) StoreLogMsg("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args) int StoreLogMsg(const char *fmt, ...) { char Buf[4096+256]; char buffer[4096]; va_list args; struct timeb SeqEndTime; struct tm *tm; va_start(args, fmt); int rc = vsnprintf(buffer, sizeof(buffer), fmt, args); va_end(args); memset(Buf,0,sizeof(Buf)); ftime(&SeqEndTime); SeqEndTime.time = time(NULL); tm=localtime(&SeqEndTime.time); if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == YES) { sprintf(Buf,"%02d:%02d:%02d:%03d - %s", tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm, buffer); printf("%s \n", Buf); } else { sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm, buffer, tm->tm_year+1900,tm->tm_mon+1); system(Buf); } return rc; } void PRINTF_FUNC(char *string, ...) { va_list args; char buffer[4096]; va_start(args, string); vsnprintf(buffer, sizeof(buffer), string, args); va_end(args); DEBUG_INFO("%s \n", buffer); } void ShowSocketData(struct PACKET_STRUCTURE *packet) { printf("se: %02X, id: %02X, op: %d, len: %3d, reg: %02X", packet->Header.se, packet->Header.id, packet->Header.op, packet->Header.len, packet->Payload.reg); if(packet->Header.len > 1) { printf(", Data:"); for(int i = 0; i < packet->Header.len - 1; i++) { printf(" %02X", packet->Payload.data[i]); } } printf("\n"); } //========================================== // Init all share memory //========================================== int InitShareMemory() { int result = PASS; int MeterSMId; //creat ShmSysConfigAndInfo if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0) { #ifdef SystemLogMessage DEBUG_ERROR("shmget ShmSysConfigAndInfo NG\n"); #endif result = FAIL; } else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1) { #ifdef SystemLogMessage DEBUG_ERROR("shmat ShmSysConfigAndInfo NG\n"); #endif result = FAIL; } else {} /* //creat ShmStatusCodeData if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), 0777)) < 0) { #ifdef SystemLogMessage DEBUG_ERROR("shmget ShmStatusCodeData NG\n"); #endif result = FAIL; } else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1) { #ifdef SystemLogMessage DEBUG_ERROR("shmat ShmStatusCodeData NG\n"); #endif result = FAIL; } else {} //creat ShmOCPP16Data if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), 0777)) < 0) { #ifdef SystemLogMessage DEBUG_ERROR("shmget ShmOCPP16Data NG"); #endif result = FAIL; } else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1) { #ifdef SystemLogMessage DEBUG_ERROR("shmat ShmOCPP16Data NG"); #endif result = FAIL; } else {} //creat ShmPsuData if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), 0777)) < 0) { #ifdef SystemLogMessage DEBUG_ERROR("shmget ShmPsuData NG \n"); #endif result = FAIL; } else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1) { #ifdef SystemLogMessage DEBUG_ERROR("shmat ShmPsuData NG \n"); #endif result = FAIL; } memset(ShmPsuData,0,sizeof(struct PsuData)); */ return result; } //-------------------------------------------Socket Client Start------------------------------------------- unsigned char seqNum = 0; void sendCmdDispenserModelName(int socket, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; char *modelName = "DSYE601J0EW2PH"; //char *modelName = "DSYE601J00W2PH"; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = 0xFF; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = strlen(modelName) + 2; sendBuffer.Payload.reg = _Reg_Dispenser_Model_Name; memcpy(&sendBuffer.Payload.data[0], modelName, strlen(modelName)); sendBuffer.Payload.data[strlen(modelName)] = 1; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdDispenserConnectorIDRequest(int socket, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = 0xFF; sendBuffer.Header.op = _Header_Read; sendBuffer.Header.len = 1; sendBuffer.Payload.reg = _Reg_Connector_ID; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdPowerCabinetStatusRequest(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Read; sendBuffer.Header.len = 1; sendBuffer.Payload.reg = _Reg_Power_Cabinet_Status; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdWriteDispenserStatus(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = 1; sendBuffer.Payload.reg = _Reg_Dispenser_Status; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdReadChargingCapability(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Read; sendBuffer.Header.len = 1; sendBuffer.Payload.reg = _Reg_Charging_Capability; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdWriteChargingTarget(int socket, unsigned char connector, unsigned char se, unsigned short voltage, unsigned short current) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = 5; sendBuffer.Payload.reg = _Reg_Charging_Target; sendBuffer.Payload.data[0] = (voltage >> 8) & 0xFF; sendBuffer.Payload.data[1] = voltage & 0xFF; sendBuffer.Payload.data[2] = (current >> 8) & 0xFF; sendBuffer.Payload.data[3] = current & 0xFF; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdWritePlugInStatus(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Plug_In_Status; sendBuffer.Payload.data[0] = se % 2 == 0 ?_PIS_UnPlugged : _PIS_PluggedIn; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdWriteConnectorState(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Connector_State; sendBuffer.Payload.data[0] = _CRS_Idle; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdWriteUserID(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; char *userID = "010203040506"; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Write; sendBuffer.Header.len = strlen(userID) + 1; sendBuffer.Payload.reg = _Reg_User_ID; memcpy(sendBuffer.Payload.data, userID, strlen(userID)); send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void sendCmdReadChargingPermission(int socket, unsigned char connector, unsigned char se) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = se; sendBuffer.Header.id = connector; sendBuffer.Header.op = _Header_Read; sendBuffer.Header.len = 1; sendBuffer.Payload.reg = _Reg_Charging_Permission; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } int DispenserModelNameCheckIn(int socket, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdDispenserModelName(socket, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write Model Name OK"); result = PASS; break; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= DISPENSER_MODEL_NAME_RESEND) { //timeout break; } } return result; } int DispenserConnectorRequest(int socket, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdDispenserConnectorIDRequest(socket, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 4) { if(receiveBuffer.Payload.reg == _Reg_Connector_ID && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Get Connector ID: %02X, %02X", receiveBuffer.Payload.data[1], receiveBuffer.Payload.data[2]); result = PASS; break; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= DISPENSER_CONNECTOR_RESEND) { //timeout break; } } return result; } int DispenserReadPowerCabinetStatus(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdPowerCabinetStatusRequest(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Payload.reg == _Reg_Power_Cabinet_Status && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Get Cabinet Status Code, Len: %d", (receiveBuffer.Header.len - 2) / 6); result = PASS; } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CABINET_STATUS_REQUEST_RESEND) { //timeout break; } } return result; } int DispenserWriteStatusCode(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdWriteDispenserStatus(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_Dispenser_Status && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write Dispenser Status Code OK"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CABINET_STATUS_REQUEST_RESEND) { //timeout break; } } return result; } int DispenserReadChargingCapability(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; unsigned short voltage = 0, current = 0, power = 0; sendCmdReadChargingCapability(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 8) { if(receiveBuffer.Payload.reg == _Reg_Charging_Capability && receiveBuffer.Payload.data[0] == _R_OK) { voltage = (receiveBuffer.Payload.data[1] << 8) + receiveBuffer.Payload.data[2]; current = (receiveBuffer.Payload.data[3] << 8) + receiveBuffer.Payload.data[4]; power = (receiveBuffer.Payload.data[5] << 8) + receiveBuffer.Payload.data[6]; PRINTF_FUNC("Capability Voltage: %d.%dV, Current: %d.%dA, Power: %d.%dkW", voltage / 10, voltage % 10, current / 10, current % 10, power / 10, power % 10); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } int DispenserWriteChargingTarget(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdWriteChargingTarget(socket, connector, se, 7505, 406); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_Charging_Target && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write Charging Target OK"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } int DispenserWritePlugInStatus(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdWritePlugInStatus(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_Plug_In_Status && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write Plug In Status OK"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } int DispenserWriteConnectorState(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdWriteConnectorState(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_Connector_State && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write Connector State OK"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } int DispenserWriteUserID(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdWriteUserID(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 2) { if(receiveBuffer.Payload.reg == _Reg_User_ID && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Write User ID OK"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } int DispenserReadChargingPermission(int socket, unsigned char connector, unsigned char se) { int rxLen = 0, timeout = 0; struct PACKET_STRUCTURE receiveBuffer; int result = FAIL; sendCmdReadChargingPermission(socket, connector, se); while(1) { if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ShowSocketData(&receiveBuffer); if(receiveBuffer.Header.len == 3) { if(receiveBuffer.Payload.reg == _Reg_Charging_Permission && receiveBuffer.Payload.data[0] == _R_OK) { PRINTF_FUNC("Charging Permission: %s", receiveBuffer.Payload.data[1] == _PS_Permitted ? "Permitted" : "Not Permitted"); result = PASS; } } } } timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); if(timeout >= CHARGING_CAPABILITY_RESEND) { //timeout break; } } return result; } void tcpSocketClientStart(void) { struct sockaddr_in info; struct timeval tv; uint8_t socketEnable; int sockfd = 0; unsigned char clientStatus = 0; unsigned char se = 0; //start dhcp client //udhcpc -i eth1 --script /root/dhcp_script/eth1.script //udhcpc -i eth1 -s /root/dhcp_script/eth1.script & //udhcpc -i eth0 -x hostname CSU3_DSYE601J0EW2PH-SERIALFORRD -s /root/dhcp_script/eth0.script for(;;) { bzero(&info,sizeof(info)); info.sin_family = PF_INET; info.sin_addr.s_addr = inet_addr(SOCKET_SERVER_IP); info.sin_port = htons(TCP_LISTEN_PORT); sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd == -1) { PRINTF_FUNC("Fail to create a socket."); return; } PRINTF_FUNC("TCP Client Start"); if(connect(sockfd, (struct sockaddr *)&info, sizeof(info)) == -1) { PRINTF_FUNC("Connection error"); } else { PRINTF_FUNC("Connect to %s success", inet_ntoa(info.sin_addr)); tv.tv_sec = 0; tv.tv_usec = 500000; setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv); socketEnable = ON; } while(socketEnable) { switch(clientStatus) { case 0: //5.1 Dispenser model name if(DispenserModelNameCheckIn(sockfd, se++) == PASS) { clientStatus = 1; } break; case 1: if(DispenserConnectorRequest(sockfd, se++) == PASS) { clientStatus = 2; } break; case 2: if(DispenserReadPowerCabinetStatus(sockfd, 0x01, se++) == PASS) { if(DispenserWriteStatusCode(sockfd, 0x01, se++) == PASS) { clientStatus = 3; } } break; case 3: if(DispenserWriteUserID(sockfd, 0x01, se++) == PASS) { clientStatus = 4; } break; case 4: if(DispenserReadChargingCapability(sockfd, 0x01, se++) == PASS) { } if(DispenserWriteChargingTarget(sockfd, 0x01, se++) == PASS) { } if(DispenserWritePlugInStatus(sockfd, 0x01, se++) == PASS) { } if(DispenserWriteConnectorState(sockfd, 0x01, se++) == PASS) { } if(DispenserReadChargingPermission(sockfd, 0x01, se++) == PASS) { } break; default: break; } } close(sockfd); sleep(5); return; } } //--------------------------------------------Socket Client End-------------------------------------------- BOOL IsAvalibleGunType(char name, unsigned char *type) { char modelList[6] = {'J', 'U', 'E', 'G', 'V', 'F'}; unsigned char typeList[6] = {0, 1, 1, 2, 1, 1}; // 0 : Chademo, 1: CCS, 2: GB for(int i = 0; i < 6; i++) { if(name == modelList[i]) { *type = typeList[i]; return true; } } return false; } unsigned char ConnectorQuantityTypeParsing(unsigned char *modelName, unsigned char *type, unsigned char *physical) { unsigned char quantity = 0; for(int i = 0; i < 3; i++) { if(IsAvalibleGunType(modelName[7 + i], &type[quantity])) { physical[quantity] = modelName[7 + i]; if(quantity < 2) { quantity++; } else { quantity = 0; break; } } } return quantity; } void ModelNameResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = 0xFF; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Dispenser_Model_Name; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void ConnectorIDResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result, unsigned char dispenserIndex) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = 0xFF; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 4; sendBuffer.Payload.reg = _Reg_Connector_ID; sendBuffer.Payload.data[0] = result; sendBuffer.Payload.data[1] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0]; sendBuffer.Payload.data[2] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[1]; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void PowerCabinetStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { struct PACKET_STRUCTURE sendBuffer; unsigned char MiscEventCode[7]; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Power_Cabinet_Status; sendBuffer.Payload.data[0] = _R_OK; if(ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 0) { sendBuffer.Header.len += (ShmSysConfigAndInfo->SysWarningInfo.WarningCount * 6); for(int i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) { memcpy(&sendBuffer.Payload.data[1 + (i * 6)], &ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], 6); if(ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][1] == '1') { sendBuffer.Payload.data[1 + (i * 6) + 1] = '4'; } } } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.MiscNeedAnnouncement) { sendBuffer.Header.len += 6; memset(MiscEventCode, 0, sizeof(MiscEventCode)); memcpy(MiscEventCode, "B40001", sizeof(MiscEventCode) - 1); memcpy(&sendBuffer.Payload.data[1 + (ShmSysConfigAndInfo->SysWarningInfo.WarningCount * 6)], &MiscEventCode[0], 6); } send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void DispenserStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Dispenser_Status; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } struct ChargingCapabilityResponse ConnectorCapability[GENERAL_GUN_QUANTITY]; void GetPhysicalLimitVoltageAndCurrent(byte index, unsigned short *voltage, unsigned short *currrent) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage != 0 && ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage <= *voltage) { *voltage = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage; } if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent != 0 && ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent <= *currrent) { *currrent = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent; } } void GetConfigLimitVoltageAndCurrent(byte index, unsigned short *voltage, unsigned short *currrent) { unsigned short limitCurrent = ShmSysConfigAndInfo->SysInfo.MainChargingMode == _MAIN_CHARGING_MODE_MAX ? (ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingCurrent) : (ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingCurrent / 2); if(limitCurrent != 0 && limitCurrent <= *currrent) { *currrent = limitCurrent; } } void ChargingCapabilityResponse(int socket, struct PACKET_STRUCTURE *packet) { struct PACKET_STRUCTURE sendBuffer; unsigned short voltage = 0, current = 0, power = 0; unsigned char currency = 0; unsigned int price = 0, cost = 0, account = 0; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); voltage = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.MaximumChargingVoltage; current = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.AvailableChargingCurrent; power = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.AvailableChargingPower; GetPhysicalLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, ¤t); GetConfigLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, ¤t); currency = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency; price = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].UserPrice; cost = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].TotalCost; account = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AccountBalance; if((ConnectorCapability[packet->Header.id - 1].MaxOuputVoltage / 10) != (voltage / 10) || (ConnectorCapability[packet->Header.id - 1].MaxOuputCurrent / 10) != (current / 10) || (ConnectorCapability[packet->Header.id - 1].MaxOuputPower / 10) != (power / 10)) { PRINTF_FUNC("Connector %d Capability Voltage: %d, Current: %d, Power: %d", packet->Header.id, (int)(voltage), (int)(current), (int)(power)); } if(ConnectorCapability[packet->Header.id - 1].Currency != currency || ConnectorCapability[packet->Header.id - 1].UserPrice != price || ConnectorCapability[packet->Header.id - 1].TotalCost != cost || ConnectorCapability[packet->Header.id - 1].AccountBalance != account) { PRINTF_FUNC("Connector %d Currency: %d, UserPrice: %d, Cost: %d, Account: %d", packet->Header.id, (int)(currency), (int)(price), (int)(cost), (int)(account)); } ConnectorCapability[packet->Header.id - 1].MaxOuputVoltage = voltage; ConnectorCapability[packet->Header.id - 1].MaxOuputCurrent = current; ConnectorCapability[packet->Header.id - 1].MaxOuputPower = power; ConnectorCapability[packet->Header.id - 1].Currency = currency; ConnectorCapability[packet->Header.id - 1].UserPrice = price; ConnectorCapability[packet->Header.id - 1].TotalCost = cost; ConnectorCapability[packet->Header.id - 1].AccountBalance = account; sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 21; sendBuffer.Payload.reg = _Reg_Charging_Capability; sendBuffer.Payload.data[0] = _R_OK; sendBuffer.Payload.data[1] = ((voltage >> 8) & 0xFF); sendBuffer.Payload.data[2] = (voltage & 0xFF); sendBuffer.Payload.data[3] = ((current >> 8) & 0xFF); sendBuffer.Payload.data[4] = (current & 0xFF); sendBuffer.Payload.data[5] = ((power >> 8) & 0xFF); sendBuffer.Payload.data[6] = (power & 0xFF); sendBuffer.Payload.data[7] = currency; sendBuffer.Payload.data[8] = ((price >> 24) & 0xFF); sendBuffer.Payload.data[9] = ((price >> 16) & 0xFF); sendBuffer.Payload.data[10] = ((price >> 8) & 0xFF); sendBuffer.Payload.data[11] = (price & 0xFF); sendBuffer.Payload.data[12] = ((cost >> 24) & 0xFF); sendBuffer.Payload.data[13] = ((cost >> 16) & 0xFF); sendBuffer.Payload.data[14] = ((cost >> 8) & 0xFF); sendBuffer.Payload.data[15] = (cost & 0xFF); sendBuffer.Payload.data[16] = ((account >> 24) & 0xFF); sendBuffer.Payload.data[17] = ((account >> 16) & 0xFF); sendBuffer.Payload.data[18] = ((account >> 8) & 0xFF); sendBuffer.Payload.data[19] = (account & 0xFF); send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void ChargingTargetResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Charging_Target; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void FirmwareUpgradeResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 3; sendBuffer.Payload.reg = _Reg_Software_Update; sendBuffer.Payload.data[0] = _R_OK; sendBuffer.Payload.data[1] = result; if(result == _R_NeedUpgrade) { int length = strlen(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FwFileName); memcpy(&sendBuffer.Payload.data[2], ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FwFileName, length); sendBuffer.Header.len += length; } send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void PlugInStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Plug_In_Status; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void ConnectorStateResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Connector_State; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void UserIDResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 3; sendBuffer.Payload.reg = _Reg_User_ID; sendBuffer.Payload.data[0] = result == _DAS_Wait ? _R_NG : _R_OK; sendBuffer.Payload.data[1] = result == _DAS_Allowed ? _PS_Permitted : _PS_NotPermitted; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void ChargingPermissionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 3; sendBuffer.Payload.reg = _Reg_Charging_Permission; sendBuffer.Payload.data[0] = result == _DAS_Wait ? _R_NG : _R_OK; sendBuffer.Payload.data[1] = result == _DAS_Allowed ? _PS_Permitted : _PS_NotPermitted; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void AddMiscCommand(struct PACKET_STRUCTURE *packet, struct MISC_COMMAND *misc) { packet->Payload.data[packet->Header.len - 1 + 0] = ((misc->Command >> 8) & 0xFF); packet->Payload.data[packet->Header.len - 1 + 1] = ((misc->Command >> 0) & 0xFF); packet->Payload.data[packet->Header.len - 1 + 2] = ((misc->Value >> 24) & 0xFF); packet->Payload.data[packet->Header.len - 1 + 3] = ((misc->Value >> 16) & 0xFF); packet->Payload.data[packet->Header.len - 1 + 4] = ((misc->Value >> 8) & 0xFF); packet->Payload.data[packet->Header.len - 1 + 5] = ((misc->Value >> 0) & 0xFF); packet->Header.len += 6; } void MiscControlResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Misc_Control; sendBuffer.Payload.data[0] = result; if(result == _R_OK) { struct MISC_COMMAND misc; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AvailabilityRequest) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AvailabilityRequest = false; misc.Command = _MiscCmd_ChangeOperative; misc.Value = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.IsAvailable; PRINTF_FUNC("Announce Connector %d Availability: %d", packet->Header.id, misc.Value); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartRequest) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartRequest = false; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartConfirm = true; misc.Command = _MiscCmd_RemoteStart; misc.Value = true; PRINTF_FUNC("Announce Connector %d Remote Start: %d", packet->Header.id, misc.Value); AddMiscCommand(&sendBuffer, &misc); } // if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest) // { // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest = false; // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopConfirm = true; // misc.Command = _MiscCmd_RemoteStop; // misc.Value = true; // PRINTF_FUNC("Announce Connector %d Remote Stop: %d", packet->Header.id, misc.Value); // AddMiscCommand(&sendBuffer, &misc); // } // if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest) // { // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest = false; // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopConfirm = true; // misc.Command = _MiscCmd_UnlockStop; // misc.Value = true; // PRINTF_FUNC("Announce Connector %d Unlock Stop: %d", packet->Header.id, misc.Value); // AddMiscCommand(&sendBuffer, &misc); // } if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AccountBalanceRequest) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AccountBalanceRequest = false; misc.Command = _MiscCmd_AccountBalance; misc.Value = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AccountBalance; PRINTF_FUNC("Announce Connector %d Account Balance: %d", packet->Header.id, (misc.Value)); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] == packet->Header.id) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest = false; misc.Command = _MiscCmd_ConnectorTimeout; misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout; PRINTF_FUNC("Announce Dispenser %d Connection Timeout: %d", dispenserIndex + 1, misc.Value); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest = false; misc.Command = _MiscCmd_DefaultPrice; misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice; PRINTF_FUNC("Announce Dispenser %d Default Price: %d", dispenserIndex + 1, misc.Value); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest = false; misc.Command = _MiscCmd_Currency; misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency; PRINTF_FUNC("Announce Dispenser %d Currency Index: %d", dispenserIndex + 1, misc.Value); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest = false; misc.Command = _MiscCmd_BackendStatus; misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus; PRINTF_FUNC("Announce Connector %d BackendStatus: %d", packet->Header.id, (misc.Value)); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest = false; misc.Command = _MiscCmd_EthernetStatus; misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus; PRINTF_FUNC("Announce Connector %d EthernetStatus: %d", packet->Header.id, (misc.Value)); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest = false; misc.Command = _MiscCmd_WiFiStatus; misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus; PRINTF_FUNC("Announce Connector %d WiFiStatus: %d", packet->Header.id, (misc.Value)); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest = false; misc.Command = _MiscCmd_4GStatus; misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus; PRINTF_FUNC("Announce Connector %d TelcomModemStatus: %d", packet->Header.id, (misc.Value)); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootRequest = false; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootConfirm = true; misc.Command = _MiscCmd_HardwareReboot; misc.Value = true; PRINTF_FUNC("Announce Dispenser %d Hardware Reboot: %d", dispenserIndex + 1, misc.Value); AddMiscCommand(&sendBuffer, &misc); } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetRequest) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetRequest = false; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetConfirm = true; misc.Command = _MiscCmd_SoftwareRestart; misc.Value = true; PRINTF_FUNC("Announce Dispenser %d Software Reset: %d", dispenserIndex + 1, misc.Value); AddMiscCommand(&sendBuffer, &misc); } } } send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void WriteCsuVersionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Report_Csu_Version; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void WriteOtherVersionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Report_Other_Version; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void WriteChargingInfoResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Charging_Info; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void ChargerSystemIdResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_Charger_System_Id; sendBuffer.Payload.data[0] = result; if(result == _R_OK) { int strLen = 0; strLen = strlen((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId); memcpy(&sendBuffer.Payload.data[sendBuffer.Header.len - 1], (char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, strLen); sendBuffer.Header.len += strLen + 1; char TimeSync[32]; struct timeb SeqEndTime; struct tm *tm; ftime(&SeqEndTime); SeqEndTime.time = time(NULL); tm=localtime(&SeqEndTime.time); memset(TimeSync, 0x00, 32); sprintf(TimeSync, "%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); strLen = strlen(TimeSync); memcpy(&sendBuffer.Payload.data[sendBuffer.Header.len - 1], TimeSync, strLen); sendBuffer.Header.len += strLen + 1; //PRINTF_FUNC("Dispenser %d Read System Id: %s", dispenserIndex + 1, ShmSysConfigAndInfo->SysConfig.ChargeBoxId); } send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } void WriteWaitPlugInResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result) { struct PACKET_STRUCTURE sendBuffer; memset(&sendBuffer, 0x00, sizeof(sendBuffer)); sendBuffer.Header.se = packet->Header.se; sendBuffer.Header.id = packet->Header.id; sendBuffer.Header.op = _Header_Response; sendBuffer.Header.len = 2; sendBuffer.Payload.reg = _Reg_WaitPlugIn; sendBuffer.Payload.data[0] = result; send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0); } BOOL FindConnectorID(unsigned char dispenserIndex, unsigned char id) { BOOL find = false; for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] == id) { find = true; break; } } return find; } void ConnectorPhysicalLimitBindingHandler(unsigned char connectorIndex, unsigned char physical) { //char modelList[6] = {'J', 'U', 'E', 'G', 'V', 'F'}; //unsigned char typeList[6] = {0, 1, 1, 2, 1, 1}; // 0 : Chademo, 1: CCS, 2: GB switch(physical) { case 'J': ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CHA_MAX_PHYSICAL_VOLTAGE; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CHA_NATURAL_MAX_CURRENT; break; case 'U': case 'E': ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_NATURAL_MAX_CURRENT; break; case 'G': ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = GBT_MAX_PHYSICAL_VOLTAGE; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = GBT_NATURAL_MAX_CURRENT; break; case 'V': case 'F': ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_LIQUID_MAX_CURRENT; break; default: ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = 0; break; } } void ConnectorTypeBindingHandler(unsigned char dispenserIndex, unsigned char *type, unsigned char *physicalType) { char *str_gun_type[] = {STR_GUN_TYPE_CHADEMO, STR_GUN_TYPE_CCS, STR_GUN_TYPE_GBT}; for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++) { unsigned char gunIndex = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] - 1; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].ParentDispensetIndex = dispenserIndex; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].GeneralChargingData.Index = gunIndex; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].GeneralChargingData.Type = type[i]; ConnectorPhysicalLimitBindingHandler(gunIndex, physicalType[i]); PRINTF_FUNC("Dispenser %d Connector %d type %s, MaxVol: %4d, MaxCur: %4d", dispenserIndex + 1, gunIndex + 1, str_gun_type[type[i]], ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalVoltage, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalCurrent); } } BOOL IsAvailableDispenserIndexSequence(unsigned char index) { for(int i = 0; i < GENERAL_GUN_QUANTITY; i++) { if(i == index) { return true; } if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << i)) == 0) { // i is not check in yet before index return false; } } return false; } void DispenserCheckInInfoUpdate(void) { unsigned char dispenser = 0, connector = 0; BOOL change = false; for(int i = 0; i < GENERAL_GUN_QUANTITY; i++) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None && ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout) { dispenser++; ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << i); ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity; connector += ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity; } } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity != dispenser || ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity != connector) { change = true; } ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = dispenser; ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = connector; if(change) { PRINTF_FUNC("Total Dispenser: %d, Total Connector: %d\n", ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity, ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity); } } void SetConnectorID(unsigned char dispenserIndex, unsigned char quantity) { unsigned char currentQuantity = 0; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] = 0x00; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[1] = 0x00; for(int i = 0; i < dispenserIndex; i++) { currentQuantity += ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i]; } for(int i = 0; i < quantity; i++) { currentQuantity++; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] = currentQuantity; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[currentQuantity - 1].Enable = true; } } BOOL DispenserIdentificationHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char *modelName) { unsigned char quantity = 0; unsigned char connectorType[2] = {0, 0}; unsigned char physicalType[2] = {0, 0}; quantity = ConnectorQuantityTypeParsing(modelName, connectorType, physicalType); if(quantity > 0) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout && quantity != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex]) { PRINTF_FUNC("The same dispenser id (%d) but connector quantity not match", dispenserIndex + 1); return false; } if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_None || ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Identification; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity = quantity; ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex] = quantity; SetConnectorID(dispenserIndex, quantity); memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, packet->Payload.data, (packet->Header.len - 2)); ConnectorTypeBindingHandler(dispenserIndex, connectorType, physicalType); PRINTF_FUNC("Dispenser id %d identified, Connector quantity: %d\n", dispenserIndex + 1, quantity); DispenserCheckInInfoUpdate(); return true; } else { PRINTF_FUNC("Conflict dispenser ID: %d", dispenserIndex + 1); } } else { PRINTF_FUNC("Connector quantity fail, model name: %s", modelName); } return false; } BOOL DispenserStatusCodeHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); if(find) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount = (packet->Header.len - 1) / 6; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount > 10) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount = 10; } for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++) { memcpy(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i][0], &packet->Payload.data[i * 6], 6); } /* BOOL needUpdate = FALSE; // check is there new status code for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++) { if(strcmp(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i][0], &LastWarningInfo[packet->Header.id - 1].WarningCode[i][0]) == 0) { needUpdate = TRUE; break; } } if(needUpdate) { memcpy(&LastWarningInfo[packet->Header.id - 1], &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo, sizeof(struct WARNING_CODE_INFO)); } */ char strDispenserStatus[128]; sprintf(strDispenserStatus, "Dispenser id %d, Status Code Len: %d", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount); if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount > 0) { for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++) { char strTemp[16]; sprintf(strTemp, ", %s", ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i]); strcat(strDispenserStatus, strTemp); } } PRINTF_FUNC(strDispenserStatus); } else { } return find; } BOOL ConnectorChargingCapabilityHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); BOOL done = false; if(find) { done = true; } return done; } unsigned long GetTimeoutValue(struct timeval _sour_time) { struct timeval _end_time; gettimeofday(&_end_time, NULL); return 1000000 * (_end_time.tv_sec - _sour_time.tv_sec) + _end_time.tv_usec - _sour_time.tv_usec; } BOOL ConnectorChargingTargetHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); BOOL done = false; unsigned short voltage = 0, current = 0; if(find) { voltage = ((packet->Payload.data[0] << 8) + packet->Payload.data[1]); current = ((packet->Payload.data[2] << 8) + packet->Payload.data[3]); if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage != voltage || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent != current) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage = voltage; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent = current; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable) { PRINTF_FUNC("Connector %d Remote Voltage: %d, Remote Current: %d", packet->Header.id, voltage, current); } } GetPhysicalLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, ¤t); GetConfigLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, ¤t); if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage != voltage || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent != current) { if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable = true; PRINTF_FUNC("Connector %d Remote Voltage: %d, Remote Current: %d", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent); PRINTF_FUNC("Connector %d Limit Voltage: %d, Limit Current: %d", packet->Header.id, voltage, current); } } else { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable = false; } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitVoltage = voltage; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitCurrent = current; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_PREPARING_FOR_EVSE || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_CHARGING) { float targetVol = (float)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitVoltage / 10); float targetCur = (float)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitCurrent / 10); if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != targetVol || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != targetCur) { PRINTF_FUNC("Connector %d Target Voltage: %d, Current: %d", packet->Header.id, (int)(targetVol * 10), (int)(targetCur * 10)); } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = targetVol; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = targetCur; done = true; } else { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != 0 || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != 0) { PRINTF_FUNC("Connector %d Not Charging Status, Set Voltage & Current Fail", packet->Header.id); } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = 0; } } else { } return done; } unsigned char FirmwareUpgradeHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { unsigned char UpgradeResponse = _R_NoUpgrade; if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] == packet->Header.id) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateRequest) { if(packet->Payload.data[0] == 0) { UpgradeResponse = _R_NeedUpgrade; } else { if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm = true; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateRequest = false; PRINTF_FUNC("Dispenser %d Updating...", dispenserIndex + 1); } } } else { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm) { if(packet->Payload.data[0] == 0) { if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateCompleted) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateCompleted = true; PRINTF_FUNC("Dispenser %d Upgrade Completed", dispenserIndex + 1); } } } } } return UpgradeResponse; } BOOL ConnectorPlugInHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); if(find) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn != packet->Payload.data[0]) { PRINTF_FUNC("Connector %d %s", packet->Header.id, packet->Payload.data[0] == _PIS_PluggedIn ? "Pluged In" : "Un Plugged"); } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn = packet->Payload.data[0]; } else { } return find; } BOOL ConnectorStateHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); unsigned char ConnectionState; unsigned char *AlarmCode; if(find && packet->Header.len <= 8) { ConnectionState = packet->Payload.data[0]; AlarmCode = &packet->Payload.data[1]; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != ConnectionState) { PRINTF_FUNC("Connector %d Remote Status: %d", packet->Header.id, ConnectionState); switch(ConnectionState) { case _CRS_Idle: case _CRS_Terminating: if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging) { PRINTF_FUNC("*********** Connector id %d Set Normal Stop Flag ***********\n", packet->Header.id); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.NormalStopRequest = true; } break; case _CRS_Alarm: memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode, AlarmCode, 6); if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Idle) { PRINTF_FUNC("*********** Connector id %d Set Fault Status [%s] ***********", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.FaultStatusRequest = true; } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging) { PRINTF_FUNC("*********** Connector id %d Set Alarm Stop Flag [%s] ***********", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AlarmStopRequest = true; } break; default: break; } } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus = ConnectionState; } else { } return true; } unsigned char UserIDHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); DispenserAck_Status authorize = _DAS_Wait; unsigned char CardNumber[32]; unsigned char *result; int length = 0; if(find || packet->Header.id == 0xFF) { length = packet->Header.len - 1; memset(CardNumber, 0x00, sizeof(CardNumber)); memcpy(CardNumber, packet->Payload.data, length); if(packet->Header.id != 0xFF) { result = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizingResult; } else { result = &ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthResult; } if(*result == _AuthResult_Valid) { PRINTF_FUNC("Dispenser %d Target %d user id %s authorizing ok", dispenserIndex + 1, packet->Header.id, CardNumber); authorize = _DAS_Allowed; } else if(*result == _AuthResult_Invalid) { PRINTF_FUNC("Dispenser %d Target %d user id %s authorizing fail", dispenserIndex + 1, packet->Header.id, CardNumber); authorize = _DAS_NotAllowed; } else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthStatus == _AuthorizeStatus_Idle && ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest == false) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, CardNumber, sizeof(CardNumber)); ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthTarget = packet->Header.id; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest = true; PRINTF_FUNC("Dispenser %d connector %d user id %s need authorize", dispenserIndex + 1, packet->Header.id, CardNumber); authorize = _DAS_Wait; } else { authorize = _DAS_Wait; } } else { authorize = _DAS_NotAllowed; } return authorize; } unsigned char ChargingPermissionHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); DispenserAck_Status permission = _DAS_Wait; if(find) { switch(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus) { case S_IDLE: if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Idle || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing) { permission = _DAS_Wait; } else { permission = _DAS_NotAllowed; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission) { PRINTF_FUNC("Cabinet status idle, not allow dispenser %d connector %d charging", dispenserIndex + 1, packet->Header.id); } } break; case S_AUTHORIZING: case S_REASSIGN_CHECK: case S_REASSIGN: case S_PREPARNING: permission = _DAS_Wait; break; case S_PREPARING_FOR_EV: if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest) { permission = _DAS_NotAllowed; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission) { PRINTF_FUNC("RemoteStop or UnlockStop, not allow dispenser index %d connector id %d preparing to charge", dispenserIndex, packet->Header.id); } } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus >= _CRS_Preparing && ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus <= _CRS_Charging) { if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.PermissionRequest) { ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.PermissionRequest = true; PRINTF_FUNC("Allow dispenser index %d connector id %d start preparing to charge", dispenserIndex, packet->Header.id); } permission = _DAS_Allowed; } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Terminating) { permission = _DAS_NotAllowed; PRINTF_FUNC("Dispenser Terminating, Not allow dispenser index %d connector id %d preparing to charge", dispenserIndex, packet->Header.id); } else { // keep wait } break; case S_PREPARING_FOR_EVSE: permission = _DAS_Allowed; break; case S_CHARGING: if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest) { permission = _DAS_NotAllowed; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission) { PRINTF_FUNC("RemoteStop or UnlockStop, not allow dispenser index %d connector id %d charging", dispenserIndex, packet->Header.id); } } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging) { permission = _DAS_Allowed; } else { permission = _DAS_NotAllowed; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission) { PRINTF_FUNC("Dispenser index %d connector id %d remote status not in charging mode", dispenserIndex, packet->Header.id); } } break; case S_TERMINATING: case S_COMPLETE: case S_ALARM: case S_FAULT: case S_RESERVATION: case S_MAINTAIN: permission = _DAS_NotAllowed; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission) { PRINTF_FUNC("Cabinet status(%d) not match, not allow dispenser index %d connector id %d charging", ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus, dispenserIndex, packet->Header.id); } break; default: break; } } else { PRINTF_FUNC("Dispenser index %d Connector id %d not found", dispenserIndex, packet->Header.id); permission = _DAS_NotAllowed; } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission = permission; // PRINTF_FUNC("Dispenser %d Permission %s, Gun Status: %d, Connector Status: %d, Wait Plug: %d, PlugIn: %d, Available: %d, Order: %d", dispenserIndex, permission == true ? "OK" : "NG", // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus, // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus, // ShmSysConfigAndInfo->SysInfo.WaitForPlugit, // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn, // ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.IsAvailable, // ShmSysConfigAndInfo->SysInfo.OrderCharging); return permission; } BOOL MiscControlHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); BOOL done = false; if(find) { done = true; } return done; } unsigned char DispenserWriteCsuVersionInfoHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { char version[32]; BOOL writeVersion = FALSE, showVersion = FALSE;; memcpy(version, &packet->Payload.data[0], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[32], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[64], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[96], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev, version, 32); showVersion = true; } if(showVersion) { PRINTF_FUNC("********** Dispenser id %d: Csu Version information **********", dispenserIndex + 1); PRINTF_FUNC("********** CsuBootLoadRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev); PRINTF_FUNC("********** CsuKernelFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev); PRINTF_FUNC("********** CsuRootFsFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev); PRINTF_FUNC("********** CsuPrimFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev); } writeVersion = TRUE; return writeVersion; } unsigned char DispenserWriteOtherVersionInfoHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { char version[32]; BOOL writeVersion = FALSE, showVersion = FALSE;; memcpy(version, &packet->Payload.data[0], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[32], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[64], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[96], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev, version, 32); showVersion = true; } memcpy(version, &packet->Payload.data[128], 32); if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev, version) != 0) { memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev, version, 32); showVersion = true; } if(showVersion) { PRINTF_FUNC("********** Dispenser id %d: Other Version information **********", dispenserIndex + 1); PRINTF_FUNC("********** FanModuleFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev); PRINTF_FUNC("********** RelayModuleRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev); PRINTF_FUNC("********** Connector1Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev); PRINTF_FUNC("********** Connector2Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev); PRINTF_FUNC("********** LedModuleFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev); } writeVersion = TRUE; return writeVersion; } unsigned char DispenserWriteChargingInfoHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); if(find) { unsigned short voltage = (packet->Payload.data[0] << 8) + (packet->Payload.data[1]); unsigned short current = (packet->Payload.data[2] << 8) + (packet->Payload.data[3]); //unsigned int time = (packet->Payload.data[4] << 24) + (packet->Payload.data[5] << 16) + (packet->Payload.data[6] << 8) + (packet->Payload.data[7]); unsigned char soc = (packet->Payload.data[8]); if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteChargingVoltage / 10) != (voltage / 10) || (ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteChargingCurrent / 10) != (current / 10) || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteSoc != soc) { PRINTF_FUNC("Connector %d Charging Info: Voltage %4dV Current %4dA Soc %d\% ", packet->Header.id, voltage, current, soc); } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteChargingVoltage = voltage; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteChargingCurrent = current; //ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteRemainChargingDuration = time; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteSoc = soc; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterySoc = soc; } else { } return find; } unsigned char ReadChargerSystemIdHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = TRUE; return find; } unsigned char WriteWaitPlugInHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex) { BOOL find = FindConnectorID(dispenserIndex, packet->Header.id); if(find) { unsigned char StartWait = packet->Payload.data[0]; if(StartWait) { if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug) { PRINTF_FUNC("Connector %d Start Wait Plug In", packet->Header.id); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.SwipeRfidConfirm = true; } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = true; } else { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus != S_IDLE) { PRINTF_FUNC("Connector %d Stop Wait Plug In", packet->Header.id); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.NeedCleanAuthorizeInfo = true; } } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = false; } } else { } return find; } void DisableConnector(unsigned char dispenserIndex) { for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++) { unsigned char connector = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] - 1; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Enable = false; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.TimeoutStopRequest = true; } } void DispenserSocketProcess(int socketFd, struct sockaddr_in clientInfo, unsigned char index) { int rxLen = 0, timeout = 0; unsigned char dispenserID = 0, dispenserIndex = 0; struct PACKET_STRUCTURE receiveBuffer; unsigned char modelName[64]; unsigned char ackResult = _R_NG; DispenserAck_Status ack = _DAS_Wait; PRINTF_FUNC("IP %s connection(%d) is established, start dispenser process", (inet_ntoa(clientInfo.sin_addr)), index); while(1) { if((rxLen = recv(socketFd, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0) { if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH)) { ackResult = _R_NG; //ShowSocketData(&receiveBuffer); if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_WaitModelName) { // Reg: 0x01, Dispenser model name if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name) { memset(modelName, 0x00, 64); dispenserID = receiveBuffer.Payload.data[receiveBuffer.Header.len - 2]; if(dispenserID > 0 && dispenserID <= GENERAL_GUN_QUANTITY) { dispenserIndex = dispenserID - 1; memcpy(modelName, receiveBuffer.Payload.data, receiveBuffer.Header.len - 2); if(IsAvailableDispenserIndexSequence(dispenserIndex)) { if(DispenserIdentificationHandler(&receiveBuffer, dispenserIndex, modelName) == true) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].DispenserIndex = dispenserIndex; ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status = _CNS_DispenserMatched; PRINTF_FUNC("********** Dispenser id %d check in, model name: %s **********\n", dispenserID, modelName); memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, modelName, 64); ackResult = _R_OK; } else { // response NG: gun quantity fail PRINTF_FUNC("Dispenser ID %d Identification Fail", dispenserID); } } else { // response NG: dispenser Index fail PRINTF_FUNC("Dispenser ID %d Fail, Need Wait Another Dispenser", dispenserID); } } else { PRINTF_FUNC("Dispenser ID: %d Over Range", dispenserID); } ModelNameResponse(socketFd, &receiveBuffer, ackResult); } else { // do nothing } } else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_DispenserMatched) { // Reg: 0x01, Dispenser model name if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name) { ackResult = _R_OK; ModelNameResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x02, Connector ID if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Connector_ID) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity > 0) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Idle; ackResult = _R_OK; } PRINTF_FUNC("Dispenser ID %d Get Connector ID %s", dispenserID, ackResult == _R_OK ? "OK" : "NG"); ConnectorIDResponse(socketFd, &receiveBuffer, ackResult, dispenserIndex); if(ackResult == _R_OK) { if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DispenserConfigSync) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DispenserConfigSync = true; PRINTF_FUNC("Dispenser ID %d Configuration Need To Synchronize", dispenserID); ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest = 1; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest = 1; } } } // Reg: 0x03, Power cabinet status if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Power_Cabinet_Status) { PowerCabinetStatusResponse(socketFd, &receiveBuffer, dispenserIndex); } // Reg: 0x04, Dispenser status if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Status) { if(DispenserStatusCodeHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } DispenserStatusResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x05, Charging capability if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charging_Capability) { if(ConnectorChargingCapabilityHandler(&receiveBuffer, dispenserIndex)) { ChargingCapabilityResponse(socketFd, &receiveBuffer); } } // Reg: 0x06, Charging target if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Charging_Target) { if(receiveBuffer.Header.len == 5) { if(ConnectorChargingTargetHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } } ChargingTargetResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x07, Software update if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Software_Update) { unsigned char NeedUpgrade = FirmwareUpgradeHandler(&receiveBuffer, dispenserIndex); FirmwareUpgradeResponse(socketFd, &receiveBuffer, dispenserIndex, NeedUpgrade); } // Reg: 0x08, Plug-in status if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Plug_In_Status) { if(receiveBuffer.Header.len == 2) { if(ConnectorPlugInHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } } PlugInStatusResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x09, Connector state if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Connector_State) { if(ConnectorStateHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } ConnectorStateResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x0A, User ID if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_User_ID) { ack = UserIDHandler(&receiveBuffer, dispenserIndex); UserIDResponse(socketFd, &receiveBuffer, ack); } // Reg: 0x0B, Charging permission if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charging_Permission) { ack = ChargingPermissionHandler(&receiveBuffer, dispenserIndex); ChargingPermissionResponse(socketFd, &receiveBuffer, ack); } // Reg: 0x0C, Misc Control if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Misc_Control) { if(MiscControlHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } MiscControlResponse(socketFd, &receiveBuffer, dispenserIndex, ackResult); } // Reg: 0x0D, Report csu version if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Report_Csu_Version) { if(DispenserWriteCsuVersionInfoHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } WriteCsuVersionResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x0E, Report other version if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Report_Other_Version) { if(DispenserWriteOtherVersionInfoHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } WriteOtherVersionResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x0F, Charging info if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Charging_Info) { if(DispenserWriteChargingInfoHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } WriteChargingInfoResponse(socketFd, &receiveBuffer, ackResult); } // Reg: 0x10, Charger system id if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charger_System_Id) { if(ReadChargerSystemIdHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } ChargerSystemIdResponse(socketFd, &receiveBuffer, dispenserIndex, ackResult); } // Reg: 0x11, Wait plug in if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_WaitPlugIn) { if(WriteWaitPlugInHandler(&receiveBuffer, dispenserIndex)) { ackResult = _R_OK; } WriteWaitPlugInResponse(socketFd, &receiveBuffer, ackResult); } } // clean timeout timeout = 0; } } else { timeout += SOCKET_RECEIVE_INTERVAL; usleep((SOCKET_RECEIVE_INTERVAL * 1000)); } if(timeout >= DISPENSER_SOCKET_TIMEOUT) { //timeout PRINTF_FUNC("IP: %s, Socket %d connection timeout", (inet_ntoa(clientInfo.sin_addr)), index); if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_DispenserMatched) { DisableConnector(dispenserIndex); memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex], 0x00, sizeof(struct DispenserModule)); ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Timeout; DispenserCheckInInfoUpdate(); } break; } } } int GetMacAddress(int sockFd, unsigned char *mac) { struct arpreq arpReq; struct sockaddr_in clientInfo; socklen_t len = sizeof(struct sockaddr_in); memset(mac, 0x00, 6); if(getpeername(sockFd, (struct sockaddr*)&clientInfo, &len) < 0) { return 0; } else { memcpy(&arpReq.arp_pa, &clientInfo, sizeof(struct sockaddr_in)); strcpy(arpReq.arp_dev, "eth1"); arpReq.arp_pa.sa_family = AF_INET; arpReq.arp_ha.sa_family = AF_UNSPEC; if(ioctl(sockFd, SIOCGARP, &arpReq) < 0) { return 0; } else { memcpy(mac, arpReq.arp_ha.sa_data, 6); } } return 1; } int FindFreeChannel(void) { for(int i = 0; i < MAXIMUM_CONNECT_QUANTITY; i++) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_FREE) { return i; } } return FAIL; } BOOL IsConflictIp(uint32_t ipAddress) { for(int i = 0; i < MAXIMUM_CONNECT_QUANTITY; i++) { if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress == ipAddress) { return true; } } return false; } void InitDispenserInfo(void) { for(int i = 0; i < GENERAL_GUN_QUANTITY; i++) { //memset(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i], 0x00, sizeof(struct ConnectorInfoData)); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].RemoteStatus = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Enable = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].ReadyToCharge = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].ParentDispensetIndex = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.Value = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AuthorizingType = 0; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AuthorizingResult = 0; memset(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].WarningInfo, 0x00, sizeof(struct WARNING_CODE_INFO)); //memset(&LastWarningInfo[i], 0x00, sizeof(struct WARNING_CODE_INFO)); } memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo, 0x00, sizeof(struct DispenserInfoData)); ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency = ShmSysConfigAndInfo->SysConfig.BillingData.Currency; } void tcpSocketServerStart(void) { int sockFd = 0; int clientSockFd = 0; int connectIndex = 0; pid_t forkId; struct sockaddr_in serverInfo, clientInfo; socklen_t addrlen = sizeof(clientInfo); //struct timeval timeout = {3, 0}; sockFd = socket(AF_INET, SOCK_STREAM, 0); if(sockFd == -1) { PRINTF_FUNC("InitSocketServer NG\n"); sleep(5); return; } InitDispenserInfo(); bzero(&serverInfo,sizeof(serverInfo)); serverInfo.sin_family = PF_INET; serverInfo.sin_addr.s_addr = htonl(INADDR_ANY); serverInfo.sin_port = htons(TCP_LISTEN_PORT); bind(sockFd, (struct sockaddr *)&serverInfo, sizeof(serverInfo)); listen(sockFd, CONNECTION_LIMIT); PRINTF_FUNC("TCP Server Start"); signal(SIGCHLD, SIG_IGN); // Main loop while(1) { clientSockFd = accept(sockFd, (struct sockaddr*) &clientInfo, &addrlen); /* if((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == ENONET) || (errno == EPROTO) || (errno == ENOPROTOOPT) || (errno == EOPNOTSUPP) || (errno == ENETDOWN) || (errno == ENETUNREACH) || (errno == EHOSTDOWN) || (errno == EHOSTUNREACH) || (errno == ECONNABORTED)) { printf("accept error: %s\n", strerror(errno)); //exit(EXIT_FAILURE); //break; } else if ( errno == EINTR) { printf("accept EINTRn"); continue; } else { printf("AccepCb: accept error: %s\n", strerror(errno)); //break; //exit(EXIT_FAILURE); }*/ PRINTF_FUNC("Client ip: %s is accepted at port: %d", inet_ntoa(clientInfo.sin_addr), clientInfo.sin_port); connectIndex = FindFreeChannel(); if(connectIndex >= 0) { if(IsConflictIp(clientInfo.sin_addr.s_addr) == false) { ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex].Status = _CNS_WaitModelName; ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex].IpAddress = clientInfo.sin_addr.s_addr; forkId = fork(); if(forkId == 0) { // child process DispenserSocketProcess(clientSockFd, clientInfo, connectIndex); close(clientSockFd); memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex], 0x00, sizeof(struct ConnectionInfoData)); return; } else if(forkId == -1) { PRINTF_FUNC("fork fail"); } } else { // conflict ip address PRINTF_FUNC("Conflict IP address, close socket"); close(clientSockFd); } } else { // no free channel PRINTF_FUNC("No free channel, close socket"); close(clientSockFd); } usleep(10000); } return; } int main(void) { if(InitShareMemory() == FAIL) { #ifdef SystemLogMessage DEBUG_ERROR("InitShareMemory NG\n"); #endif sleep(5); return 0; } // wait for self test completed while(ShmSysConfigAndInfo->SysInfo.BootingStatus == BOOTTING); tcpSocketServerStart(); //tcpSocketClientStart(); return 0; }