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

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

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