/*
* Module_EvComm.c
*
* Created on: 2020年9月14日
* Author: Wendell
*/
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <linux/wireless.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdio.h> /*標準輸入輸出定義*/
#include <stdlib.h> /*標準函數庫定義*/
#include <unistd.h> /*Unix 標準函數定義*/
#include <fcntl.h> /*檔控制定義*/
#include <termios.h> /*PPSIX 終端控制定義*/
#include <errno.h> /*錯誤號定義*/
#include <errno.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <ifaddrs.h>
#include <signal.h>
#include <net/if_arp.h>
#include "../../define.h"
#include "Module_EvComm.h"
#include "Config.h"
#include "Common.h"
struct SysConfigAndInfo *ShmSysConfigAndInfo;
ChargerInfoData *ShmChargerInfo;
struct ChargingInfoData *chargingInfo[CONNECTOR_QUANTITY];
struct PsuData *ShmPsuData;
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), 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("shmget ShmSysConfigAndInfo NG");
#endif
result = FAIL;
}
else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("shmat ShmSysConfigAndInfo NG");
#endif
result = FAIL;
}
else
{
}
if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("shmat ChargerInfoData NG");
#endif
result = FAIL;
}
else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("shmat ChargerInfoData NG");
#endif
result = FAIL;
}
if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), 0777)) < 0)
{
#ifdef SystemLogMessage
LOG_ERROR("shmget ShmPsuData NG");
#endif
result = FAIL;
}
else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
{
#ifdef SystemLogMessage
LOG_ERROR("shmat ShmPsuData NG");
#endif
result = FAIL;
}
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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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];
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("Fail to create a socket.");
return;
}
LOG_INFO("TCP Client Start");
if(connect(sockfd, (struct sockaddr *)&info, sizeof(info)) == -1)
{
LOG_INFO("Connection error");
}
else
{
LOG_INFO("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)
{
// 20210817 remove type "R"
char modelList[10] = {'J', 'U', 'V', 'E', 'F', 'G', 'T', 'D', 'K', 'P'};
unsigned char typeList[10] = { 0, 1, 1, 1, 1, 2, 1, 1, 0, 1}; // 0 : Chademo, 1: CCS, 2: GB
for(int i = 0; i < 11; 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 SendPacket(int socket, struct PACKET_STRUCTURE *packet)
{
//ShowSocketData(packet);
send(socket, packet, packet->Header.len + 4, 0);
}
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;
SendPacket(socket, &sendBuffer);
}
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];
SendPacket(socket, &sendBuffer);
}
// more message for debug
struct PACKET_STRUCTURE CabinetStatusToDispenser[4];
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);
}
bool need_copy = false;
if(sendBuffer.Header.len != CabinetStatusToDispenser[dispenserIndex].Header.len ||
sendBuffer.Header.op != CabinetStatusToDispenser[dispenserIndex].Header.op ||
sendBuffer.Payload.reg != CabinetStatusToDispenser[dispenserIndex].Payload.reg ||
sendBuffer.Payload.data[0] != CabinetStatusToDispenser[dispenserIndex].Payload.data[0])
{
need_copy = true;
}
else
{
for(int i = 0; i < sendBuffer.Header.len - 2; i++)
{
if(sendBuffer.Payload.data[1 + i] != CabinetStatusToDispenser[dispenserIndex].Payload.data[1 + i])
{
need_copy = true;
}
}
}
if(need_copy)
{
char str[256];
memcpy(&CabinetStatusToDispenser[dispenserIndex], &sendBuffer, sizeof(struct PACKET_STRUCTURE));
sprintf(str, "Cabinet >> Dispenser %d Status Code:", dispenserIndex + 1);
for(int i = 0; i < CabinetStatusToDispenser[dispenserIndex].Header.len - 2; i++)
{
char temp[8];
sprintf(temp, " %02X", CabinetStatusToDispenser[dispenserIndex].Payload.data[1 + i]);
strcat(str, temp);
}
LOG_INFO("%s", str);
}
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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 GetModelNameLimitPower(byte index, unsigned short *power)
{
unsigned short limitPower = 0;
unsigned char inUsingCnt = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role == _GROLE_MASTER)
{
inUsingCnt += ShmChargerInfo->PsuGrouping.GroupCollection[i].GunPsuQuantity;
}
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
ShmChargerInfo->Control.ChargerRatingPower != 0)
{
limitPower = ShmChargerInfo->Control.ChargerRatingPower;
if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
{
limitPower += ShmChargerInfo->ParallelCabinet.TotalParallelPower;
}
limitPower = (limitPower * ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity) / inUsingCnt;
}
if(limitPower != 0 && limitPower <= *power)
{
*power = limitPower;
}
}
void GetConfigLimitPowerAndCurrent(byte index, unsigned short *power, unsigned short *currrent)
{
unsigned short limitPower = 0, limitCurrent = 0;
unsigned char inUsingCnt = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role == _GROLE_MASTER)
{
inUsingCnt += ShmChargerInfo->PsuGrouping.GroupCollection[i].GunPsuQuantity;
}
}
if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
ShmSysConfigAndInfo->SysConfig.MaxChargingPower != 0)
{
limitPower = ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 10;
limitPower = (limitPower * ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity) / inUsingCnt;
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingPower = limitPower;
if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent != 0)
{
limitCurrent = ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent * 10;
limitCurrent = (limitCurrent * ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity) / inUsingCnt;
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingCurrent = limitCurrent;
if(limitPower != 0 && limitPower <= *power)
{
*power = limitPower;
}
if(limitCurrent != 0 && limitCurrent <= *currrent)
{
*currrent = limitCurrent;
}
}
void GetChargingProfileLimit(byte index, unsigned short *power, unsigned short *currrent)
{
if((chargingInfo[index]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[index]->SystemStatus <= S_CHARGING) ||
(chargingInfo[index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
{
if(chargingInfo[index]->ChargingProfilePower >= 0 && *power > ((int)chargingInfo[index]->ChargingProfilePower / 100))
{
*power = (int)chargingInfo[index]->ChargingProfilePower / 100;
}
if(chargingInfo[index]->ChargingProfileCurrent >= 0 && *currrent > (int)chargingInfo[index]->ChargingProfileCurrent)
{
*currrent = (int)chargingInfo[index]->ChargingProfileCurrent;
}
}
}
void GetMaxChargingProfileLimit(byte index, unsigned short *power, unsigned short *currrent)
{
unsigned short limitPower = 0, limitCurrent = 0;
unsigned char inUsingCnt = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role == _GROLE_MASTER)
{
inUsingCnt += ShmChargerInfo->PsuGrouping.GroupCollection[i].GunPsuQuantity;
}
}
// max charging profile
if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower >= 0)
{
limitPower = (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower / 100;
limitPower = (limitPower * ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity) / inUsingCnt;
if(*power > limitPower)
{
*power = limitPower;
}
if (chargingInfo[index]->EvBatterytargetVoltage > 0 &&
(int)chargingInfo[index]->PresentChargingVoltage > 0)
{
limitCurrent = (limitPower * 100 / chargingInfo[index]->PresentChargingVoltage) * 10;
if(*currrent > limitCurrent)
{
*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);
GetModelNameLimitPower(packet->Header.id - 1, &power);
GetConfigLimitPowerAndCurrent(packet->Header.id - 1, &power, ¤t);
GetChargingProfileLimit(packet->Header.id - 1, &power, ¤t);
GetMaxChargingProfileLimit(packet->Header.id - 1, &power, ¤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))
{
LOG_INFO("Connector %d Capability Voltage: %4d.%d V, Current: %3d.%d A, Power: %d kW", packet->Header.id,
(voltage / 10), (voltage % 10), (current / 10), (current % 10), (power / 10));
}
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)
{
LOG_INFO("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;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].CapabilityVoltage = voltage;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].CapabilityCurrent = current;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].CapabilityPower = power;
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);
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
}
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
}
// LOG_INFO("Cabinet >> Connector %d Availability [SelfTestFail]", packet->Header.id);
// LOG_INFO("Cabinet >> Connector %d Availability [Disable]", packet->Header.id);
// LOG_INFO("Cabinet >> Connector %d Availability [Inoperative]", packet->Header.id);
// LOG_INFO("Cabinet >> Connector %d Availability [Enable]", packet->Header.id);
// LOG_INFO("Cabinet >> Connector %d RemoteStart [%d]", packet->Header.id, misc.Value);
// LOG_INFO("Cabinet >> Connector %d Balance [%d]", packet->Header.id, (misc.Value));
// LOG_INFO("Cabinet >> Dispenser %d PlugTimeout [%d]", dispenserIndex + 1, misc.Value);
// LOG_INFO("Cabinet >> Dispenser %d DefaultPrice [%d]", dispenserIndex + 1, misc.Value);
// LOG_INFO("Cabinet >> Dispenser %d Currency [%d]", dispenserIndex + 1, misc.Value);
// LOG_INFO("Cabinet >> Dispenser %d BackendConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
// LOG_INFO("Cabinet >> Dispenser %d BackendConn [%d]", dispenserIndex + 1, (misc.Value));
// LOG_INFO("Cabinet >> Dispenser %d EthernetConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
// LOG_INFO("Cabinet >> Dispenser %d EthernetConn [%d]", dispenserIndex + 1, (misc.Value));
// LOG_INFO("Cabinet >> Dispenser %d WiFiConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
// LOG_INFO("Cabinet >> Dispenser %d WiFiConn [%d]", dispenserIndex + 1, (misc.Value));
// LOG_INFO("Cabinet >> Dispenser %d TelModemConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
// LOG_INFO("Cabinet >> Dispenser %d TelModemConn [%d]", dispenserIndex + 1, (misc.Value));
// LOG_INFO("Cabinet >> Dispenser %d BillingInfo [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
// LOG_INFO("Cabinet >> Dispenser %d StopButton [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
// LOG_INFO("Cabinet >> Dispenser %d HardReboot [%d]", dispenserIndex + 1, misc.Value);
// LOG_INFO("Cabinet >> Dispenser %d SoftReset [%d]", dispenserIndex + 1, misc.Value);
// LOG_INFO("Cabinet >> Dispenser %d AuthMode [%s]", dispenserIndex + 1, misc.Value ? "Disable" : "Enable");
// LOG_INFO("Cabinet >> Dispenser %d EVCCID [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
// LOG_INFO("Cabinet >> Dispenser %d LEDIntensity [%s]", dispenserIndex + 1, strIntensity[misc.Value]);
// LOG_INFO("Cabinet >> Dispenser %d LEDIntensity [%d]", dispenserIndex + 1, misc.Value);
void MiscCmdRes(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result)
{
char *strConnection[] = {STR_CONN_DISABLE, STR_CONN_CONNECTED, STR_CONN_DISCONNECTED};
char *strIntensity[] = {STR_DARKEST, STR_MEDIUM, STR_BRIGHTEST};
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;
unsigned char IsAvailable = true;
if(ShmSysConfigAndInfo->SysInfo.SelfTestSeq != _STEST_COMPLETE)
{
IsAvailable = false;
LOG_INFO("Cabinet >> Connector %d Availability [SelfTestFail]", packet->Header.id);
}
else if(!ShmChargerInfo->Control.GunAvailable[packet->Header.id - 1])
{
IsAvailable = false;
LOG_INFO("Cabinet >> Connector %d Availability [Disable]", packet->Header.id);
}
else if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.IsAvailable)
{
IsAvailable = false;
LOG_INFO("Cabinet >> Connector %d Availability [Inoperative]", packet->Header.id);
}
else
{
LOG_INFO("Cabinet >> Connector %d Availability [Enable]", packet->Header.id);
}
misc.Value = IsAvailable;
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;
LOG_INFO("Cabinet >> Connector %d RemoteStart [%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;
// LOG_INFO("Cabinet >> 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;
// LOG_INFO("Cabinet >> 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;
LOG_INFO("Cabinet >> Connector %d Balance [%d]", packet->Header.id, (misc.Value));
AddMiscCommand(&sendBuffer, &misc);
}
// announce misc command to first connector of the dispenser
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;
LOG_INFO("Cabinet >> Dispenser %d PlugTimeout [%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;
LOG_INFO("Cabinet >> Dispenser %d DefaultPrice [%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;
LOG_INFO("Cabinet >> Dispenser %d Currency [%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;
if(misc.Value <= _Connnection_Disconnected)
{
LOG_INFO("Cabinet >> Dispenser %d BackendConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
}
else
{
LOG_INFO("Cabinet >> Dispenser %d BackendConn [%d]", dispenserIndex + 1, (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;
if(misc.Value <= _Connnection_Disconnected)
{
LOG_INFO("Cabinet >> Dispenser %d EthernetConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
}
else
{
LOG_INFO("Cabinet >> Dispenser %d EthernetConn [%d]", dispenserIndex + 1, (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;
if(misc.Value <= _Connnection_Disconnected)
{
LOG_INFO("Cabinet >> Dispenser %d WiFiConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
}
else
{
LOG_INFO("Cabinet >> Dispenser %d WiFiConn [%d]", dispenserIndex + 1, (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;
if(misc.Value <= _Connnection_Disconnected)
{
LOG_INFO("Cabinet >> Dispenser %d TelModemConn [%s]", dispenserIndex + 1, strConnection[misc.Value]);
}
else
{
LOG_INFO("Cabinet >> Dispenser %d TelModemConn [%d]", dispenserIndex + 1, (misc.Value));
}
AddMiscCommand(&sendBuffer, &misc);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest = false;
misc.Command = _MiscCmd_Billing;
misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus;
LOG_INFO("Cabinet >> Dispenser %d BillingInfo [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
AddMiscCommand(&sendBuffer, &misc);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest = false;
misc.Command = _MiscCmd_StopButton;
misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton;
LOG_INFO("Cabinet >> Dispenser %d StopButton [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
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;
LOG_INFO("Cabinet >> Dispenser %d HardReboot [%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;
LOG_INFO("Cabinet >> Dispenser %d SoftReset [%d]", dispenserIndex + 1, misc.Value);
AddMiscCommand(&sendBuffer, &misc);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthModeConfigRequest)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthModeConfigRequest = false;
misc.Command = _MiscCmd_AuthDisable;
misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.AuthModeConfig;
LOG_INFO("Cabinet >> Dispenser %d AuthMode [%s]", dispenserIndex + 1, misc.Value ? "Disable" : "Enable");
AddMiscCommand(&sendBuffer, &misc);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EVCCIDConfigRequest)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EVCCIDConfigRequest = false;
misc.Command = _MiscCmd_EVCCIDEnable;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName[0] == 'D' &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName[0] == 'X')
{
misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.AuthModeConfig > 0 ? 0 : 1;
}
else
{
misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EVCCIDConfig;
}
LOG_INFO("Cabinet >> Dispenser %d EVCCID [%s]", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
AddMiscCommand(&sendBuffer, &misc);
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.LEDIntensityRequest)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.LEDIntensityRequest = false;
misc.Command = _MiscCmd_LEDIntensity;
misc.Value = ShmSysConfigAndInfo->SysConfig.LedInfo.Intensity;
if(misc.Value <= _LED_INTENSITY_BRIGHTEST)
{
LOG_INFO("Cabinet >> Dispenser %d LEDIntensity [%s]", dispenserIndex + 1, strIntensity[misc.Value]);
}
else
{
LOG_INFO("Cabinet >> Dispenser %d LEDIntensity [%d]", dispenserIndex + 1, misc.Value);
}
AddMiscCommand(&sendBuffer, &misc);
}
}
}
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
void WriteChargingInfoResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
struct PACKET_STRUCTURE sendBuffer;
unsigned short voltage = 0, current = 0;
unsigned char gun = packet->Header.id - 1;
#if 0
// for safety test
voltage = (unsigned short)(chargingInfo[gun]->PresentChargingVoltage * 10);
current = (unsigned short)(chargingInfo[gun]->PresentChargingCurrent * 10);
voltage -= ((current * 8 * 10) / 10000);
#endif
if(chargingInfo[gun]->PantographFlag == YES)
{
voltage = (unsigned short)(chargingInfo[gun]->PresentChargingVoltage * 10);
current = (unsigned short)(chargingInfo[gun]->PresentChargingCurrent * 10);
}
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 = 6;
sendBuffer.Payload.reg = _Reg_Charging_Info;
sendBuffer.Payload.data[0] = result;
sendBuffer.Payload.data[1] = (voltage >> 8) & 0xFF;
sendBuffer.Payload.data[2] = (voltage >> 0) & 0xFF;
sendBuffer.Payload.data[3] = (current >> 8) & 0xFF;
sendBuffer.Payload.data[4] = (current >> 0) & 0xFF;
SendPacket(socket, &sendBuffer);
}
int GetChargerSystemId(char *id)
{
int len = 0;
strcpy((char *)id, "");
if(ShmChargerInfo->Control.CustomerCode != _CUSTOMER_CODE_Audi)
{
ShmChargerInfo->AuthInfo.QRCodeMode = ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode;
}
switch(ShmChargerInfo->AuthInfo.QRCodeMode)
{
case _QR_MODE_Customized:
strcpy((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
break;
case _QR_MODE_ChargeBoxId:
strcpy((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
break;
case _QR_MODE_Default:
default:
strcat((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.SystemId);
break;
}
len = strlen((char *)id);
return len;
}
void ChargerSystemIdResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result)
{
struct PACKET_STRUCTURE sendBuffer;
char system_id[128];
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 = GetChargerSystemId(system_id);
memcpy(&sendBuffer.Payload.data[sendBuffer.Header.len - 1], (char *)system_id, 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;
//LOG_INFO("Dispenser %d Read System Id: %s", dispenserIndex + 1, ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
}
SendPacket(socket, &sendBuffer);
}
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;
SendPacket(socket, &sendBuffer);
}
void GroundFaultDetectionResponse(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_GroundFaultDetection;
sendBuffer.Payload.data[0] = result;
sendBuffer.Payload.data[1] = result == _R_OK ? chargingInfo[packet->Header.id - 1]->GroundFaultStatus : GFD_WAIT;
SendPacket(socket, &sendBuffer);
}
void CabinetCSUVersionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
struct PACKET_STRUCTURE sendBuffer;
char version[64];
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 = 194;
sendBuffer.Payload.reg = _Reg_Get_Cabinet_CSU_Version;
sendBuffer.Payload.data[0] = result;
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysConfig.ModelName[0]);
memcpy(&sendBuffer.Payload.data[1], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.CsuBootLoadFwRev[0]);
memcpy(&sendBuffer.Payload.data[33], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev[0]);
memcpy(&sendBuffer.Payload.data[65], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[0]);
memcpy(&sendBuffer.Payload.data[97], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.CsuPrimFwRev[0]);
memcpy(&sendBuffer.Payload.data[129], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress[0]);
memcpy(&sendBuffer.Payload.data[161], version, 32);
SendPacket(socket, &sendBuffer);
}
void CabinetOtherVersionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
struct PACKET_STRUCTURE sendBuffer;
char version[64];
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 = 98;
sendBuffer.Payload.reg = _Reg_Get_Cabinet_Other_Version;
sendBuffer.Payload.data[0] = result;
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev[0]);
memcpy(&sendBuffer.Payload.data[1], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev[0]);
memcpy(&sendBuffer.Payload.data[33], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmSysConfigAndInfo->SysInfo.FanModuleFwRev[0]);
memcpy(&sendBuffer.Payload.data[65], version, 32);
SendPacket(socket, &sendBuffer);
}
void PsuQuantityResponse(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_Get_Psu_Quantity;
sendBuffer.Payload.data[0] = result;
sendBuffer.Payload.data[1] = ShmPsuData->SystemPresentPsuQuantity;
SendPacket(socket, &sendBuffer);
}
void PsuVersionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result, int psuIndex)
{
struct PACKET_STRUCTURE sendBuffer;
char version[64];
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_Get_Psu_Version;
sendBuffer.Payload.data[0] = result;
sendBuffer.Payload.data[1] = psuIndex;
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmPsuData->PsuVersion[psuIndex].FwPrimaryVersion[0]);
memcpy(&sendBuffer.Payload.data[2], version, 32);
memset(version, 0x00, sizeof(version));
strcpy(version, (char *)&ShmPsuData->PsuVersion[psuIndex].FwSecondVersion[0]);
memcpy(&sendBuffer.Payload.data[34], version, 32);
SendPacket(socket, &sendBuffer);
}
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)
{
// 20210817 remove type "R"
//char modelList[11] = {'J', 'U', 'V', 'E', 'F', 'G', 'T', 'D', 'K', 'P'};
//unsigned char typeList[11] = { 0, 1, 1, 1, 1, 2, 1, 1, 0, 1}; // 0 : Chademo, 1: CCS, 2: GB
switch(physical)
{
case 'J':
case 'K':
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':
case 'P':
//case 'R': // 20210817 remove type "R"
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_LIQUID_MAX_CURRENT;
break;
case 'T':
case 'D':
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_NATURAL_REMA_MAX_CURRENT;
break;
default:
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = 0;
break;
}
}
void ConnectorPantographBindingHandler(unsigned char connectorIndex, unsigned char physical)
{
switch(physical)
{
case 'P':
chargingInfo[connectorIndex]->PantographFlag = YES;
break;
default:
chargingInfo[connectorIndex]->PantographFlag = NO;
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]);
ConnectorPantographBindingHandler(gunIndex, physicalType[i]);
LOG_INFO("Dispenser %d Connector %d type: %s, MaxVol: %4d, MaxCur: %4d, %s",
dispenserIndex + 1, gunIndex + 1, str_gun_type[type[i]],
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalVoltage,
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalCurrent,
chargingInfo[gunIndex]->PantographFlag == YES ? "Pantograph" : "Normal");
}
}
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++;
connector += ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity;
}
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity != dispenser ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity != connector)
{
change = true;
}
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity = dispenser;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity = connector;
if(change)
{
LOG_INFO("Total Dispenser: %d, Total Connector: %d\n",
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity,
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity);
}
}
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;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[currentQuantity - 1].GeneralChargingData.Index = currentQuantity - 1;
}
}
BOOL CheckNewDispenserSequence(unsigned char index, unsigned char quantity)
{
if(index == ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence)
{
LOG_INFO("Get New Dispenser %d, Connector Quantity: %d\n", index + 1, quantity);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << index);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[index] = quantity;
ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence = index + 1;
ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity += quantity;
ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[index] = quantity;
ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.FlashConfigChanged = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;
return true;
}
return false;
}
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.ConnectorLog[dispenserIndex] != 0 &&
quantity != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex])
{
LOG_INFO("The same dispenser id (%d) but connector quantity not match", dispenserIndex + 1);
return false;
}
if(dispenserIndex == ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence &&
(quantity + ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity) > ShmChargerInfo->Control.MaxConnector)
{
LOG_INFO("Dispenser %d connector quantity %d over range, total quantity: %d",
dispenserIndex + 1, quantity, ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity);
return false;
}
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_None ||
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout)
{
CheckNewDispenserSequence(dispenserIndex, quantity);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Identification;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity = quantity;
SetConnectorID(dispenserIndex, quantity);
memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, packet->Payload.data, (packet->Header.len - 2));
ConnectorTypeBindingHandler(dispenserIndex, connectorType, physicalType);
LOG_INFO("Dispenser id %d identified, Connector quantity: %d\n", dispenserIndex + 1, quantity);
DispenserCheckInInfoUpdate();
return true;
}
else
{
LOG_INFO("Conflict dispenser ID: %d", dispenserIndex + 1);
}
}
else
{
LOG_INFO("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);
}
}
LOG_INFO("%s", 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;
}
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, power = 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)
{
LOG_INFO("Connector %d Remote Voltage: %d, Remote Current: %d", packet->Header.id, voltage, current);
}
}
GetPhysicalLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, ¤t);
GetModelNameLimitPower(packet->Header.id - 1, &power);
GetConfigLimitPowerAndCurrent(packet->Header.id - 1, &power, ¤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;
LOG_INFO("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);
LOG_INFO("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)
{
LOG_INFO("Connector %d Target Voltage: %d V, Current: %d A",
packet->Header.id, (int)(targetVol), (int)(targetCur));
}
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)
{
LOG_INFO("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;
LOG_INFO("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;
LOG_INFO("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])
{
LOG_INFO("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;
unsigned char GunTemp = 0;
unsigned char ChillerTemp = 0;
unsigned char noAlarm[6];
memset(noAlarm, 0x00, 6);
if(find)
{
ConnectionState = packet->Payload.data[0];
AlarmCode = packet->Header.len >= 8 ? &packet->Payload.data[1] : &noAlarm[0];
GunTemp = packet->Header.len >= 10 ? packet->Payload.data[7] : GunTemp;
ChillerTemp = packet->Header.len >= 10 ? packet->Payload.data[8] : ChillerTemp;
chargingInfo[packet->Header.id - 1]->ConnectorTemp = GunTemp;
chargingInfo[packet->Header.id - 1]->ChillerTemp = ChillerTemp;
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != ConnectionState)
{
LOG_INFO("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)
{
if(chargingInfo[packet->Header.id - 1]->SystemStatus != S_IDLE)
{
LOG_INFO("*********** 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)
{
LOG_INFO("*********** 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)
{
LOG_INFO("*********** 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;
}
AuthorizingInfoData preGunAuthInfo[GENERAL_GUN_QUANTITY];
AuthorizingInfoData preDispenserAuthInfo[GENERAL_GUN_QUANTITY];
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;
AuthorizingInfoData *AuthInfo;
AuthorizingInfoData *preAuthInfo;
int length = 0;
if(find || packet->Header.id == AUTO_GUN_SELECTION)
{
length = packet->Header.len - 1;
memset(CardNumber, 0x00, sizeof(CardNumber));
memcpy(CardNumber, packet->Payload.data, length);
if(packet->Header.id != AUTO_GUN_SELECTION)
{
//result = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizingResult;
AuthInfo = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthInfo;
preAuthInfo = &preGunAuthInfo[packet->Header.id - 1];
}
else
{
//result = &ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthResult;
AuthInfo = &ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthInfo;
preAuthInfo = &preDispenserAuthInfo[dispenserIndex];
}
//if(*result == _AuthResult_Valid)
if(AuthInfo->AuthResult == _AuthResult_Valid)
{
if(preAuthInfo->AuthResult != AuthInfo->AuthResult)
{
LOG_INFO("Dispenser %d Target %d user id %s authorizing ok", dispenserIndex + 1, packet->Header.id, CardNumber);
}
authorize = _DAS_Allowed;
}
//else if(*result == _AuthResult_Invalid)
else if(AuthInfo->AuthResult == _AuthResult_Invalid)
{
if(preAuthInfo->AuthResult != AuthInfo->AuthResult)
{
LOG_INFO("Dispenser %d Target %d user id %s authorizing fail", dispenserIndex + 1, packet->Header.id, CardNumber);
}
authorize = _DAS_NotAllowed;
}
else
{
if(AuthInfo->AuthStatus == _AuthorizeStatus_Idle && AuthInfo->AuthRequest == NO)
{
memcpy(AuthInfo->AuthId, CardNumber, sizeof(CardNumber));
AuthInfo->AuthTarget = packet->Header.id;
AuthInfo->AuthRequest = YES;
if(AuthInfo->AuthTarget != AUTO_GUN_SELECTION)
{
LOG_INFO("Gun %d user id [%s] need authorize", packet->Header.id, CardNumber);
}
else
{
LOG_INFO("Dispenser %d user id [%s] need authorize", dispenserIndex + 1, CardNumber);
}
authorize = _DAS_Wait;
}
else
{
authorize = _DAS_Wait;
}
}
preAuthInfo->AuthResult = AuthInfo->AuthResult;
}
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)
{
LOG_INFO("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)
{
LOG_INFO("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;
LOG_INFO("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;
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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)
{
LOG_INFO("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
{
LOG_INFO("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;
// LOG_INFO("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)
{
LOG_INFO("********** Dispenser id %d: Csu Version information **********", dispenserIndex + 1);
LOG_INFO("********** CsuBootLoadRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev);
LOG_INFO("********** CsuKernelFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev);
LOG_INFO("********** CsuRootFsFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev);
LOG_INFO("********** 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)
{
LOG_INFO("********** Dispenser id %d: Other Version information **********", dispenserIndex + 1);
LOG_INFO("********** FanModuleFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev);
LOG_INFO("********** RelayModuleRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev);
LOG_INFO("********** Connector1Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev);
LOG_INFO("********** Connector2Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev);
LOG_INFO("********** 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);
unsigned char gun = 0;
if(find)
{
gun = packet->Header.id - 1;
unsigned short diffVoltage = 0, diffCurrent = 0;
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]);
diffVoltage = voltage >= ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage ?
voltage - ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage :
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage - voltage;
diffCurrent = current >= ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent ?
current - ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent :
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent - current;
if(diffVoltage > 10 || diffCurrent > 10 || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteSoc != soc)
{
LOG_INFO("Connector %d Charging Info: Voltage: %4d.%d V, Current: %3d.%d A, Soc: %3d, Temp: %3d, Chiller: %3d",
packet->Header.id, (voltage / 10), (voltage % 10), (current / 10), (current % 10), soc,
chargingInfo[gun]->ConnectorTemp - 60, chargingInfo[gun]->ChillerTemp - 60);
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage = voltage;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent = current;
//ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteRemainChargingDuration = time;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteSoc = soc;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].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(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_AUTHORIZING)
{
if(StartWait)
{
if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug)
{
LOG_INFO("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)
{
LOG_INFO("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
{
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = false;
}
}
else
{
}
return find;
}
unsigned char GroundFaultDetectionHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);
unsigned char gun = 0;
if(find)
{
gun = packet->Header.id - 1;
unsigned char enable = packet->Payload.data[0];
if(chargingInfo[gun]->PantographFlag == YES)
{
if(enable == _GFD_Enable &&
(chargingInfo[gun]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[gun]->SystemStatus <= S_CHARGING))
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection != _GFD_Enable)
{
LOG_INFO("Connector %d Gfd Detection Start", gun + 1);
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection = _GFD_Enable;
}
else
{
if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection != _GFD_Disable)
{
LOG_INFO("Connector %d Gfd Detection Stop", gun + 1);
}
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection = _GFD_Disable;
}
}
}
else
{
}
return find;
}
unsigned char GetCabinetCSUVersionHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
return true;
}
unsigned char GetCabinetOtherVersionHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
return true;
}
unsigned char GetPsuQuantityHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
return true;
}
unsigned char GetPsuVersionHandler(struct PACKET_STRUCTURE *packet, int *psuIndex)
{
*psuIndex = 0;
if(packet->Payload.data[0] <= ShmPsuData->SystemPresentPsuQuantity && packet->Payload.data[0] > 0)
{
*psuIndex = packet->Payload.data[0] - 1;
}
return true;
}
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;
LOG_INFO("IP %s connection(%d) is established, start dispenser process, PID = %d", (inet_ntoa(clientInfo.sin_addr)), index, getpid());
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 &&
dispenserID <= ShmChargerInfo->Control.MaxDispenser)
{
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;
LOG_INFO("********** Dispenser id %d check in, model name: %s **********\n", dispenserID, modelName);
memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, modelName, 64);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectionChannel = index;
ackResult = _R_OK;
}
else
{
// response NG: gun quantity fail
LOG_INFO("Dispenser ID %d Identification Fail", dispenserID);
}
}
else
{
// response NG: dispenser Index fail
LOG_INFO("Dispenser ID %d Fail, Need Wait Another Dispenser", dispenserID);
}
}
else
{
LOG_INFO("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;
}
LOG_INFO("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;
LOG_INFO("Dispenser ID %d Configuration Need To Synchronize", dispenserID);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthModeConfigRequest = true;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EVCCIDConfigRequest = true;
for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++)
{
unsigned char gun = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] - 1;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.AvailabilityRequest = true;
}
}
}
}
// 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;
}
MiscCmdRes(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);
}
// Reg: 0x12, Ground Fault Detection
if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_GroundFaultDetection)
{
if(GroundFaultDetectionHandler(&receiveBuffer, dispenserIndex))
{
ackResult = _R_OK;
}
GroundFaultDetectionResponse(socketFd, &receiveBuffer, ackResult);
}
// Reg: 0x13, Get Cabinet CSU Version
if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Get_Cabinet_CSU_Version)
{
if(GetCabinetCSUVersionHandler(&receiveBuffer, dispenserIndex))
{
ackResult = _R_OK;
}
CabinetCSUVersionResponse(socketFd, &receiveBuffer, ackResult);
}
// Reg: 0x14, Get Cabinet Other Version
if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Get_Cabinet_Other_Version)
{
if(GetCabinetOtherVersionHandler(&receiveBuffer, dispenserIndex))
{
ackResult = _R_OK;
}
CabinetOtherVersionResponse(socketFd, &receiveBuffer, ackResult);
}
// Reg: 0x15, Get Psu Quantity
if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Get_Psu_Quantity)
{
if(GetPsuQuantityHandler(&receiveBuffer, dispenserIndex))
{
ackResult = _R_OK;
}
PsuQuantityResponse(socketFd, &receiveBuffer, ackResult);
}
// Reg: 0x15, Get Psu Version
if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Get_Psu_Version)
{
int _PsuIndex = 0;
if(GetPsuVersionHandler(&receiveBuffer, &_PsuIndex))
{
ackResult = _R_OK;
}
PsuVersionResponse(socketFd, &receiveBuffer, ackResult, _PsuIndex);
}
}
// clean timeout
timeout = 0;
}
}
else
{
timeout += SOCKET_RECEIVE_INTERVAL;
usleep((SOCKET_RECEIVE_INTERVAL * 1000));
}
if(timeout >= DISPENSER_SOCKET_TIMEOUT || ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DuplicateIp)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DuplicateIp)
{
LOG_INFO("Dispenser %d has been kick", dispenserIndex + 1);
}
else
{
//timeout
LOG_INFO("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)
{
int dispenser = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.DuplicateIp == false)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.DuplicateIp = true;
}
return true;
}
}
return false;
}
void InitDispenserInfo(void)
{
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
bool disconnect = false;
//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;
disconnect = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.Value = 0;
ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection = disconnect;
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.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity = 0;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity = 0;
for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
{
unsigned char localStatus = 0;
localStatus = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus;
memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i], 0x00, sizeof(struct DispenserModule));
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus = localStatus;
}
// initial CheckInLog from WiringInfo.DispenserSequence
ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status = 0;
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << i);
}
// initial ConnectorLog from WiringInfo.WiringSetting
memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog, 0x00, sizeof(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog));
for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
{
if(i < GENERAL_GUN_QUANTITY)
{
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i] = ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i];
}
}
memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo, 0x00, sizeof(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo));
ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout = 0;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice = 0;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency = ShmSysConfigAndInfo->SysConfig.BillingData.Currency;
}
struct timespec _IpConflicted_time[CONNECTOR_QUANTITY];
void DispenserIpConflictedCheck(void)
{
while(1)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIp)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm == NO)
{
GetClockTime(&_IpConflicted_time[i]);
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm = true;
LOG_INFO("Dispenser %d IP Conflicted Confirm", i + 1);
}
else
{
if((GetTimeoutValue(_IpConflicted_time[i]) / mSEC_VAL) >= IP_CONFLICTED_TIME)
{
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
{
unsigned char channel = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectionChannel;
if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[channel].Status != _CNS_FREE)
{
LOG_INFO("Dispenser %d IP Conflicted Stop", i + 1);
DisableConnector(i);
memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i], 0x00, sizeof(struct DispenserModule));
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus = _DS_Timeout;
DispenserCheckInInfoUpdate();
memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[channel], 0x00, sizeof(struct ConnectionInfoData));
}
}
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIp = false;
ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm = false;
LOG_INFO("Dispenser %d IP Conflicted Clean", i + 1);
}
}
}
}
usleep(500000);
}
}
void ForkIpConflictedCheck(void)
{
pid_t forkId;
forkId = fork();
if(forkId == 0)
{
DispenserIpConflictedCheck();
return;
}
else if(forkId == -1)
{
LOG_INFO("fork fail");
}
}
int tcpSocketServerStart(void)
{
int sockFd = 0;
int clientSockFd = 0;
int connectIndex = 0;
int bindStatus = 0;
int reuseaddr = 1;
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)
{
LOG_INFO("InitSocketServer NG\n");
sleep(5);
return FAIL;
}
setsockopt(sockFd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
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);
bindStatus = bind(sockFd, (struct sockaddr *)&serverInfo, sizeof(serverInfo));
if(bindStatus < 0)
{
LOG_INFO("socket bind fail");
return FAIL;
}
listen(sockFd, CONNECTION_LIMIT);
LOG_INFO("Dispenser TCP Server Start");
signal(SIGCHLD, SIG_IGN);
ForkIpConflictedCheck();
// 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);
}*/
LOG_INFO("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 0;
}
else if(forkId == -1)
{
LOG_INFO("fork fail");
}
}
else
{
// conflict ip address
LOG_INFO("Conflict IP address, close socket");
close(clientSockFd);
memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex], 0x00, sizeof(struct ConnectionInfoData));
}
}
else
{
// no free channel
LOG_INFO("No free channel, close socket");
close(clientSockFd);
}
usleep(10000);
}
return 0;
}
void InitialConnector(void)
{
for(int i = 0; i < CONNECTOR_QUANTITY; i++)
{
chargingInfo[i] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData;
}
}
int main(void)
{
if(InitShareMemory() == FAIL)
{
#ifdef SystemLogMessage
LOG_ERROR("InitShareMemory NG");
#endif
sleep(5);
return 0;
}
InitialConnector();
// wait for self test completed
while(ShmSysConfigAndInfo->SysInfo.BootingStatus == BOOTTING ||
ShmChargerInfo->Control.CabinetRole == _CROLE_SLAVE)
{
sleep(1);
}
tcpSocketServerStart();
//tcpSocketClientStart();
return 0;
}