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

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

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