csu3_am335x/EVSE/Projects/DS60-120/Apps/Config.h

/*
 * Config.h
 *
 *  Created on: 2019年4月23日
 *      Author: foluswen
 */
#ifndef CONFIG_H_
#define CONFIG_H_

#include    <sys/types.h>

#define ShmCsuMeterKey			2001
#define ShmCommonKey			2002

typedef unsigned char			byte;

#define TOTAL_QUANTITY_GUN			4				//Max Count
#define PSU_GROUP_COUNT				4
#define DC_CONNECTOR_COUNT			2
#define AC_CONNECTOR_COUNT			1
#define VOLTAGE_SAMPLE_COUNT		30

#define GFD_WAIT			0
#define GFD_PASS			1
#define GFD_FAIL			2
#define GFD_WARNING			3

#define PRECHARGE_WAIT				0
#define PRECHARGE_READY				1
#define PRECHARGE_PRERELAY_PASS		2
#define PRECHARGE_CHARELAY_PASS		3

#define BOOTTING			0
#define BOOT_COMPLETE		1

#define	AC_MINIMUM_DUTY			6
#define	AC_STOP_DUTY			100

#define GUN_LEFT			0
#define GUN_RIGHT			1
#define GUN_CHECK			255

//=======================================
// Price type
//=======================================
#define DEFAULT_VALUE						0
#define CONNECTION_FEE						1
#define CURRENT_RATE						2
#define OCCUPANCY_FEE						3
#define SESSION_FEE							4
#define TOTAL_COST							5
#define ACCOUNT_BALANCE						6

enum _AC_SYSTEM_STATUS
{
	AC_SYS_NONE = 	0,
	AC_SYS_A,
	AC_SYS_B,
	AC_SYS_C,
	AC_SYS_D,
	AC_SYS_E,
	AC_SYS_F
};

enum _GUN_TYPE
{
	_Type_Chademo 	= 0,
	_Type_CCS		= 1,
	_Type_GB		= 2,
	_Type_AC		= 3,
	_Type_Test		= 9
};

enum _CCS_TYPE
{
	_CCS_TYPE_CCS1 = 	0,
	_CCS_TYPE_CCS2 = 	1,
};

enum _LCM_INDEX
{
	_LCM_INIT = 			0x00,
	_LCM_IDLE = 			0x01,
	_LCM_AUTHORIZING = 		0x02,
	_LCM_AUTHORIZ_COMP = 	0x03,
	_LCM_AUTHORIZ_FAIL = 	0x04,
	_LCM_WAIT_FOR_PLUG = 	0x05,
	_LCM_PRE_CHARGE = 		0x06,
	_LCM_CHARGING = 		0x07,
	_LCM_COMPLETE = 		0x08,
	_LCM_FIX = 				0x09,
	_LCM_EMC = 				0x0A,
	_LCM_NONE = 			0xFF,
};

enum _SELF_TEST_SEQ
{
	_STEST_VERSION = 0x00,
	_STEST_AC_CONTACTOR = 0x01,
	_STEST_PSU_DETECT = 0x02,
	_STEST_PSU_CAP = 0x03,
	_STEST_FAIL = 0x04,
	_STEST_COMPLETE = 0xEE,
};

enum _MODULE_PSU_WORK_STEP
{
	INITIAL_START 		= 		0,
	GET_PSU_COUNT 		= 		1,
	GET_SYS_CAP			=		2,
	BOOTING_COMPLETE 	= 		3,

	_WORK_CHARGING 		= 		10,

	_TEST_MODE			=		20,
	_ALATON_MODE		= 		21,

	_NO_WORKING			= 		254
};

enum _OFFLINE_POLICY
{
	_OFFLINE_POLICY_LOCAL_LIST = 0x00,
	_OFFLINE_POLICY_PHIHONG_RFID_TAG = 0x01,
	_OFFLINE_POLICY_FREE_CHARGING = 0x02,
	_OFFLINE_POLICY_NO_CHARGING = 0x03,
};

enum _MAIN_CHARGING_MODE
{
	_MAIN_CHARGING_MODE_NORMAL	 	= 0,
	_MAIN_CHARGING_MODE_BOTH 		= 1,
};

enum _EXTRA_ERR_PROCESS
{
	_EXTRA_ERR_PROCESS_NONE = 0,
	_EXTRA_ERR_PROCESS_INUVP = 1,
	_EXTRA_ERR_PROCESS_INOVP = 2
};

enum _CHARGER_TYPE
{
	_CHARGER_TYPE_IEC = 0,
	_CHARGER_TYPE_UL = 1,
	_CHARGER_TYPE_JARI = 2 //LWADD
};

enum _SYS_WIFI_MODE
{
	_SYS_WIFI_MODE_DISABLE = 0,
	_SYS_WIFI_MODE_STATION = 1,
	_SYS_WIFI_MODE_AP = 2
};

enum _SYS_4G_MODE
{
	_SYS_4G_MODE_DISABLE = 0,
	_SYS_4G_MODE_ENABLE = 1,
};

enum _LED_INTENSITY_LV
{
	_LED_INTENSITY_DARKEST 	 = 0,
	_LED_INTENSITY_MEDIUM 	 = 1,
	_LED_INTENSITY_BRIGHTEST = 2
};

enum _UPDATE_TYPE
{
	_UPDATE_TYPE_CSU_UBOOT 	 	= 0x10000001,
	_UPDATE_TYPE_CSU_DTB 	 	= 0x10000002,
	_UPDATE_TYPE_CSU_ZIMAGE 	= 0x10000003,
	_UPDATE_TYPE_CSU_RFILES 	= 0x10000004,
	_UPDATE_TYPE_CSU_CONFIG 	= 0x10000005,

	_UPDATE_TYPE_CCS_UBOOT 	 	= 0x10000007,
	_UPDATE_TYPE_CCS_DTB 		= 0x10000008,
	_UPDATE_TYPE_CCS_ZIMAGE 	= 0x10000009,
	_UPDATE_TYPE_CCS_RFILES 	= 0x1000000A,

	_UPDATE_TYPE_DCM_ST407 		= 0x10000006,
	_UPDATE_TYPE_RELAY_CTR 		= 0x1000000D,
	_UPDATE_TYPE_FAN_CTR 		= 0x1000000E,
	_UPDATE_TYPE_AC_WLMOUNT_CTR = 0x20000002,
	_UPDATE_TYPE_LED_CTR		= 0x10000014,

	_UPDATE_TYPE_CHADEMO 		= 0x1000000B,
	_UPDATE_TYPE_GBT			= 0x1000000C,

	_UPDATE_TYPE_DWIN_LCM		= 0x1000000F,
};

enum _CCS_COMM_PROTOCOL
{
	_CCS_COMM_V2GMessage_DIN70121 		= 0x01,
	_CCS_COMM_V2GMessage_ISO15118_2014 	= 0x02,
	_CCS_COMM_V2GMessage_ISO15118_2018 	= 0x03
};

enum _ETHERNET_USAGE
{
	_ETHERNET_USAGE_NONE 	= 0,
	_ETHERNET_USAGE_LAN,
	_ETHERNET_USAGE_WIFI,
	_ETHERNET_USAGE_3G_4g
};

enum _PRIMARY_CHECK_TAG
{
	_PRIMARY_CHECK_TAG_AC_CONTACT		= 0,
	_PRIMARY_CHECK_TAG_MAIN_BREAKER		= 1,
};

enum _ALARM_LEVEL_TAG
{
	_ALARM_LEVEL_NORMAL 		= 0,
	_ALARM_LEVEL_WARNING		= 1,
	_ALARM_LEVEL_CRITICAL		= 2
};

enum _SYSTEM_TASK_LOST_ITEM
{
	_SYSTEM_TASK_LOST_ITEM_MAIN 		= 1,
	_SYSTEM_TASK_LOST_ITEM_EVCOMM 		= 2,
	_SYSTEM_TASK_LOST_ITEM_PSUCOMM		= 3,
	_SYSTEM_TASK_LOST_ITEM_EVENTLOG		= 4,
	_SYSTEM_TASK_LOST_ITEM_PRIMARYCOMM	= 5,
	_SYSTEM_TASK_LOST_ITEM_LCMCONTROL	= 6,
	_SYSTEM_TASK_LOST_ITEM_INTERCOMM	= 7,
	_SYSTEM_TASK_LOST_ITEM_SMARTBOX		= 8
};

enum _PSU_PROTOCOL_TYPE
{
	_PSU_PROTOCOL_INFY 					= 0,
	_PSU_PROTOCOL_UU					= 1
};

enum _PSU_USING_TARGET
{
	_PSU_USING_TARGET_CON1		= 0x00,
	_PSU_USING_TARGET_CON2		= 0x01,
	_PSU_USING_TARGET_READY		= 0xFF,
};

enum _PSU_POWER_STATUS
{
	_PSU_POWER_STATUS_OFF		= 0x00,
	_PSU_POWER_STATUS_ON		= 0x01,
};

enum _PSU_DYNAMIC_FETCH_STEP
{
	_PSU_DYNAMIC_FETCH_STEP_NONE			= 0x00,
	_PSU_DYNAMIC_FETCH_STEP_WAIT			= 0x01,
	_PSU_DYNAMIC_FETCH_STEP_TG_VOL			= 0x02,
	_PSU_DYNAMIC_FETCH_STEP_RELAY			= 0x03,
	_PSU_DYNAMIC_FETCH_STEP_CUR_SHARE		= 0x04,
	_PSU_DYNAMIC_FETCH_STEP_WATI_FINISH		= 0x05,
	_PSU_DYNAMIC_FETCH_STEP_FINISH			= 0x06,
	_PSU_DYNAMIC_FETCH_STEP_ABORT			= 0x10,
};

enum _PSU_DYNAMIC_RELEASE_STEP
{
	_PSU_DYNAMIC_RELEASE_STEP_NONE			= 0x00,
	_PSU_DYNAMIC_RELEASE_STEP_WAIT			= 0x01,
	_PSU_DYNAMIC_RELEASE_STEP_LIMIT			= 0x02,
	_PSU_DYNAMIC_RELEASE_STEP_CUR_SHARE		= 0x03,
	_PSU_DYNAMIC_RELEASE_STEP_RELAYOFF		= 0x04,
	_PSU_DYNAMIC_RELEASE_STEP_WAIT_FINISH 	= 0x05,
	_PSU_DYNAMIC_RELEASE_STEP_FINISH		= 0x06,
	_PSU_DYNAMIC_RELEASE_STEP_ABORT			= 0x10,
};

enum _PSU_GROUP_INDEX
{
	_PSU_GROUP_INDEX_0	= 0x00,
	_PSU_GROUP_INDEX_1	= 0x01,
	_PSU_GROUP_INDEX_2	= 0x02,
	_PSU_GROUP_INDEX_3	= 0x03,
};

enum _RELAY_SWITCH_NAME
{
	_RELAY_SWITCH_NAME_R3		= 0x00,
	_RELAY_SWITCH_NAME_R4		= 0x01,
	_RELAY_SWITCH_NAME_R5		= 0x02,
};

struct StructMeter
{
	float curMeterValue;
	float newMeterValue;
	byte isCalculation;
	float _chargingValue;
	float _curTotalCharging;
};

struct MeterInformation
{
	struct StructMeter _meter[DC_CONNECTOR_COUNT];
	byte isWorking;
};

//struct ConnectorBalanceInfo
//{
//	unsigned int UserPrice; // connector user's user price, unit: 0.01 (dollar / kWh)
//	unsigned int TotalCost; // connector user's total cost, unit: 0.01 dollar
//	int AccountBalance; // connector user's account balance, unit: 0.01 dollar
//};
//
//struct BalanceInfo
//{
//	unsigned int defaultPrice;
//	struct ConnectorBalanceInfo connectorBalanceInfo[3]; // Max count : DC * 2 + AC * 1
//};

struct ConnectorBalanceInfo
{
	unsigned int UserPrice; // connector user's user price, unit: 0.01 (dollar / kWh)
	unsigned int TotalCost; // connector user's total cost, unit: 0.01 dollar
	int AccountBalance; // connector user's account balance, unit: 0.01 dollar
};

struct BalanceInfo
{
	//CTEP
	char defaultPrice[250];
	unsigned int defaultPrice_Noodoe;
	struct ConnectorBalanceInfo connectorBalanceInfo[3]; // Max count : DC * 2 + AC * 1
};

struct ChademoTryCommunicationKey
{
	byte try2CommunicationFlag;
	struct timespec detectTimer;
	byte elapsedTime;
};

struct GbtVincodeInfo
{
	byte packageCount;
	int dataLen;
	byte data[18];
	byte checksum;
};

struct CdfaInfor
{
	double _ctepEnergyCost;
	double _ctepParkingFee;
	double _ctepTotalCost;

	// 2.0 Needed
	byte _preTimestamp[36];
	float _preOutputEnergy;
	float _prekWhPrice;
	float _prehourPrice;
	double _preEnergyCost;
	double _preParkingFee;
	byte _preQrCodeText[1024];
};

enum _CCS_VERSION_CHECK_TAG
{
	_CCS_VERSION_CHECK_TAG_V015S0		= 0,
	_CCS_VERSION_CHECK_TAG_V013S0		= 1,
};

enum RELAY_STATUS_ERROR_INDEX
{
	RELAY_SMR1_P_STATUS = 	0,
	RELAY_SMR1_N_STATUS = 	1,
	RELAY_SMR2_P_STATUS = 	2,
	RELAY_SMR2_N_STATUS = 	3,
	RELAY_PARA_P_STATUS = 	4,
	RELAY_PARA_N_STATUS = 	5,
	RELAY_PRE_STATUS =		6
};

enum RELAY_STATUS_ERROR_TYPE
{
	RELAY_STATUS_ERROR_NONE = 0,
	RELAY_STATUS_ERROR_WELDING = 10,
	RELAY_STATUS_ERROR_DRIVING = 11,
	RELAY_STATUS_ERROR_PARA_WELDING = 12,
	RELAY_STATUS_ERROR_PARA_DRIVING = 13,
};

enum START_TRANSATION_STATUS
{
	START_TRANSATION_STATUS_WAIT = 0x00,
	START_TRANSATION_STATUS_PASS = 0x01,
	START_TRANSATION_STATUS_FAIL = 0x02,
};

enum CHARGER_TYPE
{
	CHARGER_TYPE_STANDARD 	= 0x00,
	CHARGER_TYPE_SIMPLE 	= 0X01,
};

enum RESET_4G_STEP
{
	RESET_4G_STEP_NONE 				= 0x00,
	RESET_4G_STEP_DELETE_TASK 		= 0x01,
	RESET_4G_STEP_GPIO_HIGH			= 0x02,
	RESET_4G_STEP_GPIO_LOW_COMP		= 0x03
};

enum _CCID_INDEX
{
	_CCID_GET 		= 0x01,
	_CCID_CHECK		= 0x02,
	_CCID_AUTH		= 0x03,
	_CCID_AUTHCOMP	= 0x04,
	_CCID_AUTHFAIL	= 0x05,
	_CCID_NONE 		= 0xFF,
};

enum _CONNECTOR_STATUS
{
	_CONNECTOR_STATUS_NONE 		= 0x00,
	_CONNECTOR_STATUS_WAIT		= 0x01,
	_CONNECTOR_STATUS_USING		= 0x02,
};

enum _SYSTEM_TYPE
{
	_SYSTEM_TYPE_SIMPLE 		= 0x00,
	_SYSTEM_TYPE_STANDARD		= 0x01,
	_SYSTEM_TYPE_SMART			= 0x10
};

enum _TPC_PLUG_DETECT_STATUS
{
	_TPC_PLUG_DETECT_STATUS_NONE 		= 0x00,
	_TPC_PLUG_DETECT_STATUS_WAIT		= 0x01,
};

enum VERIFY_MECHANISM
{
	VERIFY_MECHANISM_RFID 		= 0,
	VERIFY_MECHANISM_BAZEL8		= 1,
	VERIFY_MECHANISM_ENEGATE	= 2
};

enum _LCM_UPGRADE_RESULT
{
	_LCM_UPGRADE_RESULT_WAIT	= 0,
	_LCM_UPGRADE_RESULT_PASS,
	_LCM_UPGRADE_RESULT_FAIL,
};

enum _DC_METER_TRANSACTION_ACTION
{
	_DC_METER_TRANSACTION_ACTION_NONE	= 0,
	_DC_METER_TRANSACTION_ACTION_START,
	_DC_METER_TRANSACTION_ACTION_STOP,
};

enum _OCMF_INFO_READY_FLAG
{
	_OCMF_INFO_READY_NO					= 0,
	_OCMF_INFO_READY_YES,
	_OCMF_INFO_READY_FAIL
};

enum _CDFA_VERSION
{
	_CDFA_VERSION_NONE = 	0,
	_CDFA_VERSION_NOODOE = 	1,
	_CDFA_VERSION_10 = 		2,
	_CDFA_VERSION_20 = 		3
};

enum _TILT_SENSOR_STEP
{
	_TILT_SENSOR_STEP_NONE 			= 0x00,
	_TILT_SENSOR_STEP_PIN_ON 		= 0x01,
	_TILT_SENSOR_STEP_PIN_WAIT 		= 0x02,
	_TILT_SENSOR_STEP_PIN_OFF 		= 0x03,
	_TILT_SENSOR_STEP_PIN_FINISH	= 0x04,
};

typedef union
{
    unsigned int GunErrMessage;
    struct
    {
        unsigned char ChaGfdTrip:1;
        unsigned char ChaUvpFail:1;
        unsigned char ChaConnectOTP:1;
        unsigned char ChaConnectOVP:1;
        unsigned char ChaGfdWarning:1;
        unsigned char ChaRelayWeldingFault:1;
        unsigned char ChaRelayDrivingFault:1;
        unsigned char ChaConnectTempSensorFail:1;

        unsigned char CCSGfdTrip :1;
		unsigned char CCSUvpFail :1;
		unsigned char CCSConnectOTP :1;
		unsigned char CCSConnectOVP :1;
		unsigned char CCSGfdWarning :1;
		unsigned char CCSRelayWeldingFault :1;
		unsigned char CCSRelayDrivingFault :1;
		unsigned char CCSConnectTempSensorFail :1;

		unsigned char GBTGfdTrip :1;
		unsigned char GBTUvpFail :1;
		unsigned char GBTConnectOTP :1;
		unsigned char GBTConnectOVP :1;
		unsigned char GBTGfdWarning :1;
		unsigned char GBTRelayWeldingFault :1;
		unsigned char GBTRelayDrivingFault :1;
		unsigned char GBTConnectTempSensorFail :1;

		unsigned char ChaConnectUCP :1;
		unsigned char CCSConnectUCP :1;
		unsigned char GBTConnectUCP :1;
		unsigned char ParallelRelayWeldingFault :1;
		unsigned char ParallelRelayDrivingFault :1;
		unsigned char StopByEvseCondition:1;
		unsigned char :2;
    }GunBits;
}GunErr;

struct DcCommonInformation
{
	// 0 : Standard (only one psu module), 1 : Standard (two psu module), 2 : Smart
	byte systemType;
	byte halfGroupCount;
	byte rebootCount;
	// charger type (standard、simple)
	byte chargerType;
	// minimun output current limit
	float minOutputCur;
	// check if the guns are of the same type
	byte SysGunAreSameType;
	// to check the ccs version
	byte CcsVersion;
	// for relay welding/driving check
	char RelayCheckStatus[6];
	char GunRelayWeldingOccur[DC_CONNECTOR_COUNT];
	char GunRelayDrivingOccur[DC_CONNECTOR_COUNT];
	char ParaRelayWeldingOccur;
	char ParaRelayDrivingOccur;
	byte ConnectorTemp1[DC_CONNECTOR_COUNT]; //0x00: -60¢XC  ~  0xFE: 194
	byte ConnectorTemp2[DC_CONNECTOR_COUNT]; //0x00: -60¢XC  ~  0xFE: 194
	// to check the ac contact status with psu communication
	byte acContactSwitch;
	byte psuKeepCommunication;
	byte startTransactionFlag[DC_CONNECTOR_COUNT];
	int startTransactionID[DC_CONNECTOR_COUNT];

	GunErr ConnectErrList[DC_CONNECTOR_COUNT];
	byte CcsTypeSaved[DC_CONNECTOR_COUNT];

	// Plugit Rack180 : for checking start/stop charging flag
	byte StartToChargingFlag[DC_CONNECTOR_COUNT]; // 0 : Stop, 1 : Start by modbus
	unsigned short LcmFwVersion;
	byte ShowLogoFlag;

	// ocpp offline policy
	byte _isAllowChargingOnDisconnect;

	// Billing Data extend
	byte _hour_index;			//0 ~ 23
	float energy_time_period[DC_CONNECTOR_COUNT][24];

	// for OCPP Reserved
	byte _reserved_UserId[DC_CONNECTOR_COUNT][32];
	byte _reserved_ac_UserId[AC_CONNECTOR_COUNT][32];

	// auto run flag
	byte _isAutoRunTest;

	// chademo try to communicaton flag (for tesla adapter)
	struct ChademoTryCommunicationKey _cha_try_communication[DC_CONNECTOR_COUNT];

	// if the psu communication timedout, reset the AC contact for 30s
	struct timespec _psuComm_time;

	// for reset ev board (GBT or Chademo)
	byte evBoardResetFlag;

	// Use ccid to obtain authorization
	byte enObtainAuthorizbyCCID;
	byte _CcidAuthProcessStep;
	byte _authWithCcidFlag[DC_CONNECTOR_COUNT];

	// balance information - for tariff
	//struct BalanceInfo balanceInfo;
	// balance information - for standard
	struct BalanceInfo balanceInfo;

	// the hold time before return idle
	byte _returnIdleHoldFlag[DC_CONNECTOR_COUNT];

	// Date - YYYY/MM/DD
	byte _sys_date[11];
	// Date - hh/mm
	byte _sys_time[8];
	// Date - a / p .m
	byte _sys_period[6];

	// isPsuError
	byte _isPsuErrorOccur;

	// PSU Protocol
	byte _psuProtocol;

	//CHAdeMo transfer TPC plug in detect
	//LW_tpc plug detect
	byte _tpcPlugDetectState;
	byte TpcDetectFunction;

	// Check if the output voltage is stable
	float _outputVoltageSapmle[PSU_GROUP_COUNT][VOLTAGE_SAMPLE_COUNT];

	// offline power - LW_OfflinePower
	int _offlinePower;

	// Verified by GBT Vincode
	struct GbtVincodeInfo gbtVincodeInfo[DC_CONNECTOR_COUNT];

	// LCM upgrade
	byte _upgrade_lcm_flag;
	byte _upgrade_lcm_result;

	// CTEP :　California Type Evaluation Program
	byte _useVersion;
	struct CdfaInfor cdfaInfor[DC_CONNECTOR_COUNT + AC_CONNECTOR_COUNT];

	// Tilt sensor step
	byte _tiltSensorStep;

	// Ocmf Record resend
	int ocmfTridRecord[DC_CONNECTOR_COUNT];

	// OCTT
	char stopSessionIndex;

	char remoteStartAuthFlag[DC_CONNECTOR_COUNT];

	byte for_alston_test_1;
	byte for_alston_test_2;
	byte for_alston_test_3;

	// for test smartbox - fetch / release
	byte smartFetchRun[DC_CONNECTOR_COUNT];
	byte smartReleaseRun[DC_CONNECTOR_COUNT];
};

#endif /* CONFIG_H_ */