Context Navigation

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

Last change on this file since 25 was 25, checked in by f.jahn, 7 weeks ago
RTC implementiert
File size: 42.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: