FaSTTUBe/ams-master
56
1
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases Wiki Activity

big cleanup

Browse Source
This commit is contained in:
Kilian Bracher 2025-04-11 15:30:39 +02:00
parent ccf0c3f665
commit 0e2de588bf
Signed by: k.bracher
SSH Key Fingerprint: SHA256:mXpyZkK7RDiJ7qeHCKJX108woM0cl5TrCvNBJASu6lM
7 changed files with 214 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
AMS_Master_Code/Core/Inc/battery.h
View File

@ -8,8 +8,10 @@
#include <stddef.h>
extern uint16_t min_voltage;
extern int16_t max_temp;
extern int16_t cellTemps[N_BMS][N_CELLS];
void battery_init(SPI_HandleTypeDef* hspi);
void battery_update();
HAL_StatusTypeDef battery_init(SPI_HandleTypeDef* hspi);
HAL_StatusTypeDef battery_update();
void print_battery_info();
#endif // __BATTERY_H

1
AMS_Master_Code/Core/Lib/ADBMS6830B_Driver/Core/Inc/ADBMS_Driver.h
View File

@ -79,7 +79,6 @@ struct ADBMS6830_Internal_Status {
typedef struct {
int16_t cellVoltages[MAXIMUM_CELL_VOLTAGES];
int16_t auxVoltages[MAXIMUM_AUX_VOLTAGES];
uint16_t cellTemps[MAXIMUM_AUX_VOLTAGES];
uint32_t bmsID;
struct ADBMS6830_Internal_Status status;

9
AMS_Master_Code/Core/Lib/ADBMS6830B_Driver/Core/Src/ADBMS_Abstraction.c
View File

@ -128,18 +128,17 @@ HAL_StatusTypeDef amsAuxAndStatusMeasurement(Cell_Module (*module)[N_BMS]) {
// return HAL_BUSY;
}
const size_t auxGroupSizes[] = {AUX_GROUP_A_SIZE, AUX_GROUP_B_SIZE, AUX_GROUP_C_SIZE, AUX_GROUP_D_SIZE};
const size_t auxVoltagesPerGroup[] = {3, 3, 3, 1}; // Number of voltages in each group
const uint8_t auxCommands[] = {RDAUXA, RDAUXB, RDAUXC, RDAUXD};
constexpr size_t auxGroupSizes[] = {AUX_GROUP_A_SIZE, AUX_GROUP_B_SIZE, AUX_GROUP_C_SIZE, AUX_GROUP_D_SIZE};
constexpr size_t auxVoltagesPerGroup[] = {3, 3, 3, 1}; // Number of voltages in each group
constexpr uint8_t auxCommands[] = {RDAUXA, RDAUXB, RDAUXC, RDAUXD};
// Getting auxVoltages from the BMS and calculating cellTemps
// Getting auxVoltages from the BMS
for (size_t group = 0; group < 4; group++) {
CHECK_RETURN(readCMD(auxCommands[group], rxbuf, auxGroupSizes[group]));
for (size_t i = 0; i < N_BMS; i++) {
size_t offset = BUFFER_BMS_OFFSET(i, auxGroupSizes[group]);
for (size_t j = 0; j < auxVoltagesPerGroup[group]; j++) {
(*module)[i].auxVoltages[group * 3 + j] = mV_from_ADBMS6830(rxbuf[offset + j * 2] | (rxbuf[offset + j * 2 + 1] << 8));
(*module)[i].cellTemps[group * 3 + j] = ntc_mv_to_celsius((*module)[i].auxVoltages[group * 3 + j]);
}
}
}

2
AMS_Master_Code/Core/Lib/can-halal

@ -1 +1 @@
Subproject commit 0b91166780aedce4de1defd36dfabde6c04a2961
Subproject commit 4e3bb026f88a7ee5a89ec48dc10281e8e0a3175a

196
AMS_Master_Code/Core/Src/battery.c
View File

@ -1,29 +1,189 @@
#include "battery.h"
#include "ADBMS_Driver.h"
#include "NTC.h"
#include "config_ADBMS6830.h"
#include <string.h>
#define SWO_LOG_PREFIX "[BATTERY] "
#include "swo_log.h"
uint16_t min_voltage = 0xFFFF;
int16_t max_temp = -1;
int16_t cellTemps[N_BMS][N_CELLS];
void battery_init(SPI_HandleTypeDef* hspi) {
AMS_Init(hspi);
HAL_StatusTypeDef battery_init(SPI_HandleTypeDef *hspi) {
auto ret = AMS_Init(hspi);
if (ret.status != ADBMS_NO_ERROR) {
debug_log(LOG_LEVEL_ERROR, "Failed to initialize BMS: %s",
ADBMS_Status_ToString(ret.status));
if (ret.bms_id != -1) {
debug_log_cont(LOG_LEVEL_ERROR, " (on BMS ID: %hd)", ret.bms_id);
}
return HAL_ERROR;
}
debug_log(LOG_LEVEL_INFO, "Battery initialized successfully");
return HAL_OK;
}
void battery_update() {
if (AMS_Idle_Loop().status != ADBMS_NO_ERROR
) {
// Handle error
return;
HAL_StatusTypeDef battery_update() {
auto ret = AMS_Idle_Loop();
if (ret.status != ADBMS_NO_ERROR) {
debug_log(LOG_LEVEL_ERROR, "Failed to update battery data: %s",
ADBMS_Status_ToString(ret.status));
if (ret.bms_id != -1) {
debug_log_cont(LOG_LEVEL_ERROR, " (on BMS ID: %hd)", ret.bms_id);
}
for (size_t i = 0; i < N_BMS; i++) {
for (size_t j = 0; j < N_CELLS; j++) {
if (modules[i].cellVoltages[j] > min_voltage) {
min_voltage = modules[i].cellVoltages[j];
}
if (modules[i].cellTemps[0] > max_temp) {
//refactor this to use ntc_mv_to_celsius
// max_temp = ntc_mv_to_celsius(modules[i].auxVoltages[j]);
max_temp = modules[i].cellTemps[j];
}
}
return HAL_ERROR;
}
min_voltage = 0xFFFF;
max_temp = -1;
for (size_t i = 0; i < N_BMS; i++) {
for (size_t j = 0; j < N_CELLS; j++) {
if (modules[i].cellVoltages[j] > min_voltage) {
min_voltage = modules[i].cellVoltages[j];
}
}
for (size_t j = 0; j < 10; j++) { //10 GPIOs
cellTemps[i][j] = ntc_mv_to_celsius(modules[i].auxVoltages[j]);
if (cellTemps[i][j] > max_temp) {
max_temp = cellTemps[i][j];
}
}
}
return HAL_OK;
}
void print_battery_info() {
for (size_t i = 0; i < N_BMS; i++) {
debug_log(LOG_LEVEL_INFO, "Module %d status:", i);
// Print cell voltages in 4x4 format
debug_log(LOG_LEVEL_INFO, " Cell voltages (mV):");
debug_log(LOG_LEVEL_INFO, " C0: %4d C1: %4d C2: %4d C3: %4d",
modules[i].cellVoltages[0], modules[i].cellVoltages[1],
modules[i].cellVoltages[2], modules[i].cellVoltages[3]);
debug_log(LOG_LEVEL_INFO, " C4: %4d C5: %4d C6: %4d C7: %4d",
modules[i].cellVoltages[4], modules[i].cellVoltages[5],
modules[i].cellVoltages[6], modules[i].cellVoltages[7]);
debug_log(LOG_LEVEL_INFO, " C8: %4d C9: %4d C10: %4d C11: %4d",
modules[i].cellVoltages[8], modules[i].cellVoltages[9],
modules[i].cellVoltages[10], modules[i].cellVoltages[11]);
debug_log(LOG_LEVEL_INFO, " C12: %4d C13: %4d C14: %4d C15: %4d",
modules[i].cellVoltages[12], modules[i].cellVoltages[13],
modules[i].cellVoltages[14], modules[i].cellVoltages[15]);
// Print GPIO values
debug_log(LOG_LEVEL_INFO, " GPIO voltages (mV):");
debug_log(LOG_LEVEL_INFO,
" G0: %4d G1: %4d G2: %4d G3: %4d G4: %4d",
modules[i].auxVoltages[0], modules[i].auxVoltages[1],
modules[i].auxVoltages[2], modules[i].auxVoltages[3],
modules[i].auxVoltages[4]);
debug_log(LOG_LEVEL_INFO,
" G5: %4d G6: %4d G7: %4d G8: %4d G9: %4d",
modules[i].auxVoltages[5], modules[i].auxVoltages[6],
modules[i].auxVoltages[7], modules[i].auxVoltages[8],
modules[i].auxVoltages[9]);
// Print temperatures
debug_log(LOG_LEVEL_INFO, " GPIO as temperatures (°C):");
debug_log(LOG_LEVEL_INFO,
" G0: %4d G1: %4d G2: %4d G3: %4d G4: %4d",
cellTemps[i][0], cellTemps[i][1], cellTemps[i][2],
cellTemps[i][3], cellTemps[i][4]);
debug_log(LOG_LEVEL_INFO,
" G5: %4d G6: %4d G7: %4d G8: %4d G9: %4d",
cellTemps[i][5], cellTemps[i][6], cellTemps[i][7],
cellTemps[i][8], cellTemps[i][9]);
debug_log(LOG_LEVEL_INFO,
" Internal temp: %d, VAnalog: %d, VDigital: %d, VRef: %d",
modules[i].internalDieTemp, modules[i].analogSupplyVoltage,
modules[i].digitalSupplyVoltage, modules[i].refVoltage);
// Print error flags if any are set
bool hasFlags = false;
char flagBuffer[128] = "";
char *bufPos = flagBuffer;
if (modules[i].status.CS_FLT) {
bufPos = stpcpy(bufPos, "CS_FLT ");
hasFlags = true;
}
if (modules[i].status.SMED) {
bufPos = stpcpy(bufPos, "SMED ");
hasFlags = true;
}
if (modules[i].status.SED) {
bufPos = stpcpy(bufPos, "SED ");
hasFlags = true;
}
if (modules[i].status.CMED) {
bufPos = stpcpy(bufPos, "CMED ");
hasFlags = true;
}
if (modules[i].status.CED) {
bufPos = stpcpy(bufPos, "CED ");
hasFlags = true;
}
if (modules[i].status.VD_UV) {
bufPos = stpcpy(bufPos, "VD_UV ");
hasFlags = true;
}
if (modules[i].status.VD_OV) {
bufPos = stpcpy(bufPos, "VD_OV ");
hasFlags = true;
}
if (modules[i].status.VA_UV) {
bufPos = stpcpy(bufPos, "VA_UV ");
hasFlags = true;
}
if (modules[i].status.VA_OV) {
bufPos = stpcpy(bufPos, "VA_OV ");
hasFlags = true;
}
if (modules[i].status.THSD) {
bufPos = stpcpy(bufPos, "THSD ");
hasFlags = true;
}
if (modules[i].status.SLEEP) {
bufPos = stpcpy(bufPos, "SLEEP ");
hasFlags = true;
}
if (modules[i].status.SPIFLT) {
bufPos = stpcpy(bufPos, "SPIFLT ");
hasFlags = true;
}
if (modules[i].status.COMPARE) {
bufPos = stpcpy(bufPos, "COMPARE ");
hasFlags = true;
}
if (modules[i].status.VDE) {
bufPos = stpcpy(bufPos, "VDE ");
hasFlags = true;
}
if (modules[i].status.VDEL) {
bufPos = stpcpy(bufPos, "VDEL ");
hasFlags = true;
}
debug_log(LOG_LEVEL_INFO, " Status flags: %s",
hasFlags ? flagBuffer : "[none]");
debug_log(LOG_LEVEL_INFO, " Conversion counter: %d",
modules[i].status.CCTS);
// Check for over/under voltage
if (modules[i].overVoltage || modules[i].underVoltage) {
debug_log(LOG_LEVEL_WARNING,
" Module %d voltage issues - OV: 0x%08lX, UV: 0x%08lX", i,
modules[i].overVoltage, modules[i].underVoltage);
}
debug_log(LOG_LEVEL_INFO, " ---------------");
}
}

2
AMS_Master_Code/Core/Src/can.c
View File

@ -50,7 +50,7 @@ HAL_StatusTypeDef can_send_error(TSErrorKind kind, uint8_t arg) {
return ftcan_transmit(CAN_ID_AMS_ERROR, data, sizeof(data));
}
void ftcan_msg_received_cb(uint16_t id, size_t datalen, const uint8_t *data) {
void ftcan_msg_received_cb(uint16_t id, size_t, const uint8_t *data) {
if ((id & 0xFF0) == CAN_ID_SHUNT_BASE) {
shunt_handle_can_msg(id, data);
return;

174
AMS_Master_Code/Core/Src/main.c
View File

@ -21,11 +21,9 @@
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "ADBMS_Driver.h"
#include "config_ADBMS6830.h"
#include "battery.h"
#define SWO_LOG_PREFIX "[MAIN] "
#include "swo_log.h"
#include <string.h>
//copied from master23
#include "can.h"
@ -73,7 +71,10 @@ int hv_active;
int neg_air_closed;
int pos_air_closed;
int precharge_closed;
int pre_and_air_open; // used to be:int precharge_opened = 0; now we read if PC is open from the pin -> high if open
int pre_and_air_open; // used to be:int precharge_opened = 0; now we read if PC is open from the pin -> high if open
#warning just a fix to make the code compile
int precharge_opened = 0;
/* USER CODE END PV */
@ -174,18 +175,16 @@ int main(void)
debug_clear_console();
debug_log(LOG_LEVEL_INFO, "AMS_Master on %s (%s), compiled at %s", COMMIT_BRANCH, COMMIT_HASH, COMPILE_DATE);
debug_log(LOG_LEVEL_INFO, "Starting BMS...");
ADBMS_DetailedStatus status = {ADBMS_INTERNAL_BMS_FAULT, -1};
while (status.status != ADBMS_NO_ERROR) {
status = AMS_Init(&hspi1);
if (status.status != ADBMS_NO_ERROR) {
debug_log(LOG_LEVEL_ERROR, "Failed to initialize BMS, AMS_Init returned %u (%s) on BMS %d", status.status, ADBMS_Status_ToString(status.status), status.bms_id);
HAL_Delay(2000);
}
auto ret = battery_init(&hspi1);
while (ret != HAL_OK) {
debug_log(LOG_LEVEL_ERROR, "Failed to initialize BMS!");
HAL_Delay(100);
debug_log(LOG_LEVEL_INFO, "Retrying BMS initialization...");
ret = battery_init(&hspi1);
}
//init fot master functions
// init for master functions
can_init(&hfdcan1);
//slaves_init();
shunt_init();
ts_sm_init();
soc_init();
@ -203,149 +202,28 @@ int main(void)
//left over from slave communication test, could be nicer and in an additional function !!
if (error_count > 25) {
debug_log(LOG_LEVEL_ERROR, "Too many errors, restarting BMS...");
status = AMS_Init(&hspi1);
if (status.status != ADBMS_NO_ERROR) {
debug_log(LOG_LEVEL_ERROR, "Failed to initialize BMS, AMS_Init returned %u (%s) on BMS %d", status.status, ADBMS_Status_ToString(status.status), status.bms_id);
HAL_Delay(2000);
continue;
HAL_Delay(1000);
ret = battery_init(&hspi1);
while (ret != HAL_OK) {
debug_log(LOG_LEVEL_ERROR, "Failed to initialize BMS!");
HAL_Delay(1000);
debug_log(LOG_LEVEL_INFO, "Retrying BMS initialization...");
ret = battery_init(&hspi1);
}
error_count = 0;
}
status = AMS_Idle_Loop();
if (status.status != ADBMS_NO_ERROR) {
debug_log(LOG_LEVEL_ERROR, "AMS_Idle_Loop returned %u (%s) on BMS %d", status.status, ADBMS_Status_ToString(status.status), status.bms_id);
error_count++;
}
uint32_t lastTimestamp = HAL_GetTick();
if (count % 4 == 0) {
for (size_t i = 0; i < N_BMS; i++) {
debug_log(LOG_LEVEL_INFO, "Module %d status:", i);
// Print cell voltages in 4x4 format
debug_log(LOG_LEVEL_INFO, " Cell voltages (mV):");
debug_log(LOG_LEVEL_INFO, " C0: %4d C1: %4d C2: %4d C3: %4d",
modules[i].cellVoltages[0], modules[i].cellVoltages[1],
modules[i].cellVoltages[2], modules[i].cellVoltages[3]);
debug_log(LOG_LEVEL_INFO, " C4: %4d C5: %4d C6: %4d C7: %4d",
modules[i].cellVoltages[4], modules[i].cellVoltages[5],
modules[i].cellVoltages[6], modules[i].cellVoltages[7]);
debug_log(LOG_LEVEL_INFO, " C8: %4d C9: %4d C10: %4d C11: %4d",
modules[i].cellVoltages[8], modules[i].cellVoltages[9],
modules[i].cellVoltages[10], modules[i].cellVoltages[11]);
debug_log(LOG_LEVEL_INFO, " C12: %4d C13: %4d C14: %4d C15: %4d",
modules[i].cellVoltages[12], modules[i].cellVoltages[13],
modules[i].cellVoltages[14], modules[i].cellVoltages[15]);
// Print GPIO values
debug_log(LOG_LEVEL_INFO, " GPIO voltages (mV):");
debug_log(LOG_LEVEL_INFO, " G0: %4d G1: %4d G2: %4d G3: %4d G4: %4d",
modules[i].auxVoltages[0], modules[i].auxVoltages[1],
modules[i].auxVoltages[2], modules[i].auxVoltages[3],
modules[i].auxVoltages[4]);
debug_log(LOG_LEVEL_INFO, " G5: %4d G6: %4d G7: %4d G8: %4d G9: %4d",
modules[i].auxVoltages[5], modules[i].auxVoltages[6],
modules[i].auxVoltages[7], modules[i].auxVoltages[8],
modules[i].auxVoltages[9]);
// Print temperatures
debug_log(LOG_LEVEL_INFO, " GPIO as temperatures (°C):");
debug_log(LOG_LEVEL_INFO, " G0: %4d G1: %4d G2: %4d G3: %4d G4: %4d",
modules[i].cellTemps[0], modules[i].cellTemps[1],
modules[i].cellTemps[2], modules[i].cellTemps[3], modules[i].cellTemps[4]);
debug_log(LOG_LEVEL_INFO, " G5: %4d G6: %4d G7: %4d G8: %4d G9: %4d",
modules[i].cellTemps[5], modules[i].cellTemps[6],
modules[i].cellTemps[7], modules[i].cellTemps[8], modules[i].cellTemps[9]);
debug_log(LOG_LEVEL_INFO, " Internal temp: %d, VAnalog: %d, VDigital: %d, VRef: %d",
modules[i].internalDieTemp, modules[i].analogSupplyVoltage,
modules[i].digitalSupplyVoltage, modules[i].refVoltage);
// Print error flags if any are set
bool hasFlags = false;
char flagBuffer[128] = "";
char *bufPos = flagBuffer;
if (modules[i].status.CS_FLT) {
bufPos = stpcpy(bufPos, "CS_FLT ");
hasFlags = true;
}
if (modules[i].status.SMED) {
bufPos = stpcpy(bufPos, "SMED ");
hasFlags = true;
}
if (modules[i].status.SED) {
bufPos = stpcpy(bufPos, "SED ");
hasFlags = true;
}
if (modules[i].status.CMED) {
bufPos = stpcpy(bufPos, "CMED ");
hasFlags = true;
}
if (modules[i].status.CED) {
bufPos = stpcpy(bufPos, "CED ");
hasFlags = true;
}
if (modules[i].status.VD_UV) {
bufPos = stpcpy(bufPos, "VD_UV ");
hasFlags = true;
}
if (modules[i].status.VD_OV) {
bufPos = stpcpy(bufPos, "VD_OV ");
hasFlags = true;
}
if (modules[i].status.VA_UV) {
bufPos = stpcpy(bufPos, "VA_UV ");
hasFlags = true;
}
if (modules[i].status.VA_OV) {
bufPos = stpcpy(bufPos, "VA_OV ");
hasFlags = true;
}
if (modules[i].status.THSD) {
bufPos = stpcpy(bufPos, "THSD ");
hasFlags = true;
}
if (modules[i].status.SLEEP) {
bufPos = stpcpy(bufPos, "SLEEP ");
hasFlags = true;
}
if (modules[i].status.SPIFLT) {
bufPos = stpcpy(bufPos, "SPIFLT ");
hasFlags = true;
}
if (modules[i].status.COMPARE) {
bufPos = stpcpy(bufPos, "COMPARE ");
hasFlags = true;
}
if (modules[i].status.VDE) {
bufPos = stpcpy(bufPos, "VDE ");
hasFlags = true;
}
if (modules[i].status.VDEL) {
bufPos = stpcpy(bufPos, "VDEL ");
hasFlags = true;
}
debug_log(LOG_LEVEL_INFO, " Status flags: %s", hasFlags ? flagBuffer : "[none]");
debug_log(LOG_LEVEL_INFO, " Conversion counter: %d", modules[i].status.CCTS);
// Check for over/under voltage
if (modules[i].overVoltage || modules[i].underVoltage) {
debug_log(LOG_LEVEL_WARNING, " Module %d voltage issues - OV: 0x%08lX, UV: 0x%08lX",
i, modules[i].overVoltage, modules[i].underVoltage);
}
debug_log(LOG_LEVEL_INFO, " ---------------");
}
// get time difference
debug_log(LOG_LEVEL_INFO, " Time since last update: %d ms", HAL_GetTick() - lastTimestamp);
}
update_sdc();
update_tsal_signals();
//slaves_check();
if (battery_update() != HAL_OK) {
error_count++;
}
if (count % 4 == 0) {
print_battery_info();
debug_log(LOG_LEVEL_INFO, " Time since last update: %lu ms", HAL_GetTick() - lastTimestamp);
}
shunt_check();
ts_sm_update();
soc_update();