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

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