source: trunk/fw_g473rct/SES/src/eeprom.c@ 20

Last change on this file since 20 was 20, checked in by f.jahn, 4 months ago

adc dma funktioniert und modbus funktioniert
File size: 48.8 KB
Line 
1//https://controllerstech.com/eeprom-and-stm32/
2
3#include "eeprom.h"
4#include "stdio.h"
5#include "math.h"
6
7#define CONCAT(a, b) CONCAT_INNER(a, b) // These three macros
8#define CONCAT_INNER(a, b) a ## b // generate unique variables
9#define UNIQUE_NAME(base) CONCAT(base, __COUNTER__) // according to template "baseX", like "base1", "base2" and etc
10
11// Define the I2C
12extern I2C_HandleTypeDef hi2c3;
13#define EEPROM_I2C &hi2c3
14
15// EEPROM ADDRESS (8bits)
16#define EEPROM_ADDR 0xA0
17
18// Define the Page Size and number of pages
19#define PAGE_SIZE 64 // in Bytes
20#define PAGE_NUM 4096 // number of pages
21
22/********************************************************/
23
24// Eeprom state related defines
25
26/*****************EEPROM_EMULATOR************************/
27
28typedef struct
29{
30 // Schnittstellenparameter
31 uint32_t baudrate;
32 uint16_t parityMode;
33 uint16_t stopBits;
34 uint16_t slave_adress;
35 uint16_t ibn_day;
36 uint16_t ibn_month;
37 uint16_t ibn_year;
38 uint16_t user_id;
39
40 // Offset und Gain
41 int16_t batteryCurrentOffsetRefTemperatureShunt;
42 int16_t batteryCurrentOffsetRefTemperatureChip;
43 int16_t batteryCurrentGainRefTempShunt;
44 int16_t batteryCurrentGainRefTempChip;
45 int16_t batteryCurrentOffsetTemperatureCalibrationTemperature;
46 int16_t batteryCurrentGainTemperatureCalibrationShuntTemperature;
47 int16_t batteryCurrentGainTemperatureCalibrationChipTemperature;
48 int32_t batteryCurrentOffsetRefshuntVoltage;
49 int32_t batteryCurrentOffsetCommonModeCalibrationVoltage;
50 int32_t batteryCurrentOffsetCommonModeCompensationFactor;
51 int32_t batteryCurrentOffsetTemperatureCompensationFactor;
52 int32_t batteryCurrentGainRefCurrent;
53 int32_t batteryCurrentGainTemperatureCompensationShuntFactor;
54 int32_t batteryCurrentGainTemperatureCompensationChipFactor;
55
56 int32_t currentOffset;
57 uint32_t currentGain;
58
59 int64_t mAsCounter;
60 int32_t detectedCapacity;
61 int32_t detectedEnergy;
62 int64_t mAs_AutoMode; // 160-163 Helps to restore current SoC after Reset or Shutdown
63 int64_t mWs_AutoMode; // 164-167 Helps to restore current SoC after Reset or Shutdown
64
65 // battery parameter
66 uint16_t cef;
67 uint16_t peukert;
68 uint32_t cellCapacity;
69 uint32_t cellEnergy;
70 uint16_t iBatFull;
71 uint16_t tBatFull;
72 uint16_t uBatFull;
73 uint16_t uBatEmpty;
74 uint8_t socCalcMode;
75 uint16_t cellRatedDischargeTime;
76
77 // Schaltausgänge
78 uint16_t lvpStart; // Spannung ab der die LOW Voltage Protection aktiv wird in mV
79 uint16_t lvpStop; // Spannung ab der die LOW Voltage Protection wieder inaktiv wird
80 uint16_t ovpStart; // Spannung ab der die OVER Voltage Protection aktiv wird in mV
81 uint16_t ovpStop; // Spannung ab der die OVER Voltage Protection wieder inaktiv wird
82 int16_t loadCurrentLimit; // maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv
83 int16_t chargeCurrentLimit; // maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv
84 int16_t chargeStopHighTemperatureStart; // Abschalttemperatur Ladung wegen zu hoher Temperatur
85 int16_t chargeStopHighTemperatureStop; // Wiedereinschalttemperatur
86 int16_t chargeStopLowTemperatureStart; // Abschalttemperatur Ladung wegen zu niedriger Temperatur
87 int16_t chargeStopLowTemperatureStop; // Wiedereinschalttemperatur
88 int16_t dischargeStopHighTemperatureStart; // Abschalttemperatur Entladung wegen zu hoher Temperatur
89 int16_t dischargeStopHighTemperatureStop; // Wiedereinschalttemperatur
90 int16_t dischargeStopLowTemperatureStart; // Abschalttemperatur EntLadung wegen zu niedriger Temperatur
91 int16_t dischargeStopLowTemperatureStop; // Wiedereinschalttemperatur
92
93 int16_t uBatEmptyCompStartTemp; // We start calculating uBatEmpty compensations only when cell temperature is lower than this value
94 int16_t uBatEmptyCompStopTemp; // We stop calculating uBatEmpty compensations when cell temperature is lower than this value
95 uint16_t uBatEmptyCompStopVolt; // uBatEmpty Voltage at temperatures lower than lvpCompStopTemp
96
97 int16_t extraDischargeStrom_mA; // For example, current that consumes LiPro itself
98 uint32_t dischargeTotalAh;
99 uint32_t chargeTotalAh;
100 uint32_t dischargeTotalWh; // 154-155 [mAs]
101 uint32_t chargeTotalWh; // 156-157 [mAs]
102
103 uint16_t cefW;
104 uint32_t onTime;
105
106} eeprom_data_t;
107
108typedef struct
109{
110 // Schnittstellenparameter
111 uint32_t baudrate;
112 uint16_t parityMode;
113 uint16_t stopBits;
114 uint16_t slave_adress;
115 uint16_t ibn_day;
116 uint16_t ibn_month;
117 uint16_t ibn_year;
118 uint16_t user_id;
119
120 // Offset und Gain
121 int16_t batteryCurrentOffsetRefTemperatureShunt;
122 int16_t batteryCurrentOffsetRefTemperatureChip;
123 int16_t batteryCurrentGainRefTempShunt;
124 int16_t batteryCurrentGainRefTempChip;
125 int16_t batteryCurrentOffsetTemperatureCalibrationTemperature;
126 int16_t batteryCurrentGainTemperatureCalibrationShuntTemperature;
127 int16_t batteryCurrentGainTemperatureCalibrationChipTemperature;
128 int32_t batteryCurrentOffsetRefshuntVoltage;
129 int32_t batteryCurrentOffsetCommonModeCalibrationVoltage;
130 int32_t batteryCurrentOffsetCommonModeCompensationFactor;
131 int32_t batteryCurrentOffsetTemperatureCompensationFactor;
132 int32_t batteryCurrentGainRefCurrent;
133 int32_t batteryCurrentGainTemperatureCompensationShuntFactor;
134 int32_t batteryCurrentGainTemperatureCompensationChipFactor;
135
136 int32_t currentOffset;
137 uint32_t currentGain;
138
139 int64_t mAsCounter;
140 int32_t detectedCapacity;
141 int32_t detectedEnergy;
142 int32_t mAh_AutoMode;
143 int32_t mWh_AutoMode;
144
145 // battery parameter
146 uint16_t cef;
147 uint16_t peukert;
148 uint32_t cellCapacity;
149 uint32_t cellEnergy;
150 uint16_t iBatFull;
151 uint16_t tBatFull;
152 uint16_t uBatFull;
153 uint16_t uBatEmpty;
154 uint8_t socCalcMode;
155 uint16_t cellRatedDischargeTime;
156
157 // Schaltausgänge
158 uint16_t lvpStart; // Spannung ab der die LOW Voltage Protection aktiv wird in mV
159 uint16_t lvpStop; // Spannung ab der die LOW Voltage Protection wieder inaktiv wird
160 uint16_t ovpStart; // Spannung ab der die OVER Voltage Protection aktiv wird in mV
161 uint16_t ovpStop; // Spannung ab der die OVER Voltage Protection wieder inaktiv wird
162 int16_t loadCurrentLimit; // maximaler Laststrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv
163 int16_t chargeCurrentLimit; // maximaler Ladestrom in A wenn der Strom größer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv
164 int16_t chargeStopHighTemperatureStart; // Abschalttemperatur Ladung wegen zu hoher Temperatur
165 int16_t chargeStopHighTemperatureStop; // Wiedereinschalttemperatur
166 int16_t chargeStopLowTemperatureStart; // Abschalttemperatur Ladung wegen zu niedriger Temperatur
167 int16_t chargeStopLowTemperatureStop; // Wiedereinschalttemperatur
168 int16_t dischargeStopHighTemperatureStart; // Abschalttemperatur Entladung wegen zu hoher Temperatur
169 int16_t dischargeStopHighTemperatureStop; // Wiedereinschalttemperatur
170 int16_t dischargeStopLowTemperatureStart; // Abschalttemperatur EntLadung wegen zu niedriger Temperatur
171 int16_t dischargeStopLowTemperatureStop; // Wiedereinschalttemperatur
172
173 int16_t uBatEmptyCompStartTemp; // We start calculating uBatEmpty compensations only when cell temperature is lower than this value
174 int16_t uBatEmptyCompStopTemp; // We stop calculating uBatEmpty compensations when cell temperature is lower than this value
175 uint16_t uBatEmptyCompStopVolt; // uBatEmpty Voltage at temperatures lower than lvpCompStopTemp
176
177 int16_t extraDischargeStrom_mA; // For example, current that consumes LiPro itself
178 uint32_t dischargeTotalAh;
179 uint32_t chargeTotalAh;
180 uint32_t dischargeTotalWh; // 154-155 [mAs]
181 uint32_t chargeTotalWh; // 156-157 [mAs]
182
183 uint16_t cefW;
184 uint32_t onTime;
185
186}eeprom_old_data_t;
187
188// Substitute for #if sizeof(some_type) == sizeof(another_type) functionality
189#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
190
191typedef struct
192{
193 // Geräteinformation
194 uint32_t SN;
195 uint8_t deviceInfoWritten;
196 uint8_t UNIQUE_NAME(reserved)[3];
197}device_info_t;
198
199typedef struct
200{
201 // Eeprom Status Infos
202 uint8_t firstStartId;
203 uint8_t UNIQUE_NAME(reserved)[3];
204 uint16_t structureSize;
205 uint16_t revisionInfo;
206 uint32_t writeCounter;
207}eeprom_state_t;
208
209// fasse zu einer Struktur zusammen um nachher einfach darauf zugreifen zu können
210typedef struct
211{
212 eeprom_state_t eepromState;
213 device_info_t deviceInfo;
214 eeprom_data_t changedData;
215}eeprom_stored_data_t;
216
217
218
219
220
221// Data to store reated defines
222//#define SIZEOF_DEFAULT_EEPROM_DATA (sizeof(eeprom_new_data_t))
223#define SIZEOF_CHANGED_EEPROM_DATA (sizeof(eeprom_data_t))
224#define SIZEOF_DEVICE_INFO (sizeof(device_info_t))
225#define SIZEOF_EEPROM_STATE (sizeof(eeprom_state_t))
226
227#define SIZE_OF_DATA_TO_STORE (SIZEOF_CHANGED_EEPROM_DATA + SIZEOF_DEVICE_INFO + SIZEOF_EEPROM_STATE)
228
229
230// Adress related defines
231#define EEPROM_ADRESS_FIRST_START_ID (0)
232#define FIRST_START_ID (0xFF)
233#define CONFIG_ID (01) // Increment by 1 to make compartible update, more than 1 - incompartible
234#if CONFIG_ID == FIRST_START_ID
235#error "CONFIG_ID must not be equal to FIRST_START_ID!!! Calibration data will be erased!!!"
236#endif
237
238
239
240static uint32_t GetPage(uint32_t Address);
241static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len);
242
243void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size);
244void EEPROM_Write (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size);
245
246
247
248
249// muss modulo 8 noch hinzufügen wg 8 byte alignement
250static uint64_t eepromData[(SIZE_OF_DATA_TO_STORE / 8) + 1];
251
252
253static FLASH_EraseInitTypeDef EraseInitStruct = {0};
254
255static const eeprom_data_t defaultEepromData =
256{
257 // Schnittstellenparameter
258
259 /* baudrate */ 19200, // uint32_t baudrate;
260 /* parityMode */ 0, // uint16_t parityMode;
261 /* stopBits */ 1, // uint16_t stopBits;
262 /* slave_adress */ 1, // uint16_t slave_adress;
263 /* ibn_day */ 0, // ibm_day
264 /* ibn_month */ 0, // ibm_month
265 /* ibn_year */ 0, // ibm_year
266 /* user_id */ 0, // user id
267
268 // Offset und Gain
269
270 /* batteryCurrentOffsetRefTemperatureShunt */ 0, // int16_t batteryCurrentOffsetRefTemperatureShunt;
271 /* batteryCurrentOffsetRefTemperatureChip */ 0, // int16_t batteryCurrentOffsetRefTemperatureChip
272 /* batteryCurrentGainRefTempShunt */ 0, // int16_t batteryCurrentGainRefTempShunt;
273 /* batteryCurrentGainRefTempChip */ 0, // int16_t batteryCurrentGainRefTempShip
274 /* batteryCurrentOffsetTemperatureCalibrationTemperature */ 0, // int16_t batteryCurrentOffsetTemperatureCalibrationTemperature;
275 /* batteryCurrentGainTemperatureCalibrationShuntTemperature */ 0, // int16_t batteryCurrentGainTemperatureCalibrationShuntTemperature;
276 /* batteryCurrentGainTemperatureCalibrationChipTemperature */ 0, // int16_t batteryCurrentGainTemperatureCalibrationChipTemperature;
277 /* batteryCurrentOffsetRefshuntVoltage */ 0, // int32_t batteryCurrentOffsetRefshuntVoltage;
278 /* batteryCurrentOffsetCommonModeCalibrationVoltage */ 0, // int32_t batteryCurrentOffsetCommonModeCalibrationVoltage;
279 /* batteryCurrentOffsetTemperatureCompensationFactor */ 0, // int32_t batteryCurrentOffsetTemperatureCompensationFactor;
280 /* batteryCurrentOffsetCommonModeCompensationFactor */ 0, // int32_t batteryCurrentOffsetCommonModeCompensationFactor;
281 /* batteryCurrentGainRefCurrent */ 250000, // int32_t batteryCurrentGainRefCurrent;
282 /* batteryCurrentGainTemperatureCompensationShuntFactor */ 0, // int32_t batteryCurrentGainTemperatureCompensationShuntFactor;
283 /* batteryCurrentGainTemperatureCompensationChipFactor */ 0, // int32_t batteryCurrentGainTemperatureCompensationChipFactor;
284
285 /* currentOffset */ 0, //int32_t currentOffset;
286 /* currentGain */ 1000000, //uint32_t currentGain;
287
288 /* mAsCounter */ 0, // mAsCounter
289 /* detectedCapacity */ -1, // detectedCapacity
290 /* detectedEnergy */ -1, // detectedEnergy
291 /* mAs_AutoMode */ (-100000LL*3600LL), // mAs_AutoMode = cellCapacity*3600,
292 /* mWs_AutoMode */ (-2640000LL*3600LL),// mWs_AutoMode = cellEnergy*3600,
293
294 // battery parameter
295
296 /* cef */ 99, // cef
297 /* peukert */ 105, // peukert
298 /* cellCapacity */ 100000, // cell Capacity in mAh
299 /* cellEnergy */ 2640000, // cell energy in mWh
300 /* iBatFull */ 10, // I-batt full 4% 4A bei 100Ah akku
301 /* tBatFull */ 2, // t-batt full 2 Sekunden
302 /* uBatFull */ 14000, // 14Volt Ubatt full
303 /* uBatEmpty */ 12500, // 11,312V Ubatt Empty
304 /* socCalcMode */ 1, // SoC calculation mode: 0(default)
305 /* 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
306
307 /* lvpStart */ 12000, // uint16_t lvpStart; Spannung ab der die LOW Voltage Protection aktiv wird in mV
308 /* lvpStop */ 12500, // uint16_t lvpStop; Spannung ab der die LOW Voltage Protection wieder inaktiv wird
309 /* ovpStart */ 15000, // uint16_t ovpStart; Spannung ab der die OVER Voltage Protection aktiv wird in mV
310 /* ovpStop */ 14000, // uint16_t ovpStop; Spannung ab der die OVER Voltage Protection wieder inaktiv wird
311
312#if (DEVICETYPE == 500)
313 /* 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
314 /* 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
315#elif (DEVICETYPE == 250)
316 /* 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
317 /* 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
318#elif (DEVICETYPE == 125)
319 /* 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
320 /* 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
321#else
322#error No valid device type
323#endif
324 /* chargeStopHighTemperatureStart */ 7500, // 80°C int16_t chargeStopHighTemperatureStart; Abschalttemperatur Ladung wegen zu hoher Temperatur
325 /* chargeStopHighTemperatureStop */ 7000, // 75°C int16_t chargeStopHighTemperatureStop; Wiedereinschalttemperatur
326 /* chargeStopLowTemperatureStart */ -3500, // -35°C int16_t chargeStopLowTemperatureStart; Abschalttemperatur Ladung wegen zu niedriger Temperatur
327 /* chargeStopLowTemperatureStop */ -3000, // -30°C int16_t chargeStopLowTemperatureStop; Wiedereinschalttemperatur
328 /* dischargeStopHighTemperatureStart*/ 7500, // 80°C int16_t dischargeStopHighTemperatureStart; Abschalttemperatur Entladung wegen zu hoher Temperatur
329 /* dischargeStopHighTemperatureStop */ 7000, // 75°C int16_t dischargeStopHighTemperatureStop; Wiedereinschalttemperatur
330 /* dischargeStopLowTemperatureStart */ -3500, // -35°C int16_t dischargeStopLowTemperatureStart; Abschalttemperatur EntLadung wegen zu niedriger Temperatur
331 /* dischargeStopLowTemperatureStop */ -3000, // -30°C int16_t dischargeStopLowTemperatureStop; Wiedereinschalttemperatur
332
333 /* uBatEmptyCompStartTemp */ 50, // 5°C We start calculating uBatEmpty compensations only when cell temperature is lower than this value
334 /* uBatEmptyCompStopTemp */ -200, // -20°C We stop calculating uBatEmpty compensations when cell temperature is lower than this value
335 /* uBatEmptyCompStopVolt */ 10000, // 10V uBatEmpty voltage at temperatures lower than -20°C
336
337 /* extraDischargeStrom_mA */ 7, // mA, current that LiPro consumes itself
338 /* dischargeTotalAh */ 0, // Ah for negative current counter
339 /* chargeTotalAh */ 0, // Ah for total charge counter
340 /* dischargeTotalWh */ 0,
341 /* chargeTotalWh */ 0,
342
343 /* cefW */ 90, // 90% cef for Wh calculations
344 /* onTime */ 0
345
346};
347
348/**
349 * @brief Gets the page of a given address
350 * @param Addr: Address of the FLASH Memory
351 * @retval The page of a given address
352 */
353static uint32_t GetPage(uint32_t Addr)
354{
355 return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
356}
357
358
359startType_t EEPROM_isFirstStart(void)
360{
361 // sizeof eeprom_new_data_t must not be equal to size of eeprom_old_data_t
362 BUILD_BUG_ON(sizeof(eeprom_data_t) == sizeof(eeprom_old_data_t));
363
364 uint8_t firstStartCatcher;
365
366 EEPROM_Read(0,EEPROM_ADRESS_FIRST_START_ID, &firstStartCatcher, 1);
367
368
369 if (firstStartCatcher == FIRST_START_ID)
370 {
371 printf ("First start detected!\n");
372 return FIRST_START_AFTER_ERASE;
373 }
374 else if (firstStartCatcher == CONFIG_ID)
375 {
376 printf ("Normal start without EEPROM changes detected\n");
377 return FIRST_START_AFTER_COMPARTIBLE_UPDATE;
378 }
379 else if (firstStartCatcher == CONFIG_ID - 1)
380 {
381 printf ("EEPROM was changed! We need to preserve calibration and settings data!\n");
382 return FIRST_START_AFTER_INCOMPARTIBLE_UPDATE;
383 }
384 else return FIRST_START_ERROR;
385}
386
387//------------------------------------------------------------------------------
388
389HAL_StatusTypeDef EEPROM_fullRestore(sys_data_t* data)
390{
391 eeprom_stored_data_t* dataToStore;
392 uint32_t PageError;
393 uint32_t Address;
394 uint32_t x;
395
396 printf("EEPROM FULL RESTORE!\n");
397
398 /**************** LESE_DEFAULT_WERTE ************************/
399
400 dataToStore = (eeprom_stored_data_t*) eepromData;
401
402 // Schnittstellenparameter
403 dataToStore->changedData.baudrate = defaultEepromData.baudrate;
404 dataToStore->changedData.parityMode = defaultEepromData.parityMode;
405 dataToStore->changedData.stopBits = defaultEepromData.stopBits;
406 dataToStore->changedData.slave_adress = defaultEepromData.slave_adress;
407
408 // Offset und Gain
409 dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = defaultEepromData.batteryCurrentOffsetRefTemperatureShunt;
410 dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = defaultEepromData.batteryCurrentOffsetRefTemperatureChip;
411 dataToStore->changedData.batteryCurrentGainRefTempShunt = defaultEepromData.batteryCurrentGainRefTempShunt;
412 dataToStore->changedData.batteryCurrentGainRefTempChip = defaultEepromData.batteryCurrentGainRefTempChip;
413 dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = defaultEepromData.batteryCurrentOffsetTemperatureCalibrationTemperature;
414 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = defaultEepromData.batteryCurrentGainTemperatureCalibrationShuntTemperature;
415 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = defaultEepromData.batteryCurrentGainTemperatureCalibrationChipTemperature;
416 dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = defaultEepromData.batteryCurrentOffsetRefshuntVoltage;
417 dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = defaultEepromData.batteryCurrentOffsetCommonModeCalibrationVoltage;
418 dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = defaultEepromData.batteryCurrentOffsetCommonModeCompensationFactor;
419 dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = defaultEepromData.batteryCurrentOffsetTemperatureCompensationFactor;
420 dataToStore->changedData.batteryCurrentGainRefCurrent = defaultEepromData.batteryCurrentGainRefCurrent;
421 dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = defaultEepromData.batteryCurrentGainTemperatureCompensationShuntFactor;
422 dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = defaultEepromData.batteryCurrentGainTemperatureCompensationChipFactor;
423
424 dataToStore->changedData.currentOffset = defaultEepromData.currentOffset;
425 dataToStore->changedData.currentGain = defaultEepromData.currentGain;
426
427 // AH Counter Parameter
428 dataToStore->changedData.cef = defaultEepromData.cef;
429 dataToStore->changedData.peukert = defaultEepromData.peukert;
430 dataToStore->changedData.cellCapacity = defaultEepromData.cellCapacity;
431 dataToStore->changedData.cellEnergy = defaultEepromData.cellEnergy;
432 dataToStore->changedData.iBatFull = defaultEepromData.iBatFull;
433 dataToStore->changedData.tBatFull = defaultEepromData.tBatFull;
434 dataToStore->changedData.uBatFull = defaultEepromData.uBatFull;
435 dataToStore->changedData.uBatEmpty = defaultEepromData.uBatEmpty;
436 dataToStore->changedData.socCalcMode = defaultEepromData.socCalcMode;
437 dataToStore->changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime;
438
439 // Schaltausgänge
440 dataToStore->changedData.lvpStart = defaultEepromData.lvpStart;
441 dataToStore->changedData.lvpStop = defaultEepromData.lvpStop;
442 dataToStore->changedData.ovpStart = defaultEepromData.ovpStart;
443 dataToStore->changedData.ovpStop = defaultEepromData.ovpStop;
444 dataToStore->changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit;
445 dataToStore->changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit;
446 dataToStore->changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart;
447 dataToStore->changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop;
448 dataToStore->changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart;
449 dataToStore->changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop;
450 dataToStore->changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart;
451 dataToStore->changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop;
452 dataToStore->changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart;
453 dataToStore->changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop;
454
455 dataToStore->changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp;
456 dataToStore->changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp;
457 dataToStore->changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt;
458
459 dataToStore->changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA;
460 dataToStore->changedData.dischargeTotalAh = defaultEepromData.dischargeTotalAh;
461 dataToStore->changedData.chargeTotalAh = defaultEepromData.chargeTotalAh;
462 dataToStore->changedData.dischargeTotalWh = defaultEepromData.dischargeTotalWh;
463 dataToStore->changedData.chargeTotalWh = defaultEepromData.chargeTotalWh;
464 dataToStore->changedData.cefW = defaultEepromData.cefW;
465 dataToStore->changedData.onTime = defaultEepromData.onTime;
466
467 dataToStore->changedData.mAsCounter = defaultEepromData.mAsCounter;
468 dataToStore->changedData.detectedCapacity = defaultEepromData.detectedCapacity;
469 dataToStore->changedData.detectedEnergy = defaultEepromData.detectedEnergy;
470 dataToStore->changedData.mAs_AutoMode = defaultEepromData.mAs_AutoMode;
471 dataToStore->changedData.mWs_AutoMode = defaultEepromData.mWs_AutoMode;
472
473 // Eeprom Status Infos
474 dataToStore->eepromState.writeCounter++;
475 dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t);
476 dataToStore->eepromState.revisionInfo = 0;
477 dataToStore->eepromState.firstStartId = CONFIG_ID;
478
479
480 /****************EEPROM Speichern********************/
481
482 EEPROM_Write(0, 0, (uint8_t*)eepromData, SIZE_OF_DATA_TO_STORE);
483
484
485
486
487
488 /**************** AUSLESEN_UND_PRÜFEN ********************/
489
490 return EEPROM_readConfig(data);
491
492
493
494}
495
496
497//Werkeinstellung ohne Kalibrierwert Überschreibung
498HAL_StatusTypeDef EEPROM_factoryRestore(sys_data_t* data, int resetToDefault)
499{
500 printf("EEPROM FACTORY RESTORE/UPDATE!\n");
501
502
503
504 eeprom_stored_data_t* dataToStore = (eeprom_stored_data_t*)eepromData;
505
506 EEPROM_readConfig(data); // Restoring calibration data
507
508 // Offset und Gain
509 dataToStore->changedData.currentOffset = data->s.parameter.batteryCurrentOffset;
510 dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt;
511 dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip;
512 dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage;
513 dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage;
514 dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor;
515 dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature;
516 dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor;
517 dataToStore->changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor;
518 dataToStore->changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt;
519 dataToStore->changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip;
520 dataToStore->changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent;
521 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature;
522 dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor;
523 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature;
524 dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor;
525
526 // Schnittstellenparameter
527 dataToStore->changedData.baudrate = defaultEepromData.baudrate;
528 dataToStore->changedData.parityMode = defaultEepromData.parityMode;
529 dataToStore->changedData.stopBits = defaultEepromData.stopBits;
530 dataToStore->changedData.slave_adress = defaultEepromData.slave_adress;
531 dataToStore->changedData.ibn_day = defaultEepromData.ibn_day;
532 dataToStore->changedData.ibn_month = defaultEepromData.ibn_month;
533 dataToStore->changedData.ibn_year = defaultEepromData.ibn_year;
534 dataToStore->changedData.user_id = defaultEepromData.user_id;
535
536 //Ah counter
537 dataToStore->changedData.cef = defaultEepromData.cef;
538 dataToStore->changedData.cellCapacity = defaultEepromData.cellCapacity;
539 dataToStore->changedData.cellEnergy = defaultEepromData.cellEnergy;
540 dataToStore->changedData.iBatFull = defaultEepromData.iBatFull;
541 dataToStore->changedData.peukert = defaultEepromData.peukert;
542 dataToStore->changedData.tBatFull = defaultEepromData.tBatFull;
543 dataToStore->changedData.uBatFull = defaultEepromData.uBatFull;
544 dataToStore->changedData.uBatEmpty = defaultEepromData.uBatEmpty;
545 dataToStore->changedData.socCalcMode = defaultEepromData.socCalcMode;
546 dataToStore->changedData.cellRatedDischargeTime = defaultEepromData.cellRatedDischargeTime;
547
548 // Schaltausgänge
549 dataToStore->changedData.lvpStart = defaultEepromData.lvpStart;
550 dataToStore->changedData.lvpStop = defaultEepromData.lvpStop;
551 dataToStore->changedData.ovpStart = defaultEepromData.ovpStart;
552 dataToStore->changedData.ovpStop = defaultEepromData.ovpStop;
553 dataToStore->changedData.loadCurrentLimit = defaultEepromData.loadCurrentLimit;
554 dataToStore->changedData.chargeCurrentLimit = defaultEepromData.chargeCurrentLimit;
555 dataToStore->changedData.chargeStopHighTemperatureStart = defaultEepromData.chargeStopHighTemperatureStart;
556 dataToStore->changedData.chargeStopHighTemperatureStop = defaultEepromData.chargeStopHighTemperatureStop;
557 dataToStore->changedData.chargeStopLowTemperatureStart = defaultEepromData.chargeStopLowTemperatureStart;
558 dataToStore->changedData.chargeStopLowTemperatureStop = defaultEepromData.chargeStopLowTemperatureStop;
559 dataToStore->changedData.dischargeStopHighTemperatureStart = defaultEepromData.dischargeStopHighTemperatureStart;
560 dataToStore->changedData.dischargeStopHighTemperatureStop = defaultEepromData.dischargeStopHighTemperatureStop;
561 dataToStore->changedData.dischargeStopLowTemperatureStart = defaultEepromData.dischargeStopLowTemperatureStart;
562 dataToStore->changedData.dischargeStopLowTemperatureStop = defaultEepromData.dischargeStopLowTemperatureStop;
563
564 dataToStore->changedData.uBatEmptyCompStartTemp = defaultEepromData.uBatEmptyCompStartTemp;
565 dataToStore->changedData.uBatEmptyCompStopTemp = defaultEepromData.uBatEmptyCompStopTemp;
566 dataToStore->changedData.uBatEmptyCompStopVolt = defaultEepromData.uBatEmptyCompStopVolt;
567
568 dataToStore->changedData.extraDischargeStrom_mA = defaultEepromData.extraDischargeStrom_mA;
569 dataToStore->changedData.dischargeTotalAh = defaultEepromData.dischargeTotalAh;
570 dataToStore->changedData.chargeTotalAh = defaultEepromData.chargeTotalAh;
571 dataToStore->changedData.cefW = defaultEepromData.cefW;
572 dataToStore->changedData.onTime = defaultEepromData.onTime;
573
574 // These fields are new
575 dataToStore->changedData.mAsCounter = defaultEepromData.mAsCounter;
576 dataToStore->changedData.detectedCapacity = defaultEepromData.detectedCapacity;
577 dataToStore->changedData.detectedEnergy = defaultEepromData.detectedEnergy;
578 dataToStore->changedData.mAs_AutoMode = defaultEepromData.mAs_AutoMode;
579 dataToStore->changedData.mWs_AutoMode = defaultEepromData.mWs_AutoMode;
580 dataToStore->changedData.dischargeTotalWh = defaultEepromData.dischargeTotalWh;
581 dataToStore->changedData.chargeTotalWh = defaultEepromData.chargeTotalWh;
582
583
584 dataToStore->eepromState.writeCounter = dataToStore->eepromState.writeCounter++;
585 dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t);
586 dataToStore->eepromState.revisionInfo = 0;
587 dataToStore->eepromState.firstStartId = CONFIG_ID;
588
589 dataToStore->deviceInfo.deviceInfoWritten = 1;
590 dataToStore->deviceInfo.SN = data->s.parameter.sn;
591
592 EEPROM_Write(0,0, (uint8_t*)dataToStore, SIZE_OF_DATA_TO_STORE);
593
594
595 return EEPROM_readConfig(data);
596}
597
598HAL_StatusTypeDef EEPROM_storeConfig(sys_data_t* data, uint8_t withSN)
599{
600 eeprom_stored_data_t* dataToStore;
601 uint32_t PageError;
602 uint32_t Address;
603 uint32_t x;
604 /****************LESE_WERTE_AUS_SYSDATA*********************/
605 printf("EEPROM STORE CONFIG!\n");
606 dataToStore = (eeprom_stored_data_t*) eepromData;
607
608 // Schnittstellenparameter
609 dataToStore->changedData.baudrate = data->s.parameter.baudrate;
610 dataToStore->changedData.parityMode = data->s.parameter.parityMode;
611 dataToStore->changedData.stopBits = data->s.parameter.stopBit;
612 dataToStore->changedData.slave_adress = data->s.parameter.slave_address;
613 dataToStore->changedData.ibn_day = data->s.parameter.ibn_day;
614 dataToStore->changedData.ibn_month = data->s.parameter.ibn_month;
615 dataToStore->changedData.ibn_year = data->s.parameter.ibn_year;
616 dataToStore->changedData.user_id = data->s.parameter.user_id;
617
618 // Offset und Gain
619 dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip = data->s.parameter.batteryCurrentOffsetRefTemperatureChip;
620 dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt = data->s.parameter.batteryCurrentOffsetRefTemperatureShunt;
621
622 dataToStore->changedData.batteryCurrentGainRefTempShunt = data->s.parameter.batteryCurrentGainRefTempShunt;
623 dataToStore->changedData.batteryCurrentGainRefTempChip = data->s.parameter.batteryCurrentGainRefTempChip;
624 dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature = data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature;
625 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature;
626 dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature = data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature;
627 dataToStore->changedData.batteryCurrentOffsetRefshuntVoltage = data->s.parameter.batteryCurrentOffsetRefshuntVoltage;
628
629 dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage = data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage;
630 dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor = data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor;
631 dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor = data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor;
632 dataToStore->changedData.batteryCurrentGainRefCurrent = data->s.parameter.batteryCurrentGainRefCurrent;
633 dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor;
634 dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor = data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor;
635
636 dataToStore->changedData.currentOffset = data->s.parameter.batteryCurrentOffset;
637 dataToStore->changedData.currentGain = data->s.parameter.batteryCurrentGainCorrectionFaktor;
638
639 // AH COUNTER Einstellungen
640 dataToStore->changedData.cef = data->s.parameter.cef;
641 dataToStore->changedData.peukert = data->s.parameter.peukert;
642 dataToStore->changedData.cellCapacity = data->s.parameter.cellCapacity;
643 dataToStore->changedData.cellEnergy = data->s.parameter.battEnergy;
644 dataToStore->changedData.iBatFull = data->s.parameter.iBatFull;
645 dataToStore->changedData.tBatFull = data->s.parameter.tBatFull;
646 dataToStore->changedData.uBatFull = data->s.parameter.uBatFull;
647 dataToStore->changedData.uBatEmpty = data->s.parameter.uBatEmpty;
648 dataToStore->changedData.socCalcMode = data->s.parameter.socCalcMode;
649
650 dataToStore->changedData.cellRatedDischargeTime = data->s.parameter.cellRatedDischargeTime;
651 // Schaltausgänge
652 dataToStore->changedData.lvpStart = data->s.parameter.lvpStart;
653 dataToStore->changedData.lvpStop = data->s.parameter.lvpStop;
654 dataToStore->changedData.ovpStart = data->s.parameter.ovpStart;
655 dataToStore->changedData.ovpStop = data->s.parameter.ovpStop;
656 dataToStore->changedData.loadCurrentLimit = data->s.parameter.loadCurrentLimit;
657 dataToStore->changedData.chargeCurrentLimit = data->s.parameter.chargeCurrentLimit;
658 dataToStore->changedData.chargeStopHighTemperatureStart = data->s.parameter.chargeStopHighTemperatureStart;
659 dataToStore->changedData.chargeStopHighTemperatureStop = data->s.parameter.chargeStopHighTemperatureStop;
660 dataToStore->changedData.chargeStopLowTemperatureStart = data->s.parameter.chargeStopLowTemperatureStart;
661 dataToStore->changedData.chargeStopLowTemperatureStop = data->s.parameter.chargeStopLowTemperatureStop;
662 dataToStore->changedData.dischargeStopHighTemperatureStart = data->s.parameter.dischargeStopHighTemperatureStart;
663 dataToStore->changedData.dischargeStopHighTemperatureStop = data->s.parameter.dischargeStopHighTemperatureStop;
664 dataToStore->changedData.dischargeStopLowTemperatureStart = data->s.parameter.dischargeStopLowTemperatureStart;
665 dataToStore->changedData.dischargeStopLowTemperatureStop = data->s.parameter.dischargeStopLowTemperatureStop;
666
667 // Neue Parameter für SOC
668 dataToStore->changedData.uBatEmptyCompStartTemp = data->s.parameter.uBatEmptyCompStartTemp;
669 dataToStore->changedData.uBatEmptyCompStopTemp = data->s.parameter.uBatEmptyCompStopTemp;
670 dataToStore->changedData.uBatEmptyCompStopVolt = data->s.parameter.uBatEmptyCompStopVolt;
671
672 dataToStore->changedData.extraDischargeStrom_mA = data->s.parameter.extraDischargeStrom_mA;
673 dataToStore->changedData.dischargeTotalAh = data->s.values.dischargeTotalAh;
674 dataToStore->changedData.chargeTotalAh = data->s.values.chargeTotalAh;
675 dataToStore->changedData.dischargeTotalWh = data->s.values.dischargeTotalWh;
676 dataToStore->changedData.chargeTotalWh = data->s.values.chargeTotalWh;
677 dataToStore->changedData.cefW = data->s.parameter.cefW;
678 dataToStore->changedData.onTime = data->s.values.onTime;
679
680 dataToStore->changedData.mAsCounter = data->s.values.mAsCounter;
681 dataToStore->changedData.detectedCapacity = data->s.values.detectedCapacity;
682 dataToStore->changedData.detectedEnergy = data->s.values.detectedEnergy;
683 dataToStore->changedData.mAs_AutoMode = data->s.values.mAs_AutoMode;
684 dataToStore->changedData.mWs_AutoMode = data->s.values.mWs_AutoMode;
685
686 // Eeprom Status Infos
687 dataToStore->eepromState.writeCounter++;
688 dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t);
689 dataToStore->eepromState.revisionInfo = 0;
690 dataToStore->eepromState.firstStartId = CONFIG_ID;
691
692 if (withSN)
693 {
694 printf("Writing SN!\n");
695 dataToStore->deviceInfo.SN = data->s.parameter.sn;
696 }
697
698
699 EEPROM_Write(0,0, (uint8_t*)dataToStore, SIZE_OF_DATA_TO_STORE);
700
701 return EEPROM_readConfig(data);
702}
703
704//------------------------------------------------------------------------------
705
706HAL_StatusTypeDef EEPROM_readConfig(sys_data_t* data)
707{
708 eeprom_stored_data_t* dataToStore;
709
710 /****************WERTE_AUS_EEPROM_LESEN********************/
711
712
713 EEPROM_Read(0, 0, (uint8_t*)eepromData, sizeof(eepromData));
714
715
716 dataToStore = (eeprom_stored_data_t*)eepromData;
717
718 // Schnittstellenparameter
719 data->s.parameter.baudrate = dataToStore->changedData.baudrate;
720 data->s.parameter.parityMode = dataToStore->changedData.parityMode;
721 data->s.parameter.stopBit = dataToStore->changedData.stopBits;
722 data->s.parameter.slave_address = dataToStore->changedData.slave_adress;
723 data->s.parameter.ibn_day = dataToStore->changedData.ibn_day;
724 data->s.parameter.ibn_month = dataToStore->changedData.ibn_month;
725 data->s.parameter.ibn_year = dataToStore->changedData.ibn_year;
726 data->s.parameter.user_id = dataToStore->changedData.user_id;
727
728 // Offset und Gain
729 data->s.parameter.batteryCurrentOffsetRefTemperatureShunt = dataToStore->changedData.batteryCurrentOffsetRefTemperatureShunt;
730 data->s.parameter.batteryCurrentOffsetRefTemperatureChip = dataToStore->changedData.batteryCurrentOffsetRefTemperatureChip;
731 data->s.parameter.batteryCurrentGainRefTempShunt = dataToStore->changedData.batteryCurrentGainRefTempShunt;
732 data->s.parameter.batteryCurrentGainRefTempChip = dataToStore->changedData.batteryCurrentGainRefTempChip;
733 data->s.parameter.batteryCurrentOffsetTemperatureCalibrationTemperature = dataToStore->changedData.batteryCurrentOffsetTemperatureCalibrationTemperature;
734 data->s.parameter.batteryCurrentGainTemperatureCalibrationShuntTemperature = dataToStore->changedData.batteryCurrentGainTemperatureCalibrationShuntTemperature;
735 data->s.parameter.batteryCurrentGainTemperatureCalibrationChipTemperature = dataToStore->changedData.batteryCurrentGainTemperatureCalibrationChipTemperature;
736 data->s.parameter.batteryCurrentOffsetRefshuntVoltage = dataToStore ->changedData.batteryCurrentOffsetRefshuntVoltage;
737 data->s.parameter.batteryCurrentOffsetCommonModeCalibrationVoltage = dataToStore->changedData.batteryCurrentOffsetCommonModeCalibrationVoltage;
738 data->s.parameter.batteryCurrentOffsetCommonModeCompensationFactor = dataToStore->changedData.batteryCurrentOffsetCommonModeCompensationFactor;
739 data->s.parameter.batteryCurrentOffsetTemperatureCompensationFactor = dataToStore->changedData.batteryCurrentOffsetTemperatureCompensationFactor;
740 data->s.parameter.batteryCurrentGainRefCurrent = dataToStore->changedData.batteryCurrentGainRefCurrent;
741 data->s.parameter.batteryCurrentGainTemperatureCompensationShuntFactor = dataToStore->changedData.batteryCurrentGainTemperatureCompensationShuntFactor;
742 data->s.parameter.batteryCurrentGainTemperatureCompensationChipFactor = dataToStore->changedData.batteryCurrentGainTemperatureCompensationChipFactor;
743 data->s.parameter.batteryCurrentOffset = dataToStore->changedData.currentOffset;
744 data->s.parameter.batteryCurrentGainCorrectionFaktor = dataToStore->changedData.currentGain;
745
746 //Einstellungenm für AH counter
747 data->s.parameter.cef = dataToStore ->changedData.cef;
748 data->s.parameter.peukert = dataToStore ->changedData.peukert;
749 data->s.parameter.cellCapacity = dataToStore ->changedData.cellCapacity;
750 data->s.parameter.battEnergy = dataToStore ->changedData.cellEnergy;
751 data->s.parameter.iBatFull = dataToStore ->changedData.iBatFull;
752 data->s.parameter.tBatFull = dataToStore->changedData.tBatFull;
753 data->s.parameter.uBatFull = dataToStore->changedData.uBatFull;
754 data->s.parameter.uBatEmpty = dataToStore->changedData.uBatEmpty;
755 data->s.parameter.socCalcMode = dataToStore->changedData.socCalcMode;
756 data->s.parameter.cellRatedDischargeTime = dataToStore->changedData.cellRatedDischargeTime;
757
758 // New EU directive says that cell Energy in Wh must be somwhere on the
759 // visible part of the cell as well as capacity in Ah
760
761
762 // Schaltausgänge
763 data->s.parameter.lvpStart = dataToStore->changedData.lvpStart;
764 data->s.parameter.lvpStop = dataToStore->changedData.lvpStop;
765 data->s.parameter.ovpStart = dataToStore->changedData.ovpStart;
766 data->s.parameter.ovpStop = dataToStore->changedData.ovpStop;
767 data->s.parameter.loadCurrentLimit = dataToStore->changedData.loadCurrentLimit;
768 data->s.parameter.chargeCurrentLimit = dataToStore->changedData.chargeCurrentLimit;
769 data->s.parameter.chargeStopHighTemperatureStart = dataToStore->changedData.chargeStopHighTemperatureStart;
770 data->s.parameter.chargeStopHighTemperatureStop = dataToStore->changedData.chargeStopHighTemperatureStop;
771 data->s.parameter.chargeStopLowTemperatureStart = dataToStore->changedData.chargeStopLowTemperatureStart;
772 data->s.parameter.chargeStopLowTemperatureStop = dataToStore->changedData.chargeStopLowTemperatureStop;
773 data->s.parameter.dischargeStopHighTemperatureStart = dataToStore->changedData.dischargeStopHighTemperatureStart;
774 data->s.parameter.dischargeStopHighTemperatureStop = dataToStore->changedData.dischargeStopHighTemperatureStop;
775 data->s.parameter.dischargeStopLowTemperatureStart = dataToStore->changedData.dischargeStopLowTemperatureStart;
776 data->s.parameter.dischargeStopLowTemperatureStop = dataToStore->changedData.dischargeStopLowTemperatureStop;
777
778 data->s.parameter.uBatEmptyCompStartTemp = dataToStore->changedData.uBatEmptyCompStartTemp;
779 data->s.parameter.uBatEmptyCompStopTemp = dataToStore->changedData.uBatEmptyCompStopTemp;
780 data->s.parameter.uBatEmptyCompStopVolt = dataToStore->changedData.uBatEmptyCompStopVolt;
781
782 data->s.parameter.extraDischargeStrom_mA = dataToStore->changedData.extraDischargeStrom_mA;
783 data->s.values.dischargeTotalAh = dataToStore->changedData.dischargeTotalAh;
784 data->s.values.chargeTotalAh = dataToStore->changedData.chargeTotalAh;
785 data->s.values.dischargeTotalWh = dataToStore->changedData.dischargeTotalWh;
786 data->s.values.chargeTotalWh = dataToStore->changedData.chargeTotalWh;
787 data->s.parameter.cefW = dataToStore ->changedData.cefW;
788 data->s.values.onTime = dataToStore->changedData.onTime;
789
790 data->s.values.mAsCounter = dataToStore->changedData.mAsCounter;
791 data->s.values.detectedCapacity = dataToStore->changedData.detectedCapacity;
792 data->s.values.detectedEnergy = dataToStore->changedData.detectedEnergy;
793 data->s.values.mAs_AutoMode = dataToStore->changedData.mAs_AutoMode;
794 data->s.values.mWs_AutoMode = dataToStore->changedData.mWs_AutoMode;
795
796 // Geräteinformation
797 data->s.parameter.sn = dataToStore->deviceInfo.SN;
798
799 // prüfe Eeprom Status Infos
800 //dataToStore->eepromState.writeCounter ++ ;
801 if (dataToStore->eepromState.structureSize != sizeof(eeprom_stored_data_t)) return HAL_ERROR;
802 if (dataToStore->eepromState.revisionInfo != 0) return HAL_ERROR;
803 if (dataToStore->eepromState.firstStartId != CONFIG_ID) return HAL_ERROR;
804
805 return HAL_OK;
806}
807
808//--- NEW Functions
809// function to determine the remaining bytes
810uint16_t bytestowrite (uint16_t size, uint16_t offset)
811{
812 if ((size+offset)<PAGE_SIZE) return size;
813 else return PAGE_SIZE-offset;
814}
815
816
817void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size)
818{
819 int paddrposition = log(PAGE_SIZE)/log(2);
820
821 uint16_t startPage = page;
822 uint16_t endPage = page + ((size+offset)/PAGE_SIZE);
823
824 uint16_t numofpages = (endPage-startPage) + 1;
825 uint16_t pos=0;
826
827 for (int i=0; i<numofpages; i++)
828 {
829 uint16_t MemAddress = startPage<<paddrposition | offset;
830 uint16_t bytesremaining = bytestowrite(size, offset);
831 HAL_I2C_Mem_Read(EEPROM_I2C, EEPROM_ADDR, MemAddress, 2, &data[pos], bytesremaining, 1000);
832 startPage += 1;
833 offset=0;
834 size = size-bytesremaining;
835 pos += bytesremaining;
836 }
837}
838
839
840void EEPROM_Write (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size)
841{
842
843 // Find out the number of bit, where the page addressing starts
844 int paddrposition = log(PAGE_SIZE)/log(2);
845
846 // calculate the start page and the end page
847 uint16_t startPage = page;
848 uint16_t endPage = page + ((size+offset)/PAGE_SIZE);
849
850 // number of pages to be written
851 uint16_t numofpages = (endPage-startPage) + 1;
852 uint16_t pos=0;
853
854 // write the data
855 for (int i=0; i<numofpages; i++)
856 {
857 /* calculate the address of the memory location
858 * Here we add the page address with the byte address
859 */
860 uint16_t MemAddress = startPage<<paddrposition | offset;
861 uint16_t bytesremaining = bytestowrite(size, offset); // calculate the remaining bytes to be written
862
863 HAL_I2C_Mem_Write(EEPROM_I2C, EEPROM_ADDR, MemAddress, 2, &data[pos], bytesremaining, 1000); // write the data to the EEPROM
864
865 startPage += 1; // increment the page, so that a new page address can be selected for further write
866 offset=0; // since we will be writing to a new page, so offset will be 0
867 size = size-bytesremaining; // reduce the size of the bytes
868 pos += bytesremaining; // update the position for the data buffer
869
870 HAL_Delay (5); // Write cycle delay (5ms)
871 }
872}
Note: See TracBrowser for help on using the repository browser.