achamaikin/GbTModuleEV
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

latest version

Browse Source
This commit is contained in:
init.bin
2026-03-11 16:49:23 +03:00
parent c2e1460237
commit 2272e6ab76
140 changed files with 125511 additions and 110312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

539
Core/Src/charger_gbt.c
View File

@@ -13,7 +13,6 @@
#include "j1939.h"
#include "string.h"
#include "edcan.h"
#include "lock.h"
#include "connector.h"
#include "soft_rtc.h"
@@ -23,14 +22,14 @@ gbtState_t GBT_State;
uint32_t GBT_state_tick; //Tick after state switch
uint32_t GBT_delay_start;
uint32_t GBT_delay;
uint8_t GBT_BAT_INFO_recv;
uint8_t GBT_BAT_STAT_recv;
uint8_t GBT_BRO_recv;
uint8_t GBT_BHM_recv;
uint8_t GBT_BSD_recv;
uint8_t EV_ready;
//uint8_t GBT_Charger_Enable; //FIX
//uint8_t GBT_Charger_Permission;//FIX
/* Флаги приёма пакетов от EVSE (EV получает) */
uint8_t GBT_CHM_recv; // CHM получен (0x2600) → отвечаем BHM
uint8_t GBT_CRM_recv; // CRM получен (0x0100) → отвечаем BRM или BCP
uint8_t GBT_CML_recv; // CML получен (0x0800) → отвечаем BRO
uint8_t GBT_CST_recv; // CST получен (0x1A00) → EVSE запросил стоп, переходим в STOP
uint8_t GBT_CSD_recv; // CSD получен (0x1D00) → финальный отчёт EVSE, переходим в STOP_CSD
uint8_t GBT_CRO_val; // последнее значение CRO от EVSE (0x0A00)
GBT_CML_t GBT_MaxLoad;
GBT_CRM_t GBT_ChargerInfo;
@@ -58,28 +57,10 @@ uint32_t GBT_ErrorCode;
GBT_StopSource_t GBT_StopSource;
extern GBT_EDCAN_Output_t GBT_EDCAN_Output;
extern GBT_EDCAN_Input_t GBT_EDCAN_Input;
void GBT_Init(){
GBT_State = GBT_DISABLED;
GBT_EDCAN_Input.chargeControl = CHARGING_NOT_ALLOWED;
CONN.connControl = CMD_NONE;
GBT_Reset();
GBT_MaxLoad.maxOutputVoltage = 1000*10;
GBT_MaxLoad.minOutputVoltage = 1500; //150V
//GBT_MaxLoad[conn].maxOutputCurrent = 4000 - (GBT_MAX_CURRENT*10); //250A
GBT_MaxLoad.maxOutputCurrent = 4000 - (100*10*2); //200A
GBT_MaxLoad.minOutputCurrent = 3990; //400 - 1A
//TODO Linux registers
GBT_ChargerInfo.chargerLocation[0] = 'R';
GBT_ChargerInfo.chargerLocation[1] = 'U';
GBT_ChargerInfo.chargerLocation[2] = 'S';
GBT_ChargerInfo.chargerNumber = 00001;
}
@@ -88,78 +69,48 @@ void GBT_ChargerTask(){
//GBT_LockTask();
if(j_rx.state == 2){
switch (j_rx.PGN){
case 0x2700: //PGN BHM
GBT_BHM_recv = 1;
memcpy (&GBT_MaxVoltage, j_rx.data, sizeof(GBT_MaxVoltage));
case 0x2600: // CHM EVSE->EV (старт/версия GB/T)
GBT_CHM_recv = 1;
break;
case 0x0200: //PGN BRM LONG
GBT_BAT_INFO_recv = 1;
memcpy (&GBT_EVInfo, j_rx.data, sizeof(GBT_EVInfo));
break;
case 0x0600: //PGN BCP LONG
GBT_BAT_STAT_recv = 1;
memcpy (&GBT_BATStat, j_rx.data, sizeof(GBT_BATStat));
case 0x0100: // CRM EVSE->EV (идентификация зарядника, 0x00 или 0xAA)
memcpy(&GBT_ChargerInfo, j_rx.data, sizeof(GBT_ChargerInfo));
GBT_CRM_recv = 1;
break;
case 0x0900: //PGN BRO
GBT_BRO_recv = 1;
if(j_rx.data[0] == 0xAA) EV_ready = 1;
else EV_ready = 0;
GBT_BRO = j_rx.data[0];
case 0x0800: // CML EVSE->EV (макс. параметры зарядника)
memcpy(&GBT_MaxLoad, j_rx.data, sizeof(GBT_MaxLoad));
GBT_CML_recv = 1;
break;
case 0x1000: //PGN BCL
//TODO: power block
memcpy (&GBT_ReqPower, j_rx.data, sizeof(GBT_ReqPower));
uint16_t volt=GBT_ReqPower.requestedVoltage;
GBT_EDCAN_Output.requestedVoltage = volt;
uint16_t curr=4000-GBT_ReqPower.requestedCurrent;
GBT_EDCAN_Output.requestedCurrent = curr;
case 0x0700: // CTS EVSE->EV (time sync)
// Пока не используем, но можем сохранить время при необходимости
break;
case 0x1100: //PGN BCS
//TODO
memcpy (&GBT_ChargingStatus, j_rx.data, sizeof(GBT_ChargingStatus));
GBT_EDCAN_Output.chargingRemainingTimeMin = GBT_ChargingStatus.estimatedRemainingChargingTime;
GBT_EDCAN_Output.chargingPercentage = GBT_ChargingStatus.currentChargeState;
case 0x0A00: // CRO EVSE->EV (0x00 = инициализация, 0xAA = готов к зарядке)
GBT_CRO_val = (j_rx.data[0] & 0xFF);
break;
case 0x1300: //PGN BSM
//TODO
memcpy (&GBT_BatteryStatus, j_rx.data, sizeof(GBT_BatteryStatus));
case 0x1200: // CCS EVSE->EV (текущий статус зарядника)
memcpy(&GBT_ChargerCurrentStatus, j_rx.data, sizeof(GBT_ChargerCurrentStatus));
CONN.enableLoad = GBT_ChargerCurrentStatus.chargingPermissible;
CONN.ChargingTime = GBT_ChargerCurrentStatus.chargingTime;
CONN.MeasuredVoltageSE = GBT_ChargerCurrentStatus.outputVoltage / 10;
CONN.MeasuredCurrentSE = 4000 - GBT_ChargerCurrentStatus.outputCurrent;
break;
case 0x1500: //PGN BMV
//TODO
case 0x1A00: // CST EVSE->EV (остановка зарядки по инициативе EVSE)
GBT_CST_recv = 1;
break;
case 0x1600: //PGN BMT
//TODO
case 0x1D00: // CSD EVSE->EV (финальный отчёт зарядника)
memcpy(&GBT_ChargerStop, j_rx.data, sizeof(GBT_ChargerStop));
GBT_CSD_recv = 1;
break;
case 0x1700: //PGN BSP
//TODO
case 0x1F00: // CEM EVSE->EV (сообщение об ошибке)
memcpy(&GBT_ErrorCode, j_rx.data, sizeof(GBT_ErrorCode));
break;
//this handler in j1939.c
// case 0x1900: //PGN BST
// break;
case 0x1C00: //PGN BSD
//TODO SOC Voltage Temp
GBT_BSD_recv = 1;
break;
//this handler in j1939.c
// case 0x1E00: //PGN BEM
// break;
//BSM BMV BMT BSP BST BSD BEM
}
j_rx.state = 0;
}
@@ -168,272 +119,180 @@ void GBT_ChargerTask(){
//waiting
}else switch (GBT_State){
case GBT_DISABLED:
RELAY_Write(RELAY_AUX, 0);
if(connectorState == CONN_Charging){
GBT_Reset();
GBT_Start();//TODO IF protections (maybe not needed)
}
break;
// case GBT_S0_UNCONNECTED:
// if(!GBT_Charger_Enable){
// GBT_Stop();
// break;
// }
// if(GBT_CC_GetState()==GBT_CC_4V){
//
// GBT_SwitchState(GBT_S1_CONNECTED);
// GBT_Delay(500);
// }
// break;
// case GBT_S1_CONNECTED:
// if(!GBT_Charger_Enable){
// GBT_Stop();
// break;
// }
// if(GBT_CC_GetState()==GBT_CC_4V){
//
// GBT_Lock(1);
// GBT_SwitchState(GBT_S2_LOCKED);
// GBT_Delay(500);
// }else{
// GBT_SwitchState(GBT_S0_UNCONNECTED);
// }
// break;
// case GBT_S2_LOCKED:
// if(!GBT_Charger_Enable){
// GBT_Stop();
// break;
// }
// if(1){ //TODO: charge permission
// RELAY_Write(RELAY_AUX, 1); // 13.8V AUX ON
// GBT_SwitchState(GBT_S3_STARTED);
// GBT_Delay(500);
// }
// break;
case GBT_S3_STARTED:
GBT_SwitchState(GBT_S31_WAIT_BHM);
GBT_Delay(500);
CONN.enableLoad = 0;
// if(connectorState == Preparing){
// GBT_Reset();
// GBT_SwitchState(GBT_EV_CONNECTING);
// }
break;
case GBT_S31_WAIT_BHM:
if(j_rx.state == 0) GBT_SendCHM();
/* --- Строгая последовательность GB/T EV: приём от EVSE → ответ EV --- */
case GBT_EV_CONNECTING:
// 1) Ждём CHM (0x2600), ничего не шлём. Получили → переход в GBT_EV_HANDSHAKE
GBT_Delay(250);
if(GBT_BHM_recv) {
GBT_SwitchState(GBT_S4_ISOTEST);
if (GBT_CHM_recv) {
GBT_SwitchState(GBT_EV_HANDSHAKE);
break;
}
//Timeout 10S
if((GBT_BHM_recv == 0) && (GBT_StateTick()>10000)) { //BHM Timeout
if (GBT_StateTick() > 10000) {
GBT_Error(0xFCF0C0FC);
EDCAN_printf(LOG_WARN, "BHM Timeout\n");
EDCAN_printf(LOG_WARN, "CHM timeout\n");
}
break;
case GBT_S4_ISOTEST:
if(j_rx.state == 0) GBT_SendCHM();
case GBT_EV_HANDSHAKE:
// 2) Постоянно шлём BHM, ждём CRM (0x0100, первый раз 0x00)
GBT_MaxVoltage.maxOutputVoltage = 4500; // 450V
if (j_rx.state == 0) GBT_SendBHM();
GBT_Delay(250);
GBT_EDCAN_Output.requestedVoltage = GBT_MaxVoltage.maxOutputVoltage;
GBT_EDCAN_Output.requestedCurrent = 10; // 1A max
GBT_EDCAN_Output.enablePSU = 1;
//TODO: Isolation test trigger
if(GBT_EDCAN_Input.chargingError != CONN_NO_ERROR){
GBT_StopEVSE(GBT_CST_OTHERFALUT);
if (GBT_CRM_recv) {
GBT_SwitchState(GBT_EV_RECOGNITION);
break;
}
break;
if(GBT_StateTick()>5000){
GBT_SwitchState(GBT_S5_BAT_INFO);
GBT_EDCAN_Output.requestedVoltage = 50;
GBT_EDCAN_Output.requestedCurrent = 10; // 1A max
GBT_EDCAN_Output.enablePSU = 0;
case GBT_EV_RECOGNITION:
// 3) Постоянно шлём BRM, ждём CRM (0x0100, 0xAA)
GBT_EVInfo.version[0] = 2;
GBT_EVInfo.version[1] = 0;
GBT_EVInfo.version[2] = 0;
GBT_EVInfo.batteryType = 1;
GBT_EVInfo.batteryCapacity = 700;
GBT_EVInfo.batteryVoltage = 3990;
memcpy(GBT_EVInfo.batteryVendor, "TEST", 4);
GBT_EVInfo.batterySN = 666666;
GBT_EVInfo.batteryManuY = 30;
GBT_EVInfo.batteryManuM = 2;
GBT_EVInfo.batteryManuD = 20;
GBT_EVInfo.batteryCycleCount = 666;
GBT_EVInfo.ownAuto = 1;
GBT_EVInfo.rsvd0 = 0;
memcpy(GBT_EVInfo.EVIN, "EDISON_TEST_EVIN_", 17);
memcpy(GBT_EVInfo.EV_SW_VER, "1.0.0", 8);
if (j_rx.state == 0) GBT_SendBRM(); // TODO CHUNKED SEND
GBT_Delay(250);
if ((GBT_CRM_recv) && (GBT_ChargerInfo.bmsIdentified == 0xAA)) {
GBT_SwitchState(GBT_EV_CHARGING_PARAMETERS);
break;
}
if (GBT_StateTick() > 5000) {
GBT_Error(0xFCF1C0FC);
EDCAN_printf(LOG_WARN, "CRM(0xAA) timeout (wait BCP)\n");
}
break;
case GBT_EV_CHARGING_PARAMETERS:
// 4) Постоянно шлём BCP, ждём CML (0x0800) → шлём BRO(0xAA)
if (j_rx.state == 0) GBT_SendBCP();
GBT_Delay(250);
if (GBT_CML_recv) {
GBT_SwitchState(GBT_EV_BMS_INIT);
break;
}
if (GBT_StateTick() > 5000) {
GBT_Error(0xFCF4C0FC);
EDCAN_printf(LOG_WARN, "CML timeout\n");
}
break;
case GBT_EV_BMS_INIT:
// 5) Постоянно шлём BRO(0x00) и ждем инициализацию CRO(0xAA)
if (j_rx.state == 0) GBT_SendBRO(0x00);
GBT_Delay(250);
if (GBT_StateTick() > 1500) {
GBT_SwitchState(GBT_EV_WAIT_CHARGER_READY);
break;
}
break;
case GBT_S5_BAT_INFO:
if(j_rx.state == 0) GBT_SendCRM(0x00);
case GBT_EV_WAIT_CHARGER_READY:
// 5) Постоянно шлём BRO(0xAA) и ждем инициализацию CRO(0xAA)
if (j_rx.state == 0) GBT_SendBRO(0xAA);
GBT_Delay(250);
if(GBT_BAT_INFO_recv){ //BRM
//Got battery info
GBT_SwitchState(GBT_S6_BAT_STAT);
EDCAN_printf(LOG_INFO, "EV info:\n");
EDCAN_printf(LOG_INFO, "GBT_ver V%d.%d%d\n",GBT_EVInfo.version[0],GBT_EVInfo.version[1],GBT_EVInfo.version[2]);
EDCAN_printf(LOG_INFO, "Battery type: %d\n",GBT_EVInfo.batteryType);
EDCAN_printf(LOG_INFO, "Battery capacity: %d\n", GBT_EVInfo.batteryCapacity); // 0.1Ah/bit
EDCAN_printf(LOG_INFO, "Battery voltage: %d\n", GBT_EVInfo.batteryVoltage); // 0.1V/bit
EDCAN_printf(LOG_INFO, "Battery vendor: %.4s\n", GBT_EVInfo.batteryVendor); // Battery vendor (ASCII string)
EDCAN_printf(LOG_INFO, "Battery SN: %lu\n", GBT_EVInfo.batterySN); // int
EDCAN_printf(LOG_INFO, "Battery manufacture date: %02d.%02d.%04d\n", GBT_EVInfo.batteryManuD, GBT_EVInfo.batteryManuM ,GBT_EVInfo.batteryManuY+1985); // year (offset 1985)
EDCAN_printf(LOG_INFO, "Battery cycles: %d\n", GBT_EVInfo.batteryCycleCount); //uint24_t
EDCAN_printf(LOG_INFO, "Own auto: %d\n", GBT_EVInfo.ownAuto); // 0 = lizing, 1 = own auto
EDCAN_printf(LOG_INFO, "EVIN: %.17s\n", GBT_EVInfo.EVIN); //EVIN
EDCAN_printf(LOG_INFO, "EV_SW_VER: %.8s\n", GBT_EVInfo.EV_SW_VER);
}
//Timeout
if((GBT_StateTick()>5000) && (GBT_BAT_INFO_recv == 0)){
GBT_Error(0xFDF0C0FC); //BRM Timeout
EDCAN_printf(LOG_WARN, "BRM Timeout\n");
}
break;
case GBT_S6_BAT_STAT:
if(j_rx.state == 0) GBT_SendCRM(0xAA);
GBT_Delay(250);
if(GBT_BAT_STAT_recv){
//Got battery status
GBT_SwitchState(GBT_S7_BMS_WAIT);
EDCAN_printf(LOG_INFO, "Battery info:\n");
EDCAN_printf(LOG_INFO, "maxCV %dV\n",GBT_BATStat.maxCellVoltage/100); // 0.01v/bit
EDCAN_printf(LOG_INFO, "maxCC %dA\n",GBT_BATStat.maxChargingCurrent/10); // 0.1A/bit
EDCAN_printf(LOG_INFO, "totE %dkWh\n",GBT_BATStat.totalEnergy/10); // 0.1kWh
EDCAN_printf(LOG_INFO, "maxCV %dV\n",GBT_BATStat.maxChargingVoltage/10); // 0.1V/ bit
EDCAN_printf(LOG_INFO, "maxT %dC\n",(int16_t)GBT_BATStat.maxTemp-50); // 1C/bit, -50C offset
EDCAN_printf(LOG_INFO, "SOC %dp\n",GBT_BATStat.SOC/10); // 0.1%/bit , 0..100%
EDCAN_printf(LOG_INFO, "Volt. %dV\n",GBT_BATStat.measVoltage/10); // 0.1V/bit
}
if((GBT_StateTick()>5000) && (GBT_BAT_STAT_recv == 0)){
GBT_Error(0xFCF1C0FC); //BCP Timeout
EDCAN_printf(LOG_WARN, "BCP Timeout\n");
}
break;
case GBT_S7_BMS_WAIT:
if(j_rx.state == 0) GBT_SendCTS();
HAL_Delay(2);
if(j_rx.state == 0) GBT_SendCML();
GBT_Delay(250);
if((GBT_StateTick()>5000) && (GBT_BRO_recv == 0)){
GBT_Error(0xFCF4C0FC); //BRO Timeout
EDCAN_printf(LOG_WARN, "BRO Timeout\n");
}
if(EV_ready){
//EV ready (AA)
GBT_SwitchState(GBT_S8_INIT_CHARGER);
}else{
if((GBT_StateTick()>60000) && (GBT_BRO_recv == 1)){
GBT_Error(0xFCF4C0FC); //BRO Timeout
EDCAN_printf(LOG_WARN, "BRO Timeout\n");
}
}
break;
case GBT_S8_INIT_CHARGER:
if(j_rx.state == 0) GBT_SendCRO(0x00);
//TODO
GBT_Delay(250);
if(GBT_StateTick()>1500){
//Power Modules initiated
GBT_SwitchState(GBT_S9_WAIT_BCL);
}
break;
case GBT_S9_WAIT_BCL:
if(j_rx.state == 0) GBT_SendCRO(0xAA);
GBT_Delay(250);
if(GBT_ReqPower.chargingMode != 0){ //REFACTORING
//BCL power requirements received
GBT_SwitchState(GBT_S10_CHARGING);
CONN_SetState(CONN_Charging);
uint16_t curr=4000-GBT_ReqPower.requestedCurrent;
uint16_t volt=GBT_ReqPower.requestedVoltage;
//TODO Limits
GBT_EDCAN_Output.requestedVoltage = volt;
GBT_EDCAN_Output.requestedCurrent = curr;
GBT_EDCAN_Output.enablePSU = 1;
if (GBT_CRO_val == 0xAA) {
GBT_SwitchState(GBT_EV_CHARGING);
GBT_TimeChargingStarted = get_Current_Time();
break;
}
break;
case GBT_S10_CHARGING:
//CHARGING
//TODO BCL BCS BSM missing ERRORS
if(GBT_EDCAN_Input.chargeControl == CHARGING_NOT_ALLOWED) GBT_StopOCPP(GBT_CST_SUSPENDS_ARTIFICIALLY);
if(GBT_EDCAN_Input.chargeControl == FORCE_UNLOCK) GBT_StopOCPP(GBT_CST_SUSPENDS_ARTIFICIALLY); // --> Finished
if(GBT_LockState.error) {
GBT_StopEVSE(GBT_CST_OTHERFALUT); // --> Suspend EVSE
GBT_EDCAN_Output.outputError = CONN_ERR_LOCK;
case GBT_EV_CHARGING:
// Основной режим зарядки: EV периодически шлёт BCS/BSM.
GBT_ReqPower.requestedVoltage = CONN.RequestedVoltage * 10;
GBT_ReqPower.requestedCurrent = 4000 - CONN.RequestedCurrent;
GBT_ReqPower.chargingMode = 1;
GBT_BATStat.maxCellVoltage = 320;
GBT_BATStat.maxChargingCurrent = 40;
GBT_BATStat.totalEnergy = 6;
GBT_BATStat.maxChargingVoltage = 500;
GBT_BATStat.maxTemp = 70;
GBT_BATStat.SOC = CONN.SOC;
GBT_BATStat.measVoltage = CONN.MeasuredVoltage;
// Стоп по инициативе EVSE (получили CST)
if (GBT_CST_recv) {
GBT_StopEVSE(GBT_CST_SUDDENSTOP);
break;
}
if((GBT_ReadTemp(0) > 90) || (GBT_ReadTemp(1) > 90)) {
GBT_StopEVSE(GBT_CST_CONNECTOR_OVER_TEMP);
GBT_EDCAN_Output.outputError = CONN_ERR_CONN_TEMP;
EDCAN_printf(LOG_WARN, "Connector overheat %d %d\n", GBT_ReadTemp(0), GBT_ReadTemp(1));
// Стоп по команде с машины (EDCAN)
if (CONN.connControl == CMD_STOP) {
GBT_StopEV(GBT_CST_BMS_ACTIVELY_SUSPENDS);
break;
}
if(GBT_EDCAN_Input.chargingError != CONN_NO_ERROR){ // --> Suspend EVSE
GBT_StopEVSE(GBT_CST_OTHERFALUT);
// EDCAN_printf(LOG_WARN, "Isolation error\n");
if (IN_ReadInput(IN_ESTOP)) {
GBT_StopEV(GBT_CST_BMS_ACTIVELY_SUSPENDS);
break;
}
//GBT_ChargerCurrentStatus.chargingPermissible = 0b1111111111111100;//NOT PERMITTED
GBT_ChargerCurrentStatus.chargingPermissible = 0b1111111111111101;
GBT_ChargerCurrentStatus.chargingTime = (get_Current_Time() - GBT_TimeChargingStarted)/60;
// GBT_ChargerCurrentStatus.outputCurrent = 4000 - GBT_EDCAN_Output.requestedCurrent;
// GBT_ChargerCurrentStatus.outputVoltage = GBT_EDCAN_Output.requestedVoltage;
GBT_ChargerCurrentStatus.outputCurrent = 4000 - GBT_EDCAN_Input.measuredCurrent;
GBT_ChargerCurrentStatus.outputVoltage = GBT_EDCAN_Input.measuredVoltage;
GBT_EDCAN_Output.chargingElapsedTimeMin = (get_Current_Time() - GBT_TimeChargingStarted)/60;
GBT_EDCAN_Output.chargingElapsedTimeSec = (get_Current_Time() - GBT_TimeChargingStarted)%60;
if(j_rx.state == 0) GBT_SendCCS();
if(j_rx.state == 0) {
GBT_SendCCS();
GBT_Delay(49);
}else{
GBT_Delay(10); // Resend packet if not sent
// log_printf(LOG_WARN, "Resend packet\n");
}
//TODO: снижение тока если перегрев контактов
GBT_SendBCS();
GBT_SendBCL();
GBT_SendBSM();
GBT_Delay(250);
break;
case GBT_STOP:
GBT_Delay(10);
GBT_EDCAN_Output.enablePSU = 0;
GBT_SendCST(GBT_StopCauseCode);
//RELAY_Write(RELAY_OUTPUT, 0);
//GBT_SwitchState(GBT_DISABLED);
if(GBT_StateTick()>10000){
EDCAN_printf(LOG_WARN, "BSD Timeout\n");
GBT_Error(0xFCF0C0FD); //BSD Timeout
CONN.enableLoad = 0;
// EV шлёт BSD (Battery Stop Data), не CST (CST шлёт EVSE)
GBT_SendBSD();
if (GBT_StateTick() > 10000) {
EDCAN_printf(LOG_WARN, "CSD Timeout\n");
GBT_Error(0xFCF0C0FD); // CSD timeout
}
if(GBT_BSD_recv != 0){
if (GBT_CSD_recv) {
GBT_SwitchState(GBT_STOP_CSD);
}
break;
case GBT_STOP_CSD:
// EV не шлёт CSD (финальный отчёт шлёт EVSE). Ждём 2.5 с и завершаем.
GBT_Delay(250);
GBT_SendCSD();
if(GBT_StateTick()>2500){ //2.5S
if (GBT_StateTick() > 2500) {
GBT_SwitchState(GBT_COMPLETE);
// GBT_Reset();
//CONN_SetState(CONN_Occupied_complete);
//if(connectorState == CONN_Occupied_charging)
//PSU_Mode(0x0100);
}
break;
case GBT_ERROR:
GBT_SendCEM(GBT_ErrorCode); //2.5S
//GBT_SendBEM(GBT_ErrorCode); //2.5S TODO
GBT_SwitchState(GBT_COMPLETE);
// GBT_Reset();
//
break;
case GBT_COMPLETE:
if(connectorState != CONN_Finishing) {
if(connectorState != Finished) {
GBT_SwitchState(GBT_DISABLED);
GBT_Reset();//CHECK
}
@@ -442,46 +301,28 @@ void GBT_ChargerTask(){
default:
GBT_SwitchState(GBT_DISABLED);
}
if (CONN_CC_GetState()==GBT_CC_4V) CONN.EvseConnected = 1;
else CONN.EvseConnected = 0;
}
void GBT_SwitchState(gbtState_t state){
GBT_State = state;
ED_status = state;
GBT_state_tick = HAL_GetTick();
// if(GBT_State == GBT_DISABLED) printf ("GBT_DISABLED\n");
// if(GBT_State == GBT_S0_UNCONNECTED) printf ("GBT_S0_UNCONNECTED\n");
// if(GBT_State == GBT_S1_CONNECTED) printf ("GBT_S1_CONNECTED\n");
// if(GBT_State == GBT_S2_LOCKED) printf ("GBT_S2_LOCKED\n");
// if(GBT_State == GBT_S3_STARTED) printf ("GBT_S3_STARTED\n");
// if(GBT_State == GBT_S31_WAIT_BHM) printf ("GBT_S31_WAIT_BHM\n");
// if(GBT_State == GBT_S4_ISOTEST) printf ("GBT_S4_ISOTEST\n");
// if(GBT_State == GBT_S5_BAT_INFO) printf ("GBT_S5_BAT_INFO\n");
// if(GBT_State == GBT_S6_BAT_STAT) printf ("GBT_S6_BAT_STAT\n");
// if(GBT_State == GBT_S7_BMS_WAIT) printf ("GBT_S7_BMS_WAIT\n");
// if(GBT_State == GBT_S8_INIT_CHARGER)printf ("GBT_S8_INIT_CHARGER\n");
// if(GBT_State == GBT_S9_WAIT_BCL) printf ("GBT_S9_WAIT_BCL\n");
// if(GBT_State == GBT_S10_CHARGING) printf ("GBT_S10_CHARGING\n");
// if(GBT_State == GBT_STOP) printf ("GBT_STOP\n");
// if(GBT_State == GBT_STOP_CSD) printf ("GBT_STOP_CSD\n");
// if(GBT_State == GBT_ERROR) printf ("GBT_ERROR\n");
// if(GBT_State == GBT_COMPLETE) printf ("GBT_COMPLETE\n");
if(GBT_State == GBT_DISABLED) EDCAN_printf(LOG_INFO, "GBT_DISABLED\n");
if(GBT_State == GBT_S3_STARTED) EDCAN_printf(LOG_INFO, "GBT_S3_STARTED\n");
if(GBT_State == GBT_S31_WAIT_BHM) EDCAN_printf(LOG_INFO, "GBT_S31_WAIT_BHM\n");
if(GBT_State == GBT_S4_ISOTEST) EDCAN_printf(LOG_INFO, "GBT_S4_ISOTEST\n");
if(GBT_State == GBT_S5_BAT_INFO) EDCAN_printf(LOG_INFO, "GBT_S5_BAT_INFO\n");
if(GBT_State == GBT_S6_BAT_STAT) EDCAN_printf(LOG_INFO, "GBT_S6_BAT_STAT\n");
if(GBT_State == GBT_S7_BMS_WAIT) EDCAN_printf(LOG_INFO, "GBT_S7_BMS_WAIT\n");
if(GBT_State == GBT_S8_INIT_CHARGER)EDCAN_printf(LOG_INFO, "GBT_S8_INIT_CHARGER\n");
if(GBT_State == GBT_S9_WAIT_BCL) EDCAN_printf(LOG_INFO, "GBT_S9_WAIT_BCL\n");
if(GBT_State == GBT_S10_CHARGING) EDCAN_printf(LOG_INFO, "GBT_S10_CHARGING\n");
if(GBT_State == GBT_STOP) EDCAN_printf(LOG_INFO, "GBT_STOP\n");
if(GBT_State == GBT_STOP_CSD) EDCAN_printf(LOG_INFO, "GBT_STOP_CSD\n");
if(GBT_State == GBT_ERROR) EDCAN_printf(LOG_WARN, "GBT_ERROR\n");
if(GBT_State == GBT_COMPLETE) EDCAN_printf(LOG_INFO, "GBT_COMPLETE\n");
if(GBT_State == GBT_DISABLED) EDCAN_printf(LOG_INFO, "GBT_DISABLED\n");
if(GBT_State == GBT_EV_CONNECTING) EDCAN_printf(LOG_INFO, "GBT_EV_CONNECTING\n");
if(GBT_State == GBT_EV_HANDSHAKE) EDCAN_printf(LOG_INFO, "GBT_EV_HANDSHAKE\n");
if(GBT_State == GBT_EV_RECOGNITION) EDCAN_printf(LOG_INFO, "GBT_EV_RECOGNITION\n");
if(GBT_State == GBT_EV_CHARGING_PARAMETERS) EDCAN_printf(LOG_INFO, "GBT_EV_CHARGING_PARAMETERS\n");
if(GBT_State == GBT_EV_BMS_INIT) EDCAN_printf(LOG_INFO, "GBT_EV_BMS_INIT\n");
if(GBT_State == GBT_EV_WAIT_CHARGER_READY) EDCAN_printf(LOG_INFO, "GBT_EV_WAIT_CHARGER_READY\n");
if(GBT_State == GBT_EV_CHARGING) EDCAN_printf(LOG_INFO, "GBT_EV_CHARGING\n");
if(GBT_State == GBT_STOP) EDCAN_printf(LOG_INFO, "GBT_STOP\n");
if(GBT_State == GBT_STOP_CSD) EDCAN_printf(LOG_INFO, "GBT_STOP_CSD\n");
if(GBT_State == GBT_ERROR) EDCAN_printf(LOG_WARN, "GBT_ERROR\n");
if(GBT_State == GBT_COMPLETE) EDCAN_printf(LOG_INFO, "GBT_COMPLETE\n");
}
@@ -496,7 +337,7 @@ void GBT_Delay(uint32_t delay){
}
void GBT_StopEV(uint32_t causecode){ // --> Suspend EV
if (GBT_EDCAN_Input.chargingError || GBT_EDCAN_Output.outputError){
if (CONN.chargingError){
GBT_StopSource = GBT_STOP_EVSE;
}else{
GBT_StopSource = GBT_STOP_EV;
@@ -519,10 +360,9 @@ void GBT_StopOCPP(uint32_t causecode){ // --> Finished
void GBT_ForceStop(){ // --> Suspend EV
GBT_StopSource = GBT_STOP_EV;
GBT_EDCAN_Output.enablePSU = 0;
// Отключаем силовой контактор батареи со стороны EV
CONN.enableLoad = 0;
GBT_SwitchState(GBT_COMPLETE);
GBT_Lock(0);
RELAY_Write(RELAY_AUX, 0);
}
void GBT_Error(uint32_t errorcode){ // --> Suspend EV
@@ -534,17 +374,18 @@ void GBT_Error(uint32_t errorcode){ // --> Suspend EV
void GBT_Reset(){
GBT_BAT_INFO_recv = 0;
GBT_BAT_STAT_recv = 0;
GBT_BRO_recv = 0;
GBT_BHM_recv = 0;
GBT_BSD_recv = 0;
EV_ready = 0;
GBT_EDCAN_Output.chargingPercentage = 0;
GBT_EDCAN_Output.enablePSU = 0;
GBT_EDCAN_Output.requestedCurrent = 0;
GBT_EDCAN_Output.requestedVoltage = 500;
GBT_EDCAN_Output.outputError = 0;
GBT_SwitchState(GBT_DISABLED);
GBT_CHM_recv = 0;
GBT_CRM_recv = 0;
GBT_CML_recv = 0;
GBT_CST_recv = 0;
GBT_CSD_recv = 0;
GBT_CRO_val = 0x00;
CONN.SOC = 0;
CONN.enableLoad = 0;
CONN.RequestedCurrent = 1000;
CONN.RequestedVoltage = 400;
CONN.chargingError = 0;
memset(&GBT_EVInfo, 0, sizeof (GBT_EVInfo));
memset(&GBT_BATStat, 0, sizeof (GBT_BATStat));
memset(&GBT_ReqPower, 0, sizeof (GBT_ReqPower));
@@ -559,7 +400,3 @@ void GBT_Reset(){
GBT_TimeChargingStarted = 0;
GBT_BRO = 0x00;
}
void GBT_Start(){
RELAY_Write(RELAY_AUX, 1);
GBT_SwitchState(GBT_S3_STARTED);
}