Context Navigation

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

Last change on this file since 26 was 26, checked in by f.jahn, 7 weeks 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
13	extern 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
29	typedef 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
110	typedef 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
118	typedef 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
129	typedef 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
159	static uint32_t GetPage(uint32_t Address);
160	static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len);
161	void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size);
162	void 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
167	static uint8_t eepromData[SIZE_OF_DATA_TO_STORE];
168
169
170	static FLASH_EraseInitTypeDef EraseInitStruct = {0};
171
172	static 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 / (-100000LL3600LL), // mAs_AutoMode = cellCapacity*3600,
212	/* mWs_AutoMode / (-2640000LL3600LL),// 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	*/
268	static uint32_t GetPage(uint32_t Addr)
269	{
270	return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
271	}
272
273
274	startType_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
302	HAL_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
401	HAL_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
496	HAL_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
593	HAL_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
706	uint16_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
713	void 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
736	void 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.

Download in other formats: