/* * 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 quantity = 0; for(int i = 0; i < 3; i++) { if(IsAvalibleGunType(modelName[7 + i], &type[quantity])) { 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) { 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_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'; } } } 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 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; 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 != voltage || ConnectorCapability[packet->Header.id - 1].MaxOuputCurrent != current || ConnectorCapability[packet->Header.id - 1].MaxOuputPower != power) { 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 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_Software_Update; sendBuffer.Payload.data[0] = _R_OK; sendBuffer.Payload.data[1] = result; 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.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.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 ConnectorTypeBindingHandler(unsigned char dispenserIndex, unsigned char *type) { 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]; PRINTF_FUNC("Dispenser id %d Connector %d type %s", dispenserIndex + 1, gunIndex + 1, str_gun_type[type[i]]); } } BOOL IsAvailableDispenserIndexSequence(unsigned char index) { if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << index)) > 0) { // dispenser ever checkin return true; } else { for(int i = 0; i < GENERAL_GUN_QUANTITY; i++) { if(i == index) { return true; } if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << index)) == 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}; quantity = ConnectorQuantityTypeParsing(modelName, connectorType); 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); 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; float voltage = 0, current = 0; if(find) { voltage = (float)((packet->Payload.data[0] << 8) + packet->Payload.data[1]) / 10; current = (float)((packet->Payload.data[2] << 8) + packet->Payload.data[3]) / 10; if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_CHARGING) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != voltage || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != current) { PRINTF_FUNC("Connector %d Target Voltage: %d, Current: %d", packet->Header.id, (int)(voltage * 10), (int)(current * 10)); } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = (float)voltage; ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = (float)current; 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) { return _R_NoUpgrade; } 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); if(find) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != packet->Payload.data[0]) { PRINTF_FUNC("Connector %d Remote Status: %d", packet->Header.id, packet->Payload.data[0]); if((packet->Payload.data[0] == _CRS_Idle && ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != _CRS_Terminating) || packet->Payload.data[0] == _CRS_Terminating) { PRINTF_FUNC("*********** Connector id %d Set Stop Flag ***********\n", packet->Header.id); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.StopChargeFlag = true; } } ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus = packet->Payload.data[0]; } 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; if(find) { if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizeStatus == _AuthorizeStatus_Idle) { if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AuthorizeRequest && ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthorizeStatus == _AuthorizeStatus_Idle) { memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, 0x00, 32); memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, packet->Payload.data, packet->Header.len - 1); PRINTF_FUNC("Dispenser %d connector %d user id %s need authorize", dispenserIndex + 1, packet->Header.id, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId); ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AuthorizeRequest = true; ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeTargetID = packet->Header.id; } authorize = _DAS_Wait; } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizeStatus == _AuthorizeStatus_Fail) { PRINTF_FUNC("Dispenser %d connector %d user id %s authorizing fail", dispenserIndex + 1, packet->Header.id, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId); authorize = _DAS_NotAllowed; } else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizeStatus == _AuthorizeStatus_Pass) { PRINTF_FUNC("Dispenser %d connector %d user id %s authorizing ok", dispenserIndex + 1, packet->Header.id, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId); authorize = _DAS_Allowed; } 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; PRINTF_FUNC("Cabinet status idle, not allow dispenser id %d connector id %d charging", dispenserIndex + 1, packet->Header.id); PRINTF_FUNC("RemoteStop or UnlockStop, not allow dispenser index %d connector id %d preparing to charge", dispenserIndex, packet->Header.id); } 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; 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_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; 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; 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_RESERVATION: case S_MAINTAIN: permission = _DAS_NotAllowed; 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; } // 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]); 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; } 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; } } } // Reg: 0x03, Power cabinet status if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Power_Cabinet_Status) { PowerCabinetStatusResponse(socketFd, &receiveBuffer); } // 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, 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].AuthorizeStatus = 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\n"); 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; }