Context Navigation

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

Last change on this file since 27 was 27, checked in by f.jahn, 7 weeks 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
12	extern 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
31	typedef 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
113	typedef 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
121	typedef 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
132	typedef 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
162	static uint32_t GetPage(uint32_t Address);
163	static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len);
164	void EEPROM_Read (uint16_t page, uint16_t offset, uint8_t *data, uint16_t size);
165	void 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
170	static uint8_t eepromData[SIZE_OF_DATA_TO_STORE];
171
172
173	static FLASH_EraseInitTypeDef EraseInitStruct = {0};
174
175	static 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 / (-100000LL3600LL), // mAs_AutoMode = cellCapacity*3600,
215	/* mWs_AutoMode / (-2640000LL3600LL),// 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	*/
272	static uint32_t GetPage(uint32_t Addr)
273	{
274	return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
275	}
276
277
278	startType_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
306	HAL_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
406	HAL_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
502	HAL_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
600	HAL_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
715	uint16_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
722	void 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
747	void 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.

Download in other formats: