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

BIN
Core/Src/.DS_Store vendored
View File

Binary file not shown.

19
Core/Src/board.c
View File

@@ -11,26 +11,7 @@ extern ADC_HandleTypeDef hadc1;
//TODO:
//TEMP READ
//LOCK_FB
//GBT_TEMP_SENSORS
//USB
void GBT_Lock(uint8_t state){
if(state){//LOCK
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 1);
HAL_Delay(50);
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 0);
}else{ //UNLOCK
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 1);
HAL_Delay(50);
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 0);
}
}
uint8_t GBT_LockGetState(){
return HAL_GPIO_ReadPin(LOCK_FB_GPIO_Port, LOCK_FB_Pin);
}
void RELAY_Write(relay_t num, uint8_t state){
if(num==RELAY_AUX)HAL_GPIO_WritePin(RELAY_AUX_GPIO_Port, RELAY_AUX_Pin, state);

2
Core/Src/can.c
View File

@@ -79,7 +79,7 @@ void MX_CAN2_Init(void)
hcan2.Init.TimeTriggeredMode = DISABLE;
hcan2.Init.AutoBusOff = ENABLE;
hcan2.Init.AutoWakeUp = ENABLE;
hcan2.Init.AutoRetransmission = DISABLE;
hcan2.Init.AutoRetransmission = ENABLE;
hcan2.Init.ReceiveFifoLocked = DISABLE;
hcan2.Init.TransmitFifoPriority = ENABLE;
if (HAL_CAN_Init(&hcan2) != HAL_OK)

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);
}

207
Core/Src/connector.c Normal file
View File

@@ -0,0 +1,207 @@
/*
* connector.c
*
* All initialization before 12v_aux
*/
#include "connector.h"
#include "lock.h"
#include "board.h"
CONN_State_t connectorState;
extern GBT_EDCAN_Output_t GBT_EDCAN_Output;
extern GBT_EDCAN_Input_t GBT_EDCAN_Input;
uint8_t CC_STATE_FILTERED;
void CONN_Init(){
CONN_SetState(CONN_Initializing);
}
void CONN_Task(){
switch (connectorState){
case CONN_Initializing: // unlocked
GBT_Lock(0);
CONN_SetState(CONN_Available);
GBT_LockState.error = 0;
break;
case CONN_Error: //unlocked
GBT_Lock(0);
break;
case CONN_Available: //unlocked, waiting to connect
GBT_Lock(0);
if((CONN_CC_GetState()==GBT_CC_4V) && (GBT_EDCAN_Input.chargeControl != FORCE_UNLOCK)){
CONN_SetState(CONN_Occupied_waiting);
GBT_Lock(1);
}
break;
case CONN_Occupied_waiting: //locked, waiting to charge
GBT_Lock(1);
if(CONN_CC_GetState()==GBT_CC_4V){
if(GBT_EDCAN_Input.chargeControl == CHARGING_ALLOWED){
// RELAY_Write(RELAY_AUX, 1);
// GBT_Start();
CONN_SetState(CONN_Occupied_charging);
}
if(GBT_EDCAN_Input.chargeControl == FORCE_UNLOCK){
CONN_SetState(CONN_Available);
}
//if (CHARGING_NOT_ALLOWED) stay here
}else{
CONN_SetState(CONN_Available);
}
break;
case CONN_Occupied_charging://charging, locked
GBT_Lock(1);
if(GBT_State == GBT_COMPLETE){
CONN_SetState(CONN_Occupied_complete);
}
//
break;
case CONN_Occupied_complete://charging completed, waiting to disconnect, unlocked
GBT_Lock(0);
// RELAY_Write(RELAY_AUX, 0);
//TODO: Reconnection
if(GBT_EDCAN_Input.chargeControl == CHARGING_NOT_ALLOWED){
CONN_SetState(CONN_Initializing);
}
if(CONN_CC_GetState()==GBT_CC_6V){
CONN_SetState(CONN_Initializing);
}
//Проблема, если нажать кнопку и не вынуть пистолет, то он снова блочится
break;
default:
CONN_SetState(CONN_Initializing);
}
}
//external
//CONN_SetState(CONN_Error);
//CONN_SetState(CONN_Occupied_charging);
//CONN_SetState(CONN_Occupied_Complete);
void CONN_SetState(CONN_State_t state){
connectorState = state;
if(connectorState == CONN_Initializing) printf ("CONN_Initializing\n");
if(connectorState == CONN_Error) printf ("CONN_Error\n");
if(connectorState == CONN_Available) printf ("CONN_Available\n");
if(connectorState == CONN_Occupied_waiting) printf ("CONN_Occupied_waiting\n");
if(connectorState == CONN_Occupied_charging) printf ("CONN_Occupied_charging\n");
if(connectorState == CONN_Occupied_complete) printf ("CONN_Occupied_complete\n");
GBT_EDCAN_Output.connectorState = state;
}
void CONN_CC_ReadStateFiltered() {
static uint32_t last_change_time;
static uint32_t last_check_time;
static uint8_t prev_state;
if((last_check_time+100)>HAL_GetTick()) return;
last_check_time = HAL_GetTick();
uint8_t new_state = CONN_CC_GetStateRaw();
if (new_state != prev_state) {
last_change_time = HAL_GetTick();
prev_state = new_state;
} else if ((HAL_GetTick() - last_change_time) >= 300) {
CC_STATE_FILTERED = prev_state;
}
// switch(new_state){
// case GBT_CC_UNKNOWN:
// printf("GBT_CC_UNKNOWN\n");
// break;
// case GBT_CC_12V:
// printf("GBT_CC_12V\n");
// break;
// case GBT_CC_6V:
// printf("GBT_CC_6V\n");
// break;
// case GBT_CC_4V:
// printf("GBT_CC_4V\n");
// break;
// case GBT_CC_2V:
// printf("GBT_CC_2V\n");
// break;
//
// }
// switch(CONN_CC_GetState()){
// case GBT_CC_UNKNOWN:
// printf("FGBT_CC_UNKNOWN\n");
// break;
// case GBT_CC_12V:
// printf("FGBT_CC_12V\n");
// break;
// case GBT_CC_6V:
// printf("FGBT_CC_6V\n");
// break;
// case GBT_CC_4V:
// printf("FGBT_CC_4V\n");
// break;
// case GBT_CC_2V:
// printf("FGBT_CC_2V\n");
// break;
//
// }
}
uint8_t CONN_CC_GetState(){
return CC_STATE_FILTERED;
}
uint8_t CONN_CC_GetStateRaw(){
//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;
if((volt<13.0f) && (volt>11.0f)) return GBT_CC_12V;
if((volt<7.2f) && (volt>4.8f)) return GBT_CC_6V;
if((volt<4.8f) && (volt>3.0f)) return GBT_CC_4V;
if((volt<3.0f) && (volt>1.0f)) return GBT_CC_2V;
return GBT_CC_UNKNOWN;
}
float CONN_CC_GetAdc(){
//TODO: Filters
//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;
}

77
Core/Src/debug.c
View File

@@ -12,6 +12,9 @@
#include "board.h"
#include "charger_gbt.h"
#include "usart.h"
#include <time.h>
#include <connector.h>
uint8_t debug_rx_buffer[256];
uint8_t debug_cmd_received;
@@ -22,11 +25,23 @@ extern UART_HandleTypeDef huart2;
#if defined(__GNUC__)
int _write(int fd, char * ptr, int len)
{
HAL_UART_Transmit(&huart2, (uint8_t *) ptr, len, HAL_MAX_DELAY);
return len;
HAL_GPIO_WritePin(USART2_DIR_GPIO_Port, USART2_DIR_Pin, 1);
HAL_UART_Transmit(&huart2, (uint8_t *) ptr, len, HAL_MAX_DELAY);
HAL_GPIO_WritePin(USART2_DIR_GPIO_Port, USART2_DIR_Pin, 0);
return len;
}
#endif
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){
// if(huart->Instance == USART1){
// mm_rx_interrupt(huart, Size);
// }
if(huart->Instance == USART2){
debug_rx_interrupt(huart, Size);
}
}
void debug_rx_interrupt(UART_HandleTypeDef *huart, uint16_t Size){
debug_rx_buffer[Size] = '\0';
debug_rx_buffer_size = Size;
@@ -53,7 +68,7 @@ void parse_command(uint8_t* buffer, size_t length) {
break;
}
}
if (buffer[0] == 0) return;
if (strncmp((const char*)buffer, "reset", length) == 0) {
printf("Resetting...\n");
NVIC_SystemReset();
@@ -75,7 +90,7 @@ void parse_command(uint8_t* buffer, size_t length) {
// mm_schedule_read(0x02, 0x0001);
} else if (strncmp((const char*)buffer, "adc", length) == 0) {
printf("CC1=%.2f\n", GBT_CC_GetAdc());
printf("CC1=%.2f\n", CONN_CC_GetAdc());
} else if (strncmp((const char*)buffer, "lock_state", length) == 0) {
printf("Lock state=%d\n", GBT_LockGetState());
@@ -88,26 +103,29 @@ void parse_command(uint8_t* buffer, size_t length) {
printf("Unlocked\n");
GBT_Lock(0);
} else if (strncmp((const char*)buffer, "complete", length) == 0) {
CONN_SetState(CONN_Occupied_complete);
} else if (strncmp((const char*)buffer, "start", length) == 0) {
printf("Started\n");
GBT_Start();
} else if (strncmp((const char*)buffer, "stop", length) == 0) {
printf("Stopped\n");
GBT_Stop();
GBT_Stop(GBT_CST_SUSPENDS_ARTIFICIALLY);
} else if (strncmp((const char*)buffer, "stop1", length) == 0) {
printf("Stopped\n");
GBT_Stop1();
GBT_ForceStop();
} else if (strncmp((const char*)buffer, "force", length) == 0) {
printf("Stopped\n");
GBT_Lock(1);
GBT_SwitchState(GBT_S2_LOCKED);
GBT_Delay(500);
// } else if (strncmp((const char*)buffer, "force", length) == 0) {
// printf("Stopped\n");
// GBT_Lock(1);
// GBT_SwitchState(GBT_S2_LOCKED);
// GBT_Delay(500);
} else if (strncmp((const char*)buffer, "cc_state", length) == 0) {
switch(GBT_CC_GetState()){
switch(CONN_CC_GetState()){
case GBT_CC_UNKNOWN:
printf("GBT_CC_UNKNOWN\n");
break;
@@ -149,6 +167,18 @@ void parse_command(uint8_t* buffer, size_t length) {
printf("EVIN: %.17s\n", GBT_EVInfo.EVIN); //EVIN
printf("EV_SW_VER: %.8s\n", GBT_EVInfo.EV_SW_VER);
} else if (strncmp((const char*)buffer, "info3", length) == 0) {
printf("GBT_MaxLoad info:\n");
printf("Output max current: %d\n",GBT_MaxLoad.maxOutputCurrent);
printf("Output min current: %d\n",GBT_MaxLoad.minOutputCurrent);
printf("Output max voltage: %d\n",GBT_MaxLoad.maxOutputVoltage);
printf("Output min voltage: %d\n",GBT_MaxLoad.minOutputVoltage);
printf("\nGBT_ChargerInfo info:\n");
printf("BMS Recognized: %d\n",GBT_ChargerInfo.bmsIdentified);
printf("Charger location: %.3s\n",GBT_ChargerInfo.chargerLocation);
printf("Charger number: %lu\n",GBT_ChargerInfo.chargerNumber);
} else if (strncmp((const char*)buffer, "help", length) == 0) {
printf("Command list:\n");
printf("reset\n");
@@ -162,11 +192,32 @@ void parse_command(uint8_t* buffer, size_t length) {
printf("start\n");
printf("stop\n");
printf("stop1\n");
printf("force\n");
// printf("force\n");
printf("info1\n");
printf("info2\n");
printf("info3\n");
printf("time\n");
printf("cantest\n");
//TODO: info commands
} else if (strncmp((const char*)buffer, "time", length) == 0) {
time_t unix_time = (time_t)get_Current_Time();
struct tm *parts = localtime(&unix_time);
printf("Year: %d\n", parts->tm_year + 1900);
printf("Month: %d\n", parts->tm_mon + 1);
printf("Day: %d\n", parts->tm_mday);
printf("Hour: %d\n", parts->tm_hour);
printf("Minute: %d\n", parts->tm_min);
printf("Second: %d\n", parts->tm_sec);
} else if (strncmp((const char*)buffer, "cantest", length) == 0) {
//GBT_SendCHM();
GBT_Error(0xFDF0C0FC); //BRM Timeout
printf("can test\n");
} else {
printf("Unknown command\n");
}

43
Core/Src/edcan_handler_user.c
View File

@@ -28,31 +28,17 @@
/* Charger info registers */
#define EDCAN_REG_CHARGER_NUMBER_0 0x200
#define EDCAN_REG_CHARGER_NUMBER_1 0x201
#define EDCAN_REG_CHARGER_NUMBER_2 0x202
#define EDCAN_REG_CHARGER_NUMBER_3 0x203
#define EDCAN_REG_CHARGER_LOCATION_0 0x204
#define EDCAN_REG_CHARGER_LOCATION_1 0x205
#define EDCAN_REG_CHARGER_LOCATION_2 0x206
#define EDCAN_REG_CHARGER_INFO 0x200
//UNIX TIME
#define EDCAN_REG_TIME_0 0x210
#define EDCAN_REG_TIME_1 0x211
#define EDCAN_REG_TIME_2 0x212
#define EDCAN_REG_TIME_3 0x213
//#define EDCAN_REG_SECONDS 0x210
//#define EDCAN_REG_MINUTES 0x211
//#define EDCAN_REG_HOURS 0x212
//#define EDCAN_REG_DAYS 0x213
//#define EDCAN_REG_MONTH 0x214
//#define EDCAN_REG_YEARS 0x215
//#define EDCAN_REG_CENTURIES 0x216
//#define EDCAN_REG_TIME_SYNC 0x217
#define EDCAN_REG_MAX_LOAD 0x220
#define EDCAN_REG_BRM 0x310
#define EDCAN_REG_BCP 0x350
@@ -77,10 +63,6 @@ GBT_EDCAN_Input_t GBT_EDCAN_Input;
//extern uint8_t relay_value[8];
/**
* @brief Handler for incoming Read packet
* Another device reply value of its registers
@@ -142,14 +124,10 @@ void EDCAN_WriteUserRegister(uint16_t addr, uint8_t value){
// printf ("K0 = %d\n", value);
// HAL_GPIO_WritePin (K0_GPIO_Port, K0_Pin, (value == 0));
// break;
case EDCAN_REG_CHARGER_ENABLE:
if(value){
GBT_Start();//TODO IF protections
}else{
GBT_Stop();
}
break;
// case EDCAN_REG_CHARGER_ENABLE:
// if(value)GBT_Charger_Enable = 1;
// else GBT_Charger_Enable = 0;
// break;
case EDCAN_REG_TIME_0:
writeTimeReg(0, value);
@@ -171,6 +149,11 @@ void EDCAN_WriteUserRegister(uint16_t addr, uint8_t value){
((uint8_t*)&GBT_MaxLoad)[addr - EDCAN_REG_MAX_LOAD] = value;
break;
//0x200
case EDCAN_REG_CHARGER_INFO ... (EDCAN_REG_CHARGER_INFO+sizeof(GBT_CRM_t)):
((uint8_t*)&GBT_ChargerInfo)[addr - EDCAN_REG_CHARGER_INFO] = value;
break;
//0x580
case EDCAN_REG_INPUT ... (EDCAN_REG_INPUT+sizeof(GBT_EDCAN_Input_t)):
((uint8_t*)&GBT_EDCAN_Input)[addr - EDCAN_REG_INPUT] = value;
@@ -193,7 +176,7 @@ uint8_t EDCAN_GetUserRegisterValue(uint16_t addr){
// /* регистры 256..2047 используются пользовательских нужд */
// 0x400
case EDCAN_REG_TIME_0:
return getTimeReg(0);
break;

33
Core/Src/gbt_packet.c
View File

@@ -26,7 +26,6 @@ void GBT_SendCTS(){
J_SendPacket(0x000700, 6, 7, data);
}
//TODO
//GB/T Max Load Packet
void GBT_SendCML(){
// uint8_t data[8];
@@ -52,7 +51,6 @@ void GBT_SendCHM(){
J_SendPacket(0x2600, 6, 3, data);
}
//TODO
//GB/T CRM Packet (state=BMS identified)
void GBT_SendCRM(uint8_t state){
// uint8_t data[8];
@@ -75,8 +73,6 @@ void GBT_SendCRO(uint8_t state){
J_SendPacket(0xA00, 4, 1, data);
}
//TODO: Send measured voltage current
//GB/T CCS packet (Charger current status)
void GBT_SendCCS(){
// uint8_t data[8];
@@ -94,16 +90,31 @@ void GBT_SendCCS(){
J_SendPacket(0x1200, 6, 8, (uint8_t *)&GBT_ChargerCurrentStatus);
}
//TODO: stop cause
// GB/T Charging Stop packet
void GBT_SendCST(){
void GBT_SendCST(uint32_t Cause){
uint8_t data[8];
data[0] = 0x04; // Artificially stop charging
data[1] = 0x00; //TODO: Cause stop
data[2] = 0xF0; //
data[3] = 0xF0; //
data[0] = (Cause>>24) & 0xFF; // Error
data[1] = (Cause>>16) & 0xFF; //
data[2] = (Cause>>8) & 0xFF; //
data[3] = Cause & 0xFF; //
J_SendPacket(0x1A00, 4, 4, data);
}
//TODO CSD priority 6
void GBT_SendCSD(){
GBT_ChargerStop.chargerNumber = GBT_ChargerInfo.chargerNumber;
GBT_ChargerStop.outputEnergy = 0; //TODO Energy meters
GBT_ChargerStop.chargingTime = GBT_ChargerCurrentStatus.chargingTime;
J_SendPacket(0x1D00, 6, 7, (uint8_t *)&GBT_ChargerStop);
}
void GBT_SendCEM(uint32_t ErrorCode){
uint8_t data[8];
data[0] = (ErrorCode>>24) & 0xFF; // Error
data[1] = (ErrorCode>>16) & 0xFF; //
data[2] = (ErrorCode>>8) & 0xFF; //
data[3] = ErrorCode & 0xFF; //
J_SendPacket(0x1F00, 4, 4, data);
}

27
Core/Src/j1939.c
View File

@@ -77,11 +77,14 @@ void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
break;
case 0x1E00: //PGN BEM (ERROR)
GBT_Stop();
//Error force stop
GBT_ForceStop();
break;
case 0x1900: //PGN BST (STOP)
GBT_Stop();
//Normal stop
GBT_Stop(GBT_CST_BMS_ACTIVELY_SUSPENDS);
break;
default:
@@ -106,6 +109,7 @@ void GBT_CAN_ReInit(){
MX_CAN1_Init();
HAL_CAN_Start(&hcan1);
HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
GBT_CAN_FilterInit();
}
void J_SendPacket(uint32_t PGN, uint8_t pri, uint8_t DLC, uint8_t *data){
@@ -161,3 +165,22 @@ void J_SendACK(j_receive_t rx){//uint32_t PGN, uint8_t step, uint8_t packet){
J_SendPacket(0x00EC00, 7, 8, data);
}
void GBT_CAN_FilterInit(){
CAN_FilterTypeDef sFilterConfig;
sFilterConfig.FilterBank = 0;
sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
sFilterConfig.FilterIdHigh = 0x0000;
sFilterConfig.FilterIdLow = 0x0000;
sFilterConfig.FilterMaskIdHigh = 0x0000;
sFilterConfig.FilterMaskIdLow = 0x0000;
sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
sFilterConfig.FilterActivation = ENABLE;
//sFilterConfig.SlaveStartFilterBank = 14;
if(HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
{
Error_Handler();
}
}

88
Core/Src/lock.c Normal file
View File

@@ -0,0 +1,88 @@
/*
* lock.c
*
* Created on: Jul 31, 2024
* Author: colorbass
*/
#include "lock.h"
uint8_t LOCK_POLARITY = 1;
uint8_t LOCK_MOTOR_POLARITY = 1;
uint8_t LOCK_DELAY = 50;
GBT_LockState_t GBT_LockState;
void GBT_ForceLock(uint8_t state){
if(LOCK_MOTOR_POLARITY){
if(state){//LOCK
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 1);
HAL_Delay(LOCK_DELAY);
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 0);
}else{ //UNLOCK
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 1);
HAL_Delay(LOCK_DELAY);
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 0);
}
}else{
if(state){//LOCK
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 1);
HAL_Delay(LOCK_DELAY);
HAL_GPIO_WritePin(LOCK_A_GPIO_Port, LOCK_A_Pin, 0);
}else{ //UNLOCK
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 1);
HAL_Delay(LOCK_DELAY);
HAL_GPIO_WritePin(LOCK_B_GPIO_Port, LOCK_B_Pin, 0);
}
}
}
uint8_t GBT_LockGetState(){
//1 = locked
//0 = unlocked
if(LOCK_POLARITY){
return HAL_GPIO_ReadPin(LOCK_FB_GPIO_Port, LOCK_FB_Pin);
}else{
return !HAL_GPIO_ReadPin(LOCK_FB_GPIO_Port, LOCK_FB_Pin);
}
}
void GBT_Lock(uint8_t state){
GBT_LockState.demand = state;
}
void GBT_ManageLock(){
uint8_t MAX_RETRIES = 5;
if (GBT_LockState.error) {
return;
}
bool lock_is_open = GBT_LockGetState() == 0;
bool lock_should_be_open = GBT_LockState.demand == 0;
uint8_t retry_count = 0;
if (lock_is_open != lock_should_be_open) {
while (retry_count < MAX_RETRIES) {
if (lock_should_be_open) {
GBT_ForceLock(0);
} else {
GBT_ForceLock(1);
}
lock_is_open = GBT_LockGetState() == 0;
if (lock_is_open == lock_should_be_open) {
break;
}
retry_count++;
}
if (retry_count >= MAX_RETRIES) {
GBT_LockState.error = 1;
GBT_ForceLock(0);
printf ("Lock error\n");
}
}
}

32
Core/Src/main.c
View File

@@ -20,6 +20,7 @@
#include "main.h"
#include "adc.h"
#include "can.h"
#include "rtc.h"
#include "usart.h"
#include "gpio.h"
@@ -32,6 +33,9 @@
#include "charger_gbt.h"
#include "soft_rtc.h"
#include "j1939.h"
#include "lock.h"
#include "connector.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
@@ -100,6 +104,7 @@ int main(void)
MX_CAN1_Init();
MX_CAN2_Init();
MX_USART2_UART_Init();
MX_RTC_Init();
/* USER CODE BEGIN 2 */
CAN_ReInit();
Init_Peripheral();
@@ -109,10 +114,12 @@ int main(void)
set_Time(1721651966); //2024-07-22T12:39:26+00:00
printf("Startup (type \'help\' for command list)\n");
debug_init();
//EDCAN_Init(SW_GetAddr()); //0x20..0x23
EDCAN_Init(0x20); //Адрес EDCAN
CAN_ReInit();
EDCAN_Init(SW_GetAddr()); //0x20..0x23
//EDCAN_Init(0x20); //Адрес EDCAN
GBT_CAN_ReInit();
CAN_ReInit();
CONN_Init();
/* USER CODE END 2 */
/* Infinite loop */
@@ -122,11 +129,14 @@ int main(void)
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
// HAL_Delay(1);
EDCAN_Loop();
// can_task();
debug_task();
GBT_ChargerTask();
// HAL_Delay(1);
EDCAN_Loop();
//can_task();
debug_task();
CONN_CC_ReadStateFiltered();
GBT_ManageLock();
CONN_Task();
GBT_ChargerTask();
}
/* USER CODE END 3 */
@@ -145,9 +155,10 @@ void SystemClock_Config(void)
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV5;
RCC_OscInitStruct.LSEState = RCC_LSE_ON;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.Prediv1Source = RCC_PREDIV1_SOURCE_PLL2;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
@@ -174,7 +185,8 @@ void SystemClock_Config(void)
{
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC|RCC_PERIPHCLK_ADC;
PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{

93
Core/Src/rtc.c Normal file
View File

@@ -0,0 +1,93 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file rtc.c
* @brief This file provides code for the configuration
* of the RTC instances.
******************************************************************************
* @attention
*
* Copyright (c) 2024 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "rtc.h"
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
RTC_HandleTypeDef hrtc;
/* RTC init function */
void MX_RTC_Init(void)
{
/* USER CODE BEGIN RTC_Init 0 */
/* USER CODE END RTC_Init 0 */
/* USER CODE BEGIN RTC_Init 1 */
/* USER CODE END RTC_Init 1 */
/** Initialize RTC Only
*/
hrtc.Instance = RTC;
hrtc.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
hrtc.Init.OutPut = RTC_OUTPUTSOURCE_ALARM;
if (HAL_RTC_Init(&hrtc) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN RTC_Init 2 */
/* USER CODE END RTC_Init 2 */
}
void HAL_RTC_MspInit(RTC_HandleTypeDef* rtcHandle)
{
if(rtcHandle->Instance==RTC)
{
/* USER CODE BEGIN RTC_MspInit 0 */
/* USER CODE END RTC_MspInit 0 */
HAL_PWR_EnableBkUpAccess();
/* Enable BKP CLK enable for backup registers */
__HAL_RCC_BKP_CLK_ENABLE();
/* RTC clock enable */
__HAL_RCC_RTC_ENABLE();
/* USER CODE BEGIN RTC_MspInit 1 */
/* USER CODE END RTC_MspInit 1 */
}
}
void HAL_RTC_MspDeInit(RTC_HandleTypeDef* rtcHandle)
{
if(rtcHandle->Instance==RTC)
{
/* USER CODE BEGIN RTC_MspDeInit 0 */
/* USER CODE END RTC_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_RTC_DISABLE();
/* USER CODE BEGIN RTC_MspDeInit 1 */
/* USER CODE END RTC_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */

133
Core/Src/soft_rtc.c
View File

@@ -9,17 +9,22 @@
#include <stdint.h>
#include <time.h>
uint32_t GBT_time_offset; //current time = offset+HAL_GetTick()/1000;
uint8_t tmp_time[4];
uint8_t tmp_time32;
uint32_t tmp_time32;
extern RTC_HandleTypeDef hrtc;
static HAL_StatusTypeDef RTC1_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter);
static uint32_t RTC1_ReadTimeCounter(RTC_HandleTypeDef *hrtc);
static HAL_StatusTypeDef RTC1_ExitInitMode(RTC_HandleTypeDef *hrtc);
static HAL_StatusTypeDef RTC1_EnterInitMode(RTC_HandleTypeDef *hrtc);
uint32_t get_Current_Time(){
return GBT_time_offset + (HAL_GetTick()/1000);
return RTC1_ReadTimeCounter(&hrtc);
}
void set_Time(uint32_t unix_time){
if(unix_time <= (HAL_GetTick()/1000)) return; //invalid time
GBT_time_offset = unix_time - (HAL_GetTick()/1000);
RTC1_WriteTimeCounter(&hrtc, unix_time);
}
uint8_t to_bcd(int value) {
@@ -72,3 +77,121 @@ uint8_t getTimeReg(uint8_t reg_number){
//
// return 0;
//}
/**
* @brief Read the time counter available in RTC_CNT registers.
* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
* the configuration information for RTC.
* @retval Time counter
*/
static uint32_t RTC1_ReadTimeCounter(RTC_HandleTypeDef *hrtc)
{
uint16_t high1 = 0U, high2 = 0U, low = 0U;
uint32_t timecounter = 0U;
high1 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
low = READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT);
high2 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
if (high1 != high2)
{
/* In this case the counter roll over during reading of CNTL and CNTH registers,
read again CNTL register then return the counter value */
timecounter = (((uint32_t) high2 << 16U) | READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT));
}
else
{
/* No counter roll over during reading of CNTL and CNTH registers, counter
value is equal to first value of CNTL and CNTH */
timecounter = (((uint32_t) high1 << 16U) | low);
}
return timecounter;
}
/**
* @brief Write the time counter in RTC_CNT registers.
* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
* the configuration information for RTC.
* @param TimeCounter: Counter to write in RTC_CNT registers
* @retval HAL status
*/
static HAL_StatusTypeDef RTC1_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter)
{
HAL_StatusTypeDef status = HAL_OK;
/* Set Initialization mode */
if (RTC1_EnterInitMode(hrtc) != HAL_OK)
{
status = HAL_ERROR;
}
else
{
/* Set RTC COUNTER MSB word */
WRITE_REG(hrtc->Instance->CNTH, (TimeCounter >> 16U));
/* Set RTC COUNTER LSB word */
WRITE_REG(hrtc->Instance->CNTL, (TimeCounter & RTC_CNTL_RTC_CNT));
/* Wait for synchro */
if (RTC1_ExitInitMode(hrtc) != HAL_OK)
{
status = HAL_ERROR;
}
}
return status;
}
/**
* @brief Enters the RTC Initialization mode.
* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
* the configuration information for RTC.
* @retval HAL status
*/
static HAL_StatusTypeDef RTC1_EnterInitMode(RTC_HandleTypeDef *hrtc)
{
uint32_t tickstart = 0U;
tickstart = HAL_GetTick();
/* Wait till RTC is in INIT state and if Time out is reached exit */
while ((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
{
if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
/* Disable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
return HAL_OK;
}
/**
* @brief Exit the RTC Initialization mode.
* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
* the configuration information for RTC.
* @retval HAL status
*/
static HAL_StatusTypeDef RTC1_ExitInitMode(RTC_HandleTypeDef *hrtc)
{
uint32_t tickstart = 0U;
/* Disable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
tickstart = HAL_GetTick();
/* Wait till RTC is in INIT state and if Time out is reached exit */
while ((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
{
if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
return HAL_OK;
}