// https://controllerstech.com/eeprom-and-stm32/ #include #include "eeprom.h" #include "stdio.h" #include "modbus.h" #define CONCAT(a, b) CONCAT_INNER(a, b) // These three macros #define CONCAT_INNER(a, b) a ## b // generate unique variables #define UNIQUE_NAME(base) CONCAT(base, __COUNTER__) // according to template "baseX", like "base1", "base2" and etc // Define the I2C extern I2C_HandleTypeDef hi2c3; #define EEPROM_I2C &hi2c3 // EEPROM ADDRESS (8bits) #define EEPROM_ADDR 0xA0 // Define the Page Size and number of pages #define PAGE_SIZE 64 // in Bytes #define PAGE_NUM 4096 // number of pages #define PADDRPOSITION 6 //MUST BE calculated for every eeprom type --//int paddrposition = log(PAGE_SIZE)/log(2); /********************************************************/ // Eeprom state related defines /*****************EEPROM_EMULATOR************************/ typedef struct { // Schnittstellenparameter uint32_t baudrate; uint16_t parityMode; uint16_t stopBits; uint16_t slave_adress; uint16_t ibn_day; uint16_t ibn_month; uint16_t ibn_year; uint16_t user_id; // Offset und Gain int16_t batteryCurrentOffsetRefTemperatureShunt; int16_t batteryCurrentOffsetRefTemperatureChip; int16_t batteryCurrentGainRefTempShunt; int16_t batteryCurrentGainRefTempChip; int16_t batteryCurrentOffsetTemperatureCalibrationTemperature; int16_t batteryCurrentGainTemperatureCalibrationShuntTemperature; int16_t batteryCurrentGainTemperatureCalibrationChipTemperature; int32_t batteryCurrentOffsetRefshuntVoltage; int32_t batteryCurrentOffsetCommonModeCalibrationVoltage; int32_t batteryCurrentOffsetCommonModeCompensationFactor; int32_t batteryCurrentOffsetTemperatureCompensationFactor; int32_t batteryCurrentGainRefCurrent; int32_t batteryCurrentGainTemperatureCompensationShuntFactor; int32_t batteryCurrentGainTemperatureCompensationChipFactor; int32_t currentOffset; uint32_t currentGain; int32_t currentOffsetFast; uint32_t currentGainFast; int64_t mAsCounter; int32_t detectedCapacity; int32_t detectedEnergy; int64_t mAs_AutoMode; // 160-163 Helps to restore current SoC after Reset or Shutdown int64_t mWs_AutoMode; // 164-167 Helps to restore current SoC after Reset or Shutdown // battery parameter uint16_t cef; uint16_t peukert; uint32_t cellCapacity; uint32_t cellEnergy; uint16_t iBatFull; uint16_t tBatFull; uint16_t uBatFull; uint16_t uBatEmpty; uint16_t socCalcMode; uint16_t cellRatedDischargeTime; // Schaltausgänge uint16_t lvpStart; // Spannung ab der die LOW Voltage Protection aktiv wird in mV uint16_t lvpStop; // Spannung ab der die LOW Voltage Protection wieder inaktiv wird uint16_t ovpStart; // Spannung ab der die OVER Voltage Protection aktiv wird in mV uint16_t ovpStop; // Spannung ab der die OVER Voltage Protection wieder inaktiv wird int16_t loadCurrentLimit; // maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv int16_t chargeCurrentLimit; // maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv int16_t chargeStopHighTemperatureStart; // Abschalttemperatur Ladung wegen zu hoher Temperatur int16_t chargeStopHighTemperatureStop; // Wiedereinschalttemperatur int16_t chargeStopLowTemperatureStart; // Abschalttemperatur Ladung wegen zu niedriger Temperatur int16_t chargeStopLowTemperatureStop; // Wiedereinschalttemperatur int16_t dischargeStopHighTemperatureStart; // Abschalttemperatur Entladung wegen zu hoher Temperatur int16_t dischargeStopHighTemperatureStop; // Wiedereinschalttemperatur int16_t dischargeStopLowTemperatureStart; // Abschalttemperatur EntLadung wegen zu niedriger Temperatur int16_t dischargeStopLowTemperatureStop; // Wiedereinschalttemperatur int16_t uBatEmptyCompStartTemp; // We start calculating uBatEmpty compensations only when cell temperature is lower than this value int16_t uBatEmptyCompStopTemp; // We stop calculating uBatEmpty compensations when cell temperature is lower than this value uint16_t uBatEmptyCompStopVolt; // uBatEmpty Voltage at temperatures lower than lvpCompStopTemp int16_t extraDischargeStrom_mA; // For example, current that consumes LiPro itself uint16_t cefW; int16_t batteryEmptyDetectionMode; uint16_t auxOutputMode; uint16_t auxOutputSetpointOn; uint16_t auxOutputSetpointOff; uint16_t auxOutputInverted; } eeprom_data_t; // Substitute for #if sizeof(some_type) == sizeof(another_type) functionality #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) typedef struct { // Geräteinformation uint32_t SN; uint8_t deviceInfoWritten; uint8_t UNIQUE_NAME(reserved)[3]; }device_info_t; typedef struct { // Eeprom Status Infos uint8_t firstStartId; uint8_t UNIQUE_NAME(reserved)[3]; uint16_t structureSize; uint16_t revisionInfo; uint32_t writeCounter; }eeprom_state_t; // fasse zu einer Struktur zusammen um nachher einfach darauf zugreifen zu können typedef struct { eeprom_state_t eepromState; device_info_t deviceInfo; eeprom_data_t changedData; }eeprom_stored_data_t; // Data to store reated defines //#define SIZEOF_DEFAULT_EEPROM_DATA (sizeof(eeprom_new_data_t)) //#define SIZEOF_CHANGED_EEPROM_DATA (sizeof(eeprom_data_t)) //#define SIZEOF_DEVICE_INFO (sizeof(device_info_t)) //#define SIZEOF_EEPROM_STATE (sizeof(eeprom_state_t)) //#define SIZE_OF_DATA_TO_STORE (SIZEOF_CHANGED_EEPROM_DATA + SIZEOF_DEVICE_INFO + SIZEOF_EEPROM_STATE) // Adress related defines #define EEPROM_ADRESS_FIRST_START_ID (0) #define FIRST_START_ID (0xFF) // See datasheet (Chapter "Initial delivery state") #define CONFIG_ID (01) // Increment by 1 to make compartible update, more than 1 - incompartible #if CONFIG_ID == FIRST_START_ID #error "CONFIG_ID must not be equal to FIRST_START_ID!!! Calibration data will be erased!!!" #endif static uint32_t GetPage(uint32_t Address); static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len); void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size); void EEPROM_Write (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size); static eeprom_stored_data_t eepromData; static FLASH_EraseInitTypeDef EraseInitStruct = {0}; static const eeprom_data_t defaultEepromData = { // Schnittstellenparameter /* baudrate */ 19200, // uint32_t baudrate; /* parityMode */ MODBUS_UART_PARITY_EVEN, // uint16_t parityMode; /* stopBits */ 1, // uint16_t stopBits; /* slave_adress */ 1, // uint16_t slave_adress; /* ibn_day */ 0, // ibm_day /* ibn_month */ 0, // ibm_month /* ibn_year */ 0, // ibm_year /* user_id */ 0, // user id // Offset und Gain /* batteryCurrentOffsetRefTemperatureShunt */ 0, // int16_t batteryCurrentOffsetRefTemperatureShunt; /* batteryCurrentOffsetRefTemperatureChip */ 0, // int16_t batteryCurrentOffsetRefTemperatureChip /* batteryCurrentGainRefTempShunt */ 0, // int16_t batteryCurrentGainRefTempShunt; /* batteryCurrentGainRefTempChip */ 0, // int16_t batteryCurrentGainRefTempShip /* batteryCurrentOffsetTemperatureCalibrationTemperature */ 0, // int16_t batteryCurrentOffsetTemperatureCalibrationTemperature; /* batteryCurrentGainTemperatureCalibrationShuntTemperature */ 0, // int16_t batteryCurrentGainTemperatureCalibrationShuntTemperature; /* batteryCurrentGainTemperatureCalibrationChipTemperature */ 0, // int16_t batteryCurrentGainTemperatureCalibrationChipTemperature; /* batteryCurrentOffsetRefshuntVoltage */ 0, // int32_t batteryCurrentOffsetRefshuntVoltage; /* batteryCurrentOffsetCommonModeCalibrationVoltage */ 0, // int32_t batteryCurrentOffsetCommonModeCalibrationVoltage; /* batteryCurrentOffsetTemperatureCompensationFactor */ 0, // int32_t batteryCurrentOffsetTemperatureCompensationFactor; /* batteryCurrentOffsetCommonModeCompensationFactor */ 0, // int32_t batteryCurrentOffsetCommonModeCompensationFactor; /* batteryCurrentGainRefCurrent */ 250000, // int32_t batteryCurrentGainRefCurrent; /* batteryCurrentGainTemperatureCompensationShuntFactor */ 0, // int32_t batteryCurrentGainTemperatureCompensationShuntFactor; /* batteryCurrentGainTemperatureCompensationChipFactor */ 0, // int32_t batteryCurrentGainTemperatureCompensationChipFactor; /* currentOffset */ 0, //int32_t currentOffset; /* currentGain */ 1000000, //uint32_t currentGain; /* currentOffsetFast */ 0, //int32_t currentOffset; /* currentGainFast */ 1000000, //uint32_t currentGain; /* mAsCounter */ 0, // mAsCounter /* detectedCapacity */ -1, // detectedCapacity /* detectedEnergy */ -1, // detectedEnergy /* mAs_AutoMode */ (-100000LL*3600LL), // mAs_AutoMode = cellCapacity*3600, /* mWs_AutoMode */ (-2640000LL*3600LL),// mWs_AutoMode = cellEnergy*3600, // battery parameter /* cef */ 990, // cef %*10 /* peukert */ 105, // peukert /* cellCapacity */ 160000, // cell Capacity in mAh /* cellEnergy */ 2048000, // cell energy in mWh /* iBatFull */ 10, // I-batt full 10%, 10A bei 100Ah akku /* tBatFull */ 2, // t-batt full 2 Sekunden #if defined SYSTEM_VOLTAGE_12V /* uBatFull */ 14000, // 14V olt Ubatt full, Neu: Bei 0: Erkung von Lipro LVP als 0% /* uBatEmpty */ 12400, // 11,312V Ubatt Empty #elif defined SYSTEM_VOLTAGE_24V /* uBatFull */ 28000, // 14V olt Ubatt full, Neu: Bei 0: Erkung von Lipro LVP als 0% /* uBatEmpty */ 24800, // 11,312V Ubatt Empty #elif defined SYSTEM_VOLTAGE_48V /* uBatFull */ 56000, // 14V olt Ubatt full, Neu: Bei 0: Erkung von Lipro LVP als 0% /* uBatEmpty */ 49600, // 11,312V Ubatt Empty #else #error "System voltage not defined" #endif /* socCalcMode */ 1, // SoC calculation mode: 0(default) /* cellRatedDischargeTime */ 2, // cell rated current discharge time [C/x]. For example, if 40Ah cell is rated as 0.5c, then rated discharge time is 2 #if defined SYSTEM_VOLTAGE_12V /* lvpStart */ 12000, // uint16_t lvpStart; Spannung ab der die LOW Voltage Protection aktiv wird in mV /* lvpStop */ 12500, // uint16_t lvpStop; Spannung ab der die LOW Voltage Protection wieder inaktiv wird /* ovpStart */ 14800, // uint16_t ovpStart; Spannung ab der die OVER Voltage Protection aktiv wird in mV /* ovpStop */ 14000, // uint16_t ovpStop; Spannung ab der die OVER Voltage Protection wieder inaktiv wird #elif defined SYSTEM_VOLTAGE_24V /* lvpStart */ 24000, // uint16_t lvpStart; Spannung ab der die LOW Voltage Protection aktiv wird in mV /* lvpStop */ 25000, // uint16_t lvpStop; Spannung ab der die LOW Voltage Protection wieder inaktiv wird /* ovpStart */ 29600, // uint16_t ovpStart; Spannung ab der die OVER Voltage Protection aktiv wird in mV /* ovpStop */ 28000, // uint16_t ovpStop; Spannung ab der die OVER Voltage Protection wieder inaktiv wird #elif defined SYSTEM_VOLTAGE_48V /* lvpStart */ 48000, // uint16_t lvpStart; Spannung ab der die LOW Voltage Protection aktiv wird in mV /* lvpStop */ 50000, // uint16_t lvpStop; Spannung ab der die LOW Voltage Protection wieder inaktiv wird /* ovpStart */ 59200, // uint16_t ovpStart; Spannung ab der die OVER Voltage Protection aktiv wird in mV /* ovpStop */ 56000, // uint16_t ovpStop; Spannung ab der die OVER Voltage Protection wieder inaktiv wird #else #error "System voltage not defined" #endif #if (DEVICETYPE == 500) /* loadCurrentLimit */ -500, // uint16_t loadCurrentLimit; maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv /* chargeCurrentLimit */ 500, // uint16_t chargeCurrentLimit; maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv #elif (DEVICETYPE == 250) /* loadCurrentLimit */ -250, // uint16_t loadCurrentLimit; maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv /* chargeCurrentLimit */ 250, // uint16_t chargeCurrentLimit maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv #elif (DEVICETYPE == 125) /* loadCurrentLimit */ -125, // uint16_t loadCurrentLimit; maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv /* chargeCurrentLimit */ 125, // uint16_t chargeCurrentLimit; maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv #else #error No valid device type #endif /* chargeStopHighTemperatureStart */ 6000, // 80°C int16_t chargeStopHighTemperatureStart; Abschalttemperatur Ladung wegen zu hoher Temperatur /* chargeStopHighTemperatureStop */ 5500, // 75°C int16_t chargeStopHighTemperatureStop; Wiedereinschalttemperatur /* chargeStopLowTemperatureStart */ -2500, // -35°C int16_t chargeStopLowTemperatureStart; Abschalttemperatur Ladung wegen zu niedriger Temperatur /* chargeStopLowTemperatureStop */ -2000, // -30°C int16_t chargeStopLowTemperatureStop; Wiedereinschalttemperatur /* dischargeStopHighTemperatureStart*/ 6000, // 80°C int16_t dischargeStopHighTemperatureStart; Abschalttemperatur Entladung wegen zu hoher Temperatur /* dischargeStopHighTemperatureStop */ 5500, // 75°C int16_t dischargeStopHighTemperatureStop; Wiedereinschalttemperatur /* dischargeStopLowTemperatureStart */ -3500, // -35°C int16_t dischargeStopLowTemperatureStart; Abschalttemperatur EntLadung wegen zu niedriger Temperatur /* dischargeStopLowTemperatureStop */ -3000, // -30°C int16_t dischargeStopLowTemperatureStop; Wiedereinschalttemperatur /* uBatEmptyCompStartTemp */ 50, // 5°C We start calculating uBatEmpty compensations only when cell temperature is lower than this value /* uBatEmptyCompStopTemp */ -200, // -20°C We stop calculating uBatEmpty compensations when cell temperature is lower than this value #if defined SYSTEM_VOLTAGE_12V /* uBatEmptyCompStopVolt */ 10000, // 10V uBatEmpty voltage at temperatures lower than -20°C #elif defined SYSTEM_VOLTAGE_24V /* uBatEmptyCompStopVolt */ 20000, // 10V uBatEmpty voltage at temperatures lower than -20°C #elif defined SYSTEM_VOLTAGE_48V /* uBatEmptyCompStopVolt */ 40000, // 10V uBatEmpty voltage at temperatures lower than -20°C #else #error "System voltage not defined" #endif /* extraDischargeStrom_mA */ 7, // mA, current that LiPro consumes itself /* cefW */ 900, // 90% cef for Wh calculations [%*10] /* Battery Empty Detection Mode*/ 1, // Auto, from BMS /* AUX MODE */ AUX_MODE_HEATER,// Heizung #if defined SYSTEM_VOLTAGE_12V /* AUX SETPOINT ON */ 13600, // Erkennung Ladegerät ab 13,6V #elif defined SYSTEM_VOLTAGE_24V /* AUX SETPOINT ON */ 27200, // Erkennung Ladegerät ab 13,6V #elif defined SYSTEM_VOLTAGE_48V /* AUX SETPOINT ON */ 54400, // Erkennung Ladegerät ab 13,6V #else #error No valid device type #endif /* AUX SETPOINT OFF */ 100, // Batterie Entladung wird erkannt bei -100mA /* AUX Inverted */ 0, // Nicht invertiert }; /** * @brief Gets the page of a given address * @param Addr: Address of the FLASH Memory * @retval The page of a given address */ static uint32_t GetPage(uint32_t Addr) { return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE; } startType_t EEPROM_isFirstStart(void) { uint8_t firstStartCatcher; EEPROM_Read(0, EEPROM_ADRESS_FIRST_START_ID, &firstStartCatcher, 1); if (firstStartCatcher == FIRST_START_ID) { printf ("First start detected!\n"); return FIRST_START_AFTER_ERASE; } else if (firstStartCatcher == CONFIG_ID) { printf ("Normal start without EEPROM changes detected\n"); return FIRST_START_AFTER_COMPARTIBLE_UPDATE; } else if (firstStartCatcher == CONFIG_ID - 1) { printf ("EEPROM was changed! We need to preserve calibration and settings data!\n"); return FIRST_START_AFTER_INCOMPARTIBLE_UPDATE; } else return FIRST_START_ERROR; } //------------------------------------------------------------------------------ HAL_StatusTypeDef EEPROM_fullRestore(sys_data_t* data) { printf("EEPROM FULL RESTORE!\n"); /**************** LESE_DEFAULT_WERTE ************************/ memcpy(&eepromData.changedData, &defaultEepromData, sizeof(eeprom_data_t)); // Eeprom Status Infos eepromData.eepromState.writeCounter++; eepromData.eepromState.structureSize = sizeof(eeprom_stored_data_t); eepromData.eepromState.revisionInfo = 0; eepromData.eepromState.firstStartId = CONFIG_ID; /**************** EEPROM Speichern ********************/ EEPROM_Write(0, 0, (uint8_t*)&eepromData, sizeof(eeprom_stored_data_t)); /**************** AUSLESEN_UND_PRÜFEN ********************/ return EEPROM_readConfig(data); } //------------------------------------------------------------------------------ //Werkeinstellung ohne Kalibrierwert Überschreibung HAL_StatusTypeDef EEPROM_factoryRestore(sys_data_t* data, int resetToDefault) { printf("EEPROM FACTORY RESTORE/UPDATE!\n"); //eeprom_stored_data_t* dataToStore = &eepromData; EEPROM_readConfig(data); // Restoring calibration data // Offset und Gain eepromData.changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt; eepromData.changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip; eepromData.changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage; eepromData.changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage; eepromData.changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor; eepromData.changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature; eepromData.changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor; eepromData.changedData.currentOffset = data->s.parameter.batteryCurrentOffset; eepromData.changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor; eepromData.changedData.currentOffsetFast = data->s.parameter.batteryCurrentOffsetFast; eepromData.changedData.currentGainFast = data->s.parameter.batteryCurrentGainCorrectionFaktorFast; eepromData.changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt; eepromData.changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip; eepromData.changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent; eepromData.changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature; eepromData.changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor; eepromData.changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature; eepromData.changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor; // Schnittstellenparameter eepromData.changedData.baudrate = defaultEepromData.baudrate; eepromData.changedData.parityMode = defaultEepromData.parityMode; eepromData.changedData.stopBits = defaultEepromData.stopBits; eepromData.changedData.slave_adress = defaultEepromData.slave_adress; eepromData.changedData.ibn_day = defaultEepromData.ibn_day; eepromData.changedData.ibn_month = defaultEepromData.ibn_month; eepromData.changedData.ibn_year = defaultEepromData.ibn_year; eepromData.changedData.user_id = defaultEepromData.user_id; //Ah counter eepromData.changedData.cef = defaultEepromData.cef; eepromData.changedData.cellCapacity = defaultEepromData.cellCapacity; eepromData.changedData.cellEnergy = defaultEepromData.cellEnergy; eepromData.changedData.iBatFull = defaultEepromData.iBatFull; eepromData.changedData.peukert = defaultEepromData.peukert; eepromData.changedData.tBatFull = defaultEepromData.tBatFull; eepromData.changedData.uBatFull = defaultEepromData.uBatFull; eepromData.changedData.uBatEmpty = defaultEepromData.uBatEmpty; eepromData.changedData.socCalcMode = defaultEepromData.socCalcMode; eepromData.changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime; // Schaltausgänge eepromData.changedData.lvpStart = defaultEepromData.lvpStart; eepromData.changedData.lvpStop = defaultEepromData.lvpStop; eepromData.changedData.ovpStart = defaultEepromData.ovpStart; eepromData.changedData.ovpStop = defaultEepromData.ovpStop; eepromData.changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit; eepromData.changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit; eepromData.changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart; eepromData.changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop; eepromData.changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart; eepromData.changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop; eepromData.changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart; eepromData.changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop; eepromData.changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart; eepromData.changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop; eepromData.changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp; eepromData.changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp; eepromData.changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt; eepromData.changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA; eepromData.changedData.cefW = defaultEepromData.cefW; eepromData.changedData.batteryEmptyDetectionMode = defaultEepromData.batteryEmptyDetectionMode; eepromData.changedData.auxOutputMode = defaultEepromData.auxOutputMode; eepromData.changedData.auxOutputSetpointOn = defaultEepromData.auxOutputSetpointOn; eepromData.changedData.auxOutputSetpointOff = defaultEepromData.auxOutputSetpointOff; eepromData.changedData.auxOutputInverted = defaultEepromData.auxOutputInverted; eepromData.eepromState.writeCounter = eepromData.eepromState.writeCounter++; eepromData.eepromState.structureSize = sizeof(eeprom_stored_data_t); eepromData.eepromState.revisionInfo = 0; eepromData.eepromState.firstStartId = CONFIG_ID; eepromData.deviceInfo.deviceInfoWritten = 1; eepromData.deviceInfo.SN = data->s.parameter.sn; EEPROM_Write(0,0, (uint8_t*)&eepromData, sizeof(eeprom_stored_data_t)); return EEPROM_readConfig(data); } HAL_StatusTypeDef EEPROM_storeConfig(sys_data_t* data, uint8_t withSN) { eeprom_stored_data_t* dataToStore; /****************LESE_WERTE_AUS_SYSDATA*********************/ printf("EEPROM STORE CONFIG!\n"); dataToStore = (eeprom_stored_data_t*)&eepromData; // Schnittstellenparameter dataToStore->changedData.baudrate = data->s.parameter.baudrate; dataToStore->changedData.parityMode = data->s.parameter.parityMode; dataToStore->changedData.stopBits = data->s.parameter.stopBit; dataToStore->changedData.slave_adress = data->s.parameter.slave_address; dataToStore->changedData.ibn_day = data->s.parameter.ibn_day; dataToStore->changedData.ibn_month = data->s.parameter.ibn_month; dataToStore->changedData.ibn_year = data->s.parameter.ibn_year; dataToStore->changedData.user_id = data->s.parameter.user_id; // Offset und Gain dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip; dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt; dataToStore->changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt; dataToStore->changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip; dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature; dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature; dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature; dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage; dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage; dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor; dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor; dataToStore->changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent; dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor; dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor; dataToStore->changedData.currentOffset = data->s.parameter.batteryCurrentOffset; dataToStore->changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor; dataToStore->changedData.currentOffsetFast = data->s.parameter.batteryCurrentOffsetFast; dataToStore->changedData.currentGainFast = data->s.parameter.batteryCurrentGainCorrectionFaktorFast; // AH COUNTER Einstellungen dataToStore->changedData.cef = data->s.parameter.cef; dataToStore->changedData.peukert = data->s.parameter.peukert; dataToStore->changedData.cellCapacity = data->s.parameter.cellCapacity; dataToStore->changedData.cellEnergy = data->s.parameter.battEnergy; dataToStore->changedData.iBatFull = data->s.parameter.iBatFull; dataToStore->changedData.tBatFull = data->s.parameter.tBatFull; dataToStore->changedData.uBatFull = data->s.parameter.uBatFull; dataToStore->changedData.uBatEmpty = data->s.parameter.uBatEmpty; dataToStore->changedData.socCalcMode = data->s.parameter.socCalcMode; dataToStore->changedData.cellRatedDischargeTime = data->s.parameter.cellRatedDischargeTime; // Schaltausgänge dataToStore->changedData.lvpStart = data->s.parameter.lvpStart; dataToStore->changedData.lvpStop = data->s.parameter.lvpStop; dataToStore->changedData.ovpStart = data->s.parameter.ovpStart; dataToStore->changedData.ovpStop = data->s.parameter.ovpStop; dataToStore->changedData.loadCurrentLimit = data->s.parameter.loadCurrentLimit; dataToStore->changedData.chargeCurrentLimit = data->s.parameter.chargeCurrentLimit; dataToStore->changedData.chargeStopHighTemperatureStart = data->s.parameter.chargeStopHighTemperatureStart; dataToStore->changedData.chargeStopHighTemperatureStop = data->s.parameter.chargeStopHighTemperatureStop; dataToStore->changedData.chargeStopLowTemperatureStart = data->s.parameter.chargeStopLowTemperatureStart; dataToStore->changedData.chargeStopLowTemperatureStop = data->s.parameter.chargeStopLowTemperatureStop; dataToStore->changedData.dischargeStopHighTemperatureStart = data->s.parameter.dischargeStopHighTemperatureStart; dataToStore->changedData.dischargeStopHighTemperatureStop = data->s.parameter.dischargeStopHighTemperatureStop; dataToStore->changedData.dischargeStopLowTemperatureStart = data->s.parameter.dischargeStopLowTemperatureStart; dataToStore->changedData.dischargeStopLowTemperatureStop = data->s.parameter.dischargeStopLowTemperatureStop; // Neue Parameter für SOC dataToStore->changedData.uBatEmptyCompStartTemp = data->s.parameter.uBatEmptyCompStartTemp; dataToStore->changedData.uBatEmptyCompStopTemp = data->s.parameter.uBatEmptyCompStopTemp; dataToStore->changedData.uBatEmptyCompStopVolt = data->s.parameter.uBatEmptyCompStopVolt; dataToStore->changedData.extraDischargeStrom_mA = data->s.parameter.extraDischargeStrom_mA; dataToStore->changedData.cefW = data->s.parameter.cefW; dataToStore->changedData.batteryEmptyDetectionMode = data->s.parameter.batteryEmptyDetectionMode; dataToStore->changedData.auxOutputMode = data->s.parameter.auxOutputMode; dataToStore->changedData.auxOutputSetpointOn = data->s.parameter.auxOutputSetpointOn; dataToStore->changedData.auxOutputSetpointOff = data->s.parameter.auxOutputSetpointOff; dataToStore->changedData.auxOutputInverted = data->s.parameter.auxOutputInverted; // Eeprom Status Infos dataToStore->eepromState.writeCounter++; dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t); dataToStore->eepromState.revisionInfo = 0; dataToStore->eepromState.firstStartId = CONFIG_ID; if (withSN) { printf("Writing SN!\n"); dataToStore->deviceInfo.SN = data->s.parameter.sn; } EEPROM_Write(0,0, (uint8_t*)dataToStore, sizeof(eeprom_stored_data_t)); return EEPROM_readConfig(data); } //------------------------------------------------------------------------------ HAL_StatusTypeDef EEPROM_readConfig(sys_data_t* data) { eeprom_stored_data_t* dataToStore; /****************WERTE_AUS_EEPROM_LESEN********************/ EEPROM_Read(0, 0, (uint8_t*)&eepromData, sizeof(eepromData)); dataToStore = (eeprom_stored_data_t*)&eepromData; // Schnittstellenparameter data->s.parameter.baudrate = dataToStore->changedData.baudrate; data->s.parameter.parityMode = dataToStore->changedData.parityMode; data->s.parameter.stopBit = dataToStore->changedData.stopBits; data->s.parameter.slave_address = dataToStore->changedData.slave_adress; data->s.parameter.ibn_day = dataToStore->changedData.ibn_day; data->s.parameter.ibn_month = dataToStore->changedData.ibn_month; data->s.parameter.ibn_year = dataToStore->changedData.ibn_year; data->s.parameter.user_id = dataToStore->changedData.user_id; // Offset und Gain data->s.parameter.batteryCurrentOffsetRefTemperatureShunt = dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt; data->s.parameter.batteryCurrentOffsetRefTemperatureChip = dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip; data->s.parameter.batteryCurrentGainRefTempShunt = dataToStore->changedData.batteryCurrentGainRefTempShunt; data->s.parameter.batteryCurrentGainRefTempChip = dataToStore->changedData.batteryCurrentGainRefTempChip; data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature = dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature; data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature = dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature; data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature = dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature; data->s.parameter.batteryCurrentOffsetRefshuntVoltage = dataToStore ->changedData.batteryCurrentOffsetRefshuntVoltage; data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage = dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage; data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor = dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor; data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor = dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor; data->s.parameter.batteryCurrentGainRefCurrent = dataToStore->changedData.batteryCurrentGainRefCurrent; data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor = dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor; data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor = dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor; data->s.parameter.batteryCurrentOffset = dataToStore->changedData.currentOffset; data->s.parameter.batteryCurrentGainCorrectionFaktor = dataToStore->changedData.currentGain; data->s.parameter.batteryCurrentOffsetFast = dataToStore->changedData.currentOffsetFast; data->s.parameter.batteryCurrentGainCorrectionFaktorFast = dataToStore->changedData.currentGainFast; //Einstellungenm für AH counter data->s.parameter.cef = dataToStore ->changedData.cef; data->s.parameter.peukert = dataToStore ->changedData.peukert; data->s.parameter.cellCapacity = dataToStore ->changedData.cellCapacity; data->s.parameter.battEnergy = dataToStore ->changedData.cellEnergy; data->s.parameter.iBatFull = dataToStore ->changedData.iBatFull; data->s.parameter.tBatFull = dataToStore->changedData.tBatFull; data->s.parameter.uBatFull = dataToStore->changedData.uBatFull; data->s.parameter.uBatEmpty = dataToStore->changedData.uBatEmpty; data->s.parameter.socCalcMode = dataToStore->changedData.socCalcMode; data->s.parameter.cellRatedDischargeTime = dataToStore->changedData.cellRatedDischargeTime; // New EU directive says that cell Energy in Wh must be somwhere on the // visible part of the cell as well as capacity in Ah // Schaltausgänge data->s.parameter.lvpStart = dataToStore->changedData.lvpStart; data->s.parameter.lvpStop = dataToStore->changedData.lvpStop; data->s.parameter.ovpStart = dataToStore->changedData.ovpStart; data->s.parameter.ovpStop = dataToStore->changedData.ovpStop; data->s.parameter.loadCurrentLimit = dataToStore->changedData.loadCurrentLimit; data->s.parameter.chargeCurrentLimit = dataToStore->changedData.chargeCurrentLimit; data->s.parameter.chargeStopHighTemperatureStart = dataToStore->changedData.chargeStopHighTemperatureStart; data->s.parameter.chargeStopHighTemperatureStop = dataToStore->changedData.chargeStopHighTemperatureStop; data->s.parameter.chargeStopLowTemperatureStart = dataToStore->changedData.chargeStopLowTemperatureStart; data->s.parameter.chargeStopLowTemperatureStop = dataToStore->changedData.chargeStopLowTemperatureStop; data->s.parameter.dischargeStopHighTemperatureStart = dataToStore->changedData.dischargeStopHighTemperatureStart; data->s.parameter.dischargeStopHighTemperatureStop = dataToStore->changedData.dischargeStopHighTemperatureStop; data->s.parameter.dischargeStopLowTemperatureStart = dataToStore->changedData.dischargeStopLowTemperatureStart; data->s.parameter.dischargeStopLowTemperatureStop = dataToStore->changedData.dischargeStopLowTemperatureStop; data->s.parameter.uBatEmptyCompStartTemp = dataToStore->changedData.uBatEmptyCompStartTemp; data->s.parameter.uBatEmptyCompStopTemp = dataToStore->changedData.uBatEmptyCompStopTemp; data->s.parameter.uBatEmptyCompStopVolt = dataToStore->changedData.uBatEmptyCompStopVolt; data->s.parameter.extraDischargeStrom_mA = dataToStore->changedData.extraDischargeStrom_mA; data->s.parameter.cefW = dataToStore->changedData.cefW; data->s.parameter.batteryEmptyDetectionMode = dataToStore->changedData.batteryEmptyDetectionMode; data->s.parameter.auxOutputMode = dataToStore->changedData.auxOutputMode; data->s.parameter.auxOutputSetpointOn = dataToStore->changedData.auxOutputSetpointOn; data->s.parameter.auxOutputSetpointOff = dataToStore->changedData.auxOutputSetpointOff; data->s.parameter.auxOutputInverted = dataToStore->changedData.auxOutputInverted; // Geräteinformation data->s.parameter.sn = dataToStore->deviceInfo.SN; // prüfe Eeprom Status Infos //dataToStore->eepromState.writeCounter ++ ; if (dataToStore->eepromState.structureSize != sizeof(eeprom_stored_data_t)) return HAL_ERROR; if (dataToStore->eepromState.revisionInfo != 0) return HAL_ERROR; if (dataToStore->eepromState.firstStartId != CONFIG_ID) return HAL_ERROR; return HAL_OK; } /*Entfernte EEPROM Werte data->s.values.dischargeTotalAh = dataToStore->changedData.dischargeTotalAh; data->s.values.chargeTotalAh = dataToStore->changedData.chargeTotalAh; data->s.values.dischargeTotalWh = dataToStore->changedData.dischargeTotalWh; data->s.values.chargeTotalWh = dataToStore->changedData.chargeTotalWh; data->s.values.onTime = dataToStore->changedData.onTime; data->s.values.mAsCounter = dataToStore->changedData.mAsCounter; data->s.values.detectedCapacity = dataToStore->changedData.detectedCapacity; data->s.values.detectedEnergy = dataToStore->changedData.detectedEnergy; data->s.values.mAs_AutoMode = dataToStore->changedData.mAs_AutoMode; data->s.values.mWs_AutoMode = dataToStore->changedData.mWs_AutoMode; */ //--- NEW Functions // function to determine the remaining bytes uint16_t bytestowrite (uint16_t size, uint16_t offset) { if ((size+offset)