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

global refactoring

Browse Source
This commit is contained in:
Артём Чамайкин
2024-08-14 17:12:36 +03:00
parent a5b0b7db8d
commit b86b879ede
49 changed files with 28155 additions and 15385 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
Core/Src/charger_gbt.c
View File

@@ -13,18 +13,27 @@
#include "j1939.h"
#include "string.h"
#include "edcan.h"
#include "lock.h"
#include "connector.h"
uint8_t GBT_CC_GetStateRaw();
gbtState_t GBT_State;
uint32_t GBT_state_tick; //Tick after state switch
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
GBT_BHM_t GBT_MaxVoltage;
GBT_CML_t GBT_MaxLoad;
GBT_CRM_t GBT_ChargerInfo;
GBT_BHM_t GBT_MaxVoltage;
GBT_BRM_t GBT_EVInfo;
GBT_BCP_t GBT_BATStat;
GBT_BCL_t GBT_ReqPower;
@@ -36,64 +45,35 @@ GBT_BSM_t GBT_BatteryStatus;
GBT_CCS_t GBT_ChargerCurrentStatus;
GBT_CSD_t GBT_ChargerStop;
uint8_t GBT_BRO;
uint32_t GBT_TimeChargingStarted;
uint32_t GBT_StopCauseCode;
uint32_t GBT_ErrorCode;
extern GBT_EDCAN_Output_t GBT_EDCAN_Output;
extern GBT_EDCAN_Input_t GBT_EDCAN_Input;
void GBT_Init(){
GBT_State = GBT_DISABLED;
GBT_Lock(0);
GBT_EDCAN_Input.chargeControl == CHARGING_NOT_ALLOWED;
GBT_Reset();
}
uint8_t GBT_CC_GetState(){
//Vref=3.3v = 4095
//k=1/11
//Vin = 12v
//Vin*k= 1.09v
//12vin = 1353 ADC
//TODO: Filter 100ms
uint32_t adc;
float volt;
ADC_Select_Channel(ADC_CHANNEL_6);
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, 100);
adc = HAL_ADC_GetValue(&hadc1);
HAL_ADC_Stop(&hadc1);
volt = (float)adc/113.4f;
if((volt<12.6f) && (volt>11.4f)) return GBT_CC_12V;
if((volt<6.8f) && (volt>5.2f)) return GBT_CC_6V;
if((volt<4.8f) && (volt>3.2f)) return GBT_CC_4V;
if((volt<2.8f) && (volt>1.2f)) return GBT_CC_2V;
return GBT_CC_UNKNOWN;
}
float GBT_CC_GetAdc(){
//Vref=3.3v = 4095
//k=1/11
//Vin = 12v
//Vin*k= 1.09v
//12vin = 1353 ADC
uint32_t adc;
float volt;
ADC_Select_Channel(ADC_CHANNEL_6);
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, 100);
adc = HAL_ADC_GetValue(&hadc1);
HAL_ADC_Stop(&hadc1);
volt = (float)adc/113.4f;
return volt;
}
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));
break;
@@ -110,17 +90,18 @@ void GBT_ChargerTask(){
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];
break;
case 0x1000: //PGN BCL
//TODO: power block
//TODO: power block
memcpy (&GBT_ReqPower, j_rx.data, sizeof(GBT_ReqPower));
uint16_t volt=GBT_ReqPower.requestedVoltage/10;
uint16_t volt=GBT_ReqPower.requestedVoltage;
GBT_EDCAN_Output.requestedVoltage = volt;
uint16_t curr=(4000-GBT_ReqPower.requestedCurrent);
uint16_t curr=4000-GBT_ReqPower.requestedCurrent;
GBT_EDCAN_Output.requestedCurrent = curr;
break;
@@ -148,6 +129,18 @@ void GBT_ChargerTask(){
//TODO
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
@@ -159,32 +152,48 @@ void GBT_ChargerTask(){
//waiting
}else switch (GBT_State){
case GBT_DISABLED:
break;
case GBT_S0_UNCONNECTED:
if(GBT_CC_GetState()==GBT_CC_4V){
GBT_SwitchState(GBT_S1_CONNECTED);
GBT_Delay(500);
}
break;
case GBT_S1_CONNECTED:
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(1){ //TODO: charge permission
RELAY_Write(RELAY_AUX, 1); // 13.8V AUX ON
GBT_SwitchState(GBT_S3_STARTED);
GBT_Delay(500);
RELAY_Write(RELAY_AUX, 0);
if(connectorState == CONN_Occupied_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_S4_ISOTEST);
@@ -195,20 +204,28 @@ void GBT_ChargerTask(){
if(j_rx.state == 0) GBT_SendCHM();
GBT_Delay(250);
//TODO: Isolation test
//TODO: Timeout
if(GBT_StateTick()>1500){
//if(isolation test fail) {send CST}
if(GBT_BHM_recv) {
//Isolation test finish
GBT_SwitchState(GBT_S5_BAT_INFO);
}
//Timeout 10S
if((GBT_BHM_recv == 0) && (GBT_StateTick()>10000)) { //BHM Timeout
GBT_Error(0xFCF0C0FC);
}
break;
case GBT_S5_BAT_INFO:
if(j_rx.state == 0) GBT_SendCRM(0x00);
GBT_Delay(250);
if(GBT_BAT_INFO_recv){
if(GBT_BAT_INFO_recv){ //BRM
//Got battery info
GBT_SwitchState(GBT_S6_BAT_STAT);
}
//Timeout
if((GBT_StateTick()>5000) && (GBT_BAT_INFO_recv == 0)){
GBT_Error(0xFDF0C0FC); //BRM Timeout
}
break;
case GBT_S6_BAT_STAT:
@@ -218,6 +235,9 @@ void GBT_ChargerTask(){
//Got battery status
GBT_SwitchState(GBT_S7_BMS_WAIT);
}
if((GBT_StateTick()>5000) && (GBT_BAT_STAT_recv == 0)){
GBT_Error(0xFCF1C0FC); //BCP Timeout
}
break;
case GBT_S7_BMS_WAIT:
@@ -225,9 +245,16 @@ void GBT_ChargerTask(){
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
}
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
}
}
break;
@@ -244,71 +271,82 @@ void GBT_ChargerTask(){
case GBT_S9_WAIT_BCL:
if(j_rx.state == 0) GBT_SendCRO(0xAA);
GBT_Delay(250);
if(GBT_ReqPower.chargingMode != 0){
if(GBT_ReqPower.chargingMode != 0){ //REFACTORING
//BCL power requirements received
//write power modules
GBT_SwitchState(GBT_S10_CHARGING);
uint16_t curr=(4000-GBT_ReqPower.requestedCurrent);
uint16_t volt=GBT_ReqPower.requestedVoltage/10;
//if ((curr10>0) && (curr10<500));
//PSU_SetVoltage(volt);
//PSU_SetCurrent(curr);
CONN_SetState(CONN_Occupied_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;
GBT_TimeChargingStarted = get_Current_Time();
//TODO: EDCAN_SendPacketRead
//смещение -400а
//RELAY_Write(RELAY_3, 1);
//PSU_Mode(0x0200);
}
break;
case GBT_S10_CHARGING:
//CHARGING
//TODO BCL BCS BSM missing ERRORS
if(GBT_EDCAN_Input.chargeControl == CHARGING_NOT_ALLOWED) GBT_Stop(GBT_CST_SUSPENDS_ARTIFICIALLY);
if(GBT_EDCAN_Input.chargeControl == FORCE_UNLOCK) GBT_Stop(GBT_CST_SUSPENDS_ARTIFICIALLY);//GBT_ForceStop();
if(GBT_LockState.error) GBT_Stop(GBT_CST_OTHERFALUT);
//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;
if(j_rx.state == 0) GBT_SendCCS();
// write power modules
// if(mm_queue_size()==0){//TODO: hysteresis, charging mode
// if(GBT_CurrPower.requestedCurrent != GBT_ReqPower.requestedCurrent){
// GBT_CurrPower.requestedCurrent = GBT_ReqPower.requestedCurrent;
// //PSU_SetVoltage(GBT_ReqPower.requestedVoltage/10);
// uint16_t curr=(4000-GBT_ReqPower.requestedCurrent);
// //PSU_SetCurrent(curr);
// GBT_ChargingSummary.requestedCurrent = curr;
// }
// if(GBT_CurrPower.requestedVoltage != GBT_ReqPower.requestedVoltage){
// GBT_CurrPower.requestedVoltage = GBT_ReqPower.requestedVoltage;
// //PSU_SetCurrent(GBT_ReqPower.requestedCurrent);
// uint16_t volt=GBT_ReqPower.requestedVoltage/10;
// GBT_ChargingSummary.requestedVoltage = volt;
// //PSU_SetVoltage(volt);
// //смещение -400а
// }
//// }
GBT_Delay(50);
break;
case GBT_STOP:
//TODO: turn off power modules
GBT_Delay(10);
GBT_EDCAN_Output.enablePSU = 0;
GBT_SendCST();
GBT_SendCST(GBT_StopCauseCode);
//RELAY_Write(RELAY_OUTPUT, 0);
//GBT_SwitchState(GBT_DISABLED);
if(GBT_StateTick()>1000){
GBT_SwitchState(GBT_DISABLED);
GBT_Lock(0);
RELAY_Write(RELAY_AUX, 0);
if(GBT_StateTick()>10000){
GBT_Error(0xFCF0C0FD); //BSD Timeout
}
if(GBT_BSD_recv != 0){
GBT_SwitchState(GBT_STOP_CSD);
}
break;
case GBT_STOP_CSD:
GBT_Delay(250);
GBT_SendCSD();
if(GBT_StateTick()>2500){ //2.5S
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_SwitchState(GBT_COMPLETE);
// GBT_Reset();
//
break;
case GBT_COMPLETE:
if(connectorState != CONN_Occupied_complete) GBT_SwitchState(GBT_DISABLED);
break;
default:
GBT_SwitchState(GBT_DISABLED);
}
@@ -321,9 +359,9 @@ void GBT_SwitchState(gbtState_t 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_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_S4_ISOTEST) printf ("GBT_S4_ISOTEST\n");
if(GBT_State == GBT_S5_BAT_INFO) printf ("GBT_S5_BAT_INFO\n");
@@ -333,6 +371,9 @@ void GBT_SwitchState(gbtState_t state){
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");
}
@@ -345,22 +386,45 @@ void GBT_Delay(uint32_t delay){
GBT_delay = HAL_GetTick()+delay;
}
void GBT_Stop(){
void GBT_Stop(uint32_t causecode){
GBT_StopCauseCode = causecode;
if(GBT_State != GBT_STOP) GBT_SwitchState(GBT_STOP);
}
void GBT_Stop1(){
GBT_SwitchState(GBT_DISABLED);
void GBT_Error(uint32_t errorcode){
GBT_ErrorCode = errorcode;
GBT_SwitchState(GBT_ERROR);
}
void GBT_ForceStop(){
GBT_EDCAN_Output.enablePSU = 0;
GBT_SwitchState(GBT_COMPLETE);
GBT_Lock(0);
RELAY_Write(RELAY_AUX, 0);
}
void GBT_Start(){
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;
memset(&GBT_EVInfo, 0, sizeof (GBT_EVInfo));
memset(&GBT_BATStat, 0, sizeof (GBT_BATStat));
memset(&GBT_ReqPower, 0, sizeof (GBT_ReqPower));
GBT_SwitchState(GBT_S0_UNCONNECTED);
memset(&GBT_CurrPower, 0, sizeof (GBT_CurrPower));
memset(&GBT_MaxVoltage, 0, sizeof (GBT_MaxVoltage));
memset(&GBT_ChargingStatus, 0, sizeof (GBT_ChargingStatus));
memset(&GBT_BatteryStatus, 0, sizeof (GBT_BatteryStatus));
memset(&GBT_ChargerCurrentStatus, 0, sizeof (GBT_ChargerCurrentStatus));
memset(&GBT_ChargerStop, 0, sizeof (GBT_ChargerStop));
GBT_CurrPower.requestedCurrent = 4000; //0A
GBT_CurrPower.requestedVoltage = 0; //0V
GBT_TimeChargingStarted = 0;
GBT_BRO = 0x00;
}
void GBT_Start(){
RELAY_Write(RELAY_AUX, 1);
GBT_SwitchState(GBT_S3_STARTED);
}