source: ecs_cellMon/firmware/src/eeprom.c @ 8

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

Fixing project before activating IWDG timer in CubeMX.
File size: 20.7 KB
RevLine 
[8]1/**
2  ******************************************************************************
3  * @file    eeprom.c
4  * @author  ECS - Zed Kazharov
5  * @version V1.0.0
6  * @date    10-Jan-2023
7  * @brief   Virtual EEPROM in FLASH memory
8  *
9  *          Beschreibung         
10  *         
11  *
12  ******************************************************************************
13  */ 
14
[3]15#include "eeprom.h"
16#include "stdio.h"
17#include "string.h"
18/********************************************************/
19
20// Eeprom state related defines
21
22/*****************EEPROM_EMULATOR************************/
23
24typedef struct
25{
26  // Schnittstellenparameter
27  uint32_t     baudrate;           
28  uint16_t     parityMode;                                 
29  uint16_t     stopBits;       
30  uint16_t     slaveAddress;
31
32  // Cell Parameter
33  uint16_t    ovpAlarm; 
34  uint16_t    lvpAlarm; 
35  uint16_t    ovpStart;
36  uint16_t    ovpStop;
37  uint16_t    lvpStart;
38  uint16_t    lvpStop;
39  uint16_t    vShutdownStart;
40  uint16_t    vShutdownStop; 
41  int16_t     otShutdownStart;
42  int16_t     otShutdownStop;
43  int16_t     utpChargeStart;
44  int16_t     utpChargeStop;       
45  int16_t     utpDischargeStart;
46  int16_t     utpDischargeStop;
47  uint16_t    lvpTime;
48  uint16_t    defaultBalVoltage;
49 
50  // tempco
51  int16_t     refTemp;
52  int16_t     ovpAlarmTempco;
53  int16_t     lvpAlarmTempco;
54  int16_t     ovpStartTempco;
55  int16_t     ovpStopTempco;
56  int16_t     lvpStartTempco;
57  int16_t     lvpStopTempco;     
58  int16_t     vShutdownStartTempco;
59  int16_t     vShutdownStopTempco; 
60  int16_t     balancerVoltageTempco;
61  uint16_t    lockKey;
62}eeprom_data_t;
63
64typedef struct 
65{
66  // Geräteinformation
67  uint32_t    SN;
68  uint8_t     deviceInfoWritten;
69  uint8_t     resv[3];
70}device_info_t;
71
72
73typedef struct
74{
75  // Eeprom Status Infos
76  uint32_t     writeCounter;
77  uint16_t     structureSize;
78  uint16_t     revisionInfo;
79   uint8_t     firstStartId;
80}eeprom_state_t;
81
82
83typedef struct
84{
85  // Eeprom Status Infos
86  uint16_t    cycleCounter;
87  uint16_t    minVoltage;
88  uint16_t    maxVoltage;
89  int16_t     minTemperature;
90  int16_t     maxTemperature;
91  uint16_t    criticalOverTempTime;
92  uint16_t    criticalUnderTempTime;
93  uint16_t    criticalOvervoltageTime;
94  uint16_t    criticalUndervoltageTime;
95
96}log_data_t;
97
98// fasse zu einer Struktur zusammen um nachher einfach darauf zugreifen zu können
99typedef struct
100{
101  eeprom_data_t changedData;
102  eeprom_state_t  eepromState;
103  device_info_t deviceInfo;
104  log_data_t logData;
105}eeprom_stored_data_t;
106
107// Flash related defines
108#define USER_FLASH_BASE_ADRESS                    FLASH_BASE
109
110#define USER_FLASH_SIZE                           FLASH_SIZE
111//#define USER_FLASH_END                            ((USER_FLASH_BASE_ADRESS + USER_FLASH_SIZE) - 1)
112#define USER_FLASH_END                            (USER_FLASH_BASE_ADRESS + USER_FLASH_SIZE)
113#define USER_FLASH_PAGE_SIZE                      (0x800)
114
115// Eeprom emulator related defines
116#define NUMBER_OF_PAGES                           (2)
117#define USER_EEPROM_BASE_ADRESS                   (USER_FLASH_END - (USER_FLASH_PAGE_SIZE * NUMBER_OF_PAGES))
118
119// Data to store reated defines
120#define SIZEOF_DEFAULT_EEPROM_DATA                (sizeof(eeprom_data_t))
121#define SIZEOF_CHANGED_EEPROM_DATA                (sizeof(eeprom_data_t))
122#define SIZEOF_DEVICE_INFO                        (sizeof(device_info_t))
123#define SIZEOF_EEPROM_STATE                       (sizeof(eeprom_state_t))
124
125#define SIZE_OF_DATA_TO_STORE                     (SIZEOF_CHANGED_EEPROM_DATA + SIZEOF_DEVICE_INFO + SIZEOF_EEPROM_STATE)
126
127// Adress related defines
128#define EEPROM_ADRESS_FIRST_START_ID              (USER_EEPROM_BASE_ADRESS - 1 + SIZE_OF_DATA_TO_STORE - 1 - SIZEOF_DEVICE_INFO - 1 - 1)
129#define FIRST_START_ID                            (1)
130
131
132static uint32_t GetPage(uint32_t Address);
133static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len);
134
135// muss modulo 8 noch hinzufügen wg 8 byte alignement
136static uint64_t eepromData[(SIZE_OF_DATA_TO_STORE / 8) + 1];
137static uint64_t eepromLogData[(sizeof(log_data_t) / 8) + 1];
138static FLASH_EraseInitTypeDef EraseInitStruct = {0};
139
140extern uint16_t savedLockKey;
141
142static const eeprom_data_t defaultEepromData =
143{
144  // Schnittstellenparameter
145  MB_BAUDRATE_DEFAULT,   
146  MB_PARITY_MODE_DEFAULT,
147  MB_STOPBIT_MODE_DEFAULT,        /*uint16_t     stopbitmode, reserviert;*/                           
148  MB_SLAVE_ADDRESS_DEFAULT,        /*uint16_t     slave_adress;*/ 
149  OVP_ALARM_VOLTAGE_DEFAULT,
150  LVP_ALARM_VOLTAGE_DEFAULT,
151  OVP_START_VOLTAGE_DEFAULT,
152  OVP_STOPP_VOLTAGE_DEFAULT,
153  LVP_START_VOLTAGE_DEFAULT,
154  LVP_STOPP_VOLTAGE_DEFAULT,
155  VOLTAGE_SHUTDOWN_START_VOLTAGE_DEFAULT,
156  VOLTAGE_SHUTDOWN_STOPP_VOLTAGE_DEFAULT,
157  OVERTEMPPROTECTION_START_DEFAULT,
158  OVERTEMPPROTECTION_STOP_DEFAULT,
159  UNDERTEMPPROTECTION_CHARGE_START_DEFAULT,
160  UNDERTEMPPROTECTION_CHARGE_STOP_DEFAULT,
161  UNDERTEMPPROTECTION_DISCHARGE_START_DEFAULT,
162  UNDERTEMPPROTECTION_DISCHARGE_STOP_DEFAULT,
163  LVP_TIME_DEFAULT,
164  BAL_VOLTAGE_DEFAULT,
165  BASIS_TEMP_DEFAULT,
166  OVP_ALARM_TEMPCO_DEFAULT,
167  LVP_ALARM_TEMPCO_DEFAULT,
168  OVP_START_TEMPCO_DEFAULT,
169  OVP_STOPP_TEMPCO_DEFAULT,
170  LVP_START_TEMPCO_DEFAULT,
171  LVP_STOPP_TEMPCO_DEFAULT,
172  V_SHUTDOWN_START_TEMPCO_DEFAULT,
173  V_SHUTDOWN_STOPP_TEMPCO_DEFAULT,
174  BAL_TEMPCO_DEFAULT,
175  0,                                  //Lockkey, Default keiner!
176};
177
178/**
179  * @brief  Gets the page of a given address
180  * @param  Addr: Address of the FLASH Memory
181  * @retval The page of a given address
182  */
183static uint32_t GetPage(uint32_t Addr)
184{
185  return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
186}
187
188static HAL_StatusTypeDef getEEPROMData(uint32_t address, uint8_t * data, uint32_t len)
189{
190    uint32_t i = 0;
191    uint8_t daten;
192    if((address + len) > USER_FLASH_END)
193    {
194      return HAL_ERROR;
195    }
196    for(i = 0; i < len; i ++)
197    {
198      data[i] = *((uint8_t *) (address + i));
199    }
200    return HAL_OK;
201}
202
203bool EEPROM_isFirstStart()
204{
205
206  uint8_t firstStartCatcher;
207  if(getEEPROMData(EEPROM_ADRESS_FIRST_START_ID, (uint8_t *)&firstStartCatcher, 1) != HAL_OK) return HAL_ERROR;
208  if(firstStartCatcher != FIRST_START_ID)
209  {
210    printf ("First start detected\n");
211    return true;
212
213  }
214  else
215  {
216    printf ("previous config present\n");
217    return false;
218  }
219}
220
221HAL_StatusTypeDef EEPROM_fullRestore(sys_data_t * data, bool keepSN)
222{
223  eeprom_stored_data_t * dataToStore;
224  uint32_t PageError;
225  uint32_t Address;
226  uint32_t x;
227
228  printf("EEPROM FULL RESTORE!\n");
229
230  /****************LESE_DEFAULT_WERTE************************/
231
232  dataToStore = (eeprom_stored_data_t *) eepromData;
233 
234  memcpy( (void *) &dataToStore->changedData, (void*) &defaultEepromData, sizeof(dataToStore->changedData)) ;
235 
236 
237  // Eeprom Status Infos
238  dataToStore->eepromState.writeCounter ++;
239  dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t);
240  dataToStore->eepromState.revisionInfo = 0;
241  dataToStore->eepromState.firstStartId = FIRST_START_ID;
242 
243  /****************PAGE_LÖSCHEN********************/   
244  HAL_FLASH_Unlock();
245   
246  // check for PG bit set if so clear bit
247  FLASH_WaitForLastOperation(1000);
248  if(READ_BIT(FLASH->CR, FLASH_CR_PG)) 
249  {
250    CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
251  }
252 
253  /* Fill EraseInit structure*/
254  //Speicherung in vorletzter page, deshalb diese löschen.
255  //Log Daten kommen in die letzte page
256  EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
257  EraseInitStruct.Page        = FLASH_PAGE_NB - 2; //GetPage(USER_EEPROM_BASE_ADRESS);
258  EraseInitStruct.NbPages     = 1;
259
260  /* erase Sektoren daten d+rfen nicht im instuction cache liegen  */
261  if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)
262  {
263    while (1)
264    {
265      // ERROR HAL_FLASH_GetError() kann info geben
266    }
267  }
268
269  /****************IM_FLASH_SPEICHERN********************/
270
271  /* programmiere uint64_t */
272  Address = USER_EEPROM_BASE_ADRESS;
273  x = 0;
274  while (Address < (USER_EEPROM_BASE_ADRESS + SIZE_OF_DATA_TO_STORE))
275  {
276    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, Address, eepromData[x]) == HAL_OK)
277    {
278      Address = Address + 8;
279      x ++;
280    }
281   else
282    {
283      /* Error occurred while writing data in Flash memory.
284         User can add here some code to deal with this error */
285      while (1)
286      {
287        // ERROR
288      }
289    }
290  }
291
292  /* Lock the Flash */
293  HAL_FLASH_Lock();
294
295  /****************AUSLESEN_UND_PRÜFEN********************/
296
297  return EEPROM_readConfig(data);
298
299
300}
301
302
303
304HAL_StatusTypeDef EEPROM_storeConfig(sys_data_t * data,bool withSN, bool saveNewKey)
305{
306  eeprom_stored_data_t * dataToStore;
307  uint32_t PageError;
308  uint32_t Address;
309  uint32_t x;
310  /****************LESE_WERTE_AUS_SYSDATA*********************/ 
311  printf("EEPROM STORE CONFIG!\n");
312  dataToStore = (eeprom_stored_data_t *) eepromData;
313 
314  // Schnittstellenparameter
315  dataToStore->changedData.baudrate = data->s.baudrate;           
316  dataToStore->changedData.parityMode = data->s.parityMode;                                     
317  dataToStore->changedData.stopBits = data->s.stopBits;
318  dataToStore->changedData.slaveAddress = data->s.slaveAddress; 
319
320    // Cell Parameter
321  dataToStore->changedData.ovpAlarm = data->s.ovpAlarm;
322  dataToStore->changedData.lvpAlarm = data->s.lvpAlarm;
323  dataToStore->changedData.ovpStart = data->s.ovpStart;
324  dataToStore->changedData.ovpStop  = data->s.ovpStop;
325  dataToStore->changedData.lvpStart = data->s.lvpStart;
326  dataToStore->changedData.lvpStop  = data->s.lvpStop;
327  dataToStore->changedData.vShutdownStart  = data->s.vShutdownStart;
328  dataToStore->changedData.vShutdownStop   = data->s.vShutdownStop;
329  dataToStore->changedData.otShutdownStart = data->s.otShutdownStart;
330  dataToStore->changedData.otShutdownStop  = data->s.otShutdownStop;
331  dataToStore->changedData.utpChargeStart  = data->s.utpChargeStart;
332  dataToStore->changedData.utpChargeStop   = data->s.utpChargeStop;
333  dataToStore->changedData.utpDischargeStart = data->s.utpDischargeStart;
334  dataToStore->changedData.utpDischargeStop  = data->s.utpDischargeStop;
335  dataToStore->changedData.lvpTime           = data->s.lvpTime;
336  dataToStore->changedData.defaultBalVoltage = data->s.defaultBalVoltage;
337
338   // tempco
339  dataToStore->changedData.refTemp = data->s.refTemp;
340  dataToStore->changedData.ovpAlarmTempco = data->s.ovpAlarmTempco;
341  dataToStore->changedData.lvpAlarmTempco = data->s.lvpAlarmTempco;
342  dataToStore->changedData.ovpStartTempco = data->s.ovpStartTempco;
343  dataToStore->changedData.ovpStopTempco  = data->s.ovpStopTempco;
344  dataToStore->changedData.lvpStartTempco = data->s.lvpStartTempco;
345  dataToStore->changedData.lvpStopTempco  = data->s.lvpStopTempco;
346  dataToStore->changedData.vShutdownStartTempco = data->s.vShutdownStartTempco;
347  dataToStore->changedData.vShutdownStopTempco = data->s.vShutdownStopTempco;
348  dataToStore->changedData.balancerVoltageTempco = data->s.balancerVoltageTempco;
349
350  if (saveNewKey)
351  {
352    dataToStore->changedData.lockKey = data->s.newLockKey;
353  }
354  else
355  {
356    dataToStore->changedData.lockKey = savedLockKey;
357  }
358 
359
360  // Eeprom Status Infos
361  dataToStore->eepromState.writeCounter ++ ;
362  dataToStore->eepromState.structureSize = sizeof(eeprom_stored_data_t);
363  dataToStore->eepromState.revisionInfo = 0;
364  dataToStore->eepromState.firstStartId = FIRST_START_ID;
365
366  if (withSN)
367  {
368    printf("Writing SN!\n");
369    dataToStore->deviceInfo.SN = data->s.deviceSn;
370  }
371
372  /****************PAGE_LÖSCHEN********************/ 
373  HAL_FLASH_Unlock();
374
375  // check for PG bit set if so clear bit
376  FLASH_WaitForLastOperation(1000);
377  if(READ_BIT(FLASH->CR, FLASH_CR_PG)) 
378  {
379    CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
380  }
381
382  /* Fill EraseInit structure*/
383  EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
384  EraseInitStruct.Page        = FLASH_PAGE_NB - 2; 
385  EraseInitStruct.NbPages     = 1;
386
387  /* erase Sektoren daten dürfen nicht im instuction cache liegen  */
388  if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)
389  {
390    while (1)
391    {
392      // ERROR HAL_FLASH_GetError() kann info geben
393    }
394  }
395
396  /****************IM_FLASH_SPEICHERN********************/
397
398  /* programmiere uint64_t */
399  Address = USER_EEPROM_BASE_ADRESS;
400  x = 0;
401  while (Address < (USER_EEPROM_BASE_ADRESS + SIZE_OF_DATA_TO_STORE))
402  {
403    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, Address, eepromData[x]) == HAL_OK)
404    {
405      Address = Address + 8;
406      x ++;
407    }
408   else
409    {
410      /* Error occurred while writing data in Flash memory.
411         User can add here some code to deal with this error */
412      while (1)
413      {
414        // ERROR
415      }
416    }
417  }
418
419  /* Lock the Flash */
420  HAL_FLASH_Lock();
421
422  /****************AUSLESEN_UND_PRÜFEN********************/
423
424  return EEPROM_readConfig(data);
425
426
427}
428
429HAL_StatusTypeDef EEPROM_storeLogData()
430{
431 
432  uint32_t PageError;
433  uint32_t Address;
434  uint32_t x;
435  log_data_t * logData;
436  /****************LESE_WERTE_AUS_SYSDATA*********************/ 
437  printf("EEPROM STORE LOG DATA!\n");
438
439  //Zeiger auf Resevierten Ram Speicher, der für das speichern der Daten zuständig ist
440  logData = (log_data_t *) eepromLogData;
441  logData->cycleCounter = sysData.s.cycleCounter;
442  logData->maxVoltage = sysData.s.maxVoltage;
443  logData->minVoltage = sysData.s.minVoltage;
444  logData->maxTemperature = sysData.s.maxTemperature;
445  logData->minTemperature = sysData.s.minTemperature;
446  logData->criticalOvervoltageTime = sysData.s.criticalOverVoltageTime;
447  logData->criticalUndervoltageTime = sysData.s.criticalUnderVoltageTime;
448  logData->criticalOverTempTime = sysData.s.criticalOverTempTime;
449  logData->criticalUnderTempTime = sysData.s.criticalUnderTempTime;
450 
451
452  /****************PAGE_LÖSCHEN********************/ 
453  HAL_FLASH_Unlock();
454
455  // check for PG bit set if so clear bit
456  FLASH_WaitForLastOperation(1000);
457  if(READ_BIT(FLASH->CR, FLASH_CR_PG)) 
458  {
459    CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
460  }
461
462  /* Fill EraseInit structure*/
463  EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
464  EraseInitStruct.Page        = FLASH_PAGE_NB - 1;  // Page löschen
465  EraseInitStruct.NbPages     = 1;
466
467  /* erase Sektoren daten dürfen nicht im instuction cache liegen  */
468  if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)
469  {
470    printf("Error while deleting log data area in flash\n");
471    return HAL_ERROR;
472  }
473
474  /****************IM_FLASH_SPEICHERN********************/
475
476  /* programmiere uint64_t */
477  uint32_t startAdress =  USER_EEPROM_BASE_ADRESS + FLASH_PAGE_SIZE;
478  Address = startAdress;
479  x = 0;
480  while (Address < (startAdress + sizeof(log_data_t)))
481  {
482    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, Address, eepromLogData[x]) == HAL_OK)
483    {
484      Address = Address + 8;
485      x ++;
486    }
487   else
488    {
489        printf("Error while saving data to flash\n");
490        return HAL_ERROR;
491    }
492  }
493
494  /* Lock the Flash */
495  HAL_FLASH_Lock();
496
497  return HAL_OK;
498}
499
500
501HAL_StatusTypeDef EEPROM_ResetLogData()
502{
503 
504  uint32_t PageError;
505  uint32_t Address;
506  uint32_t x;
507  log_data_t * logData;
508  /****************LESE_WERTE_AUS_SYSDATA*********************/ 
509  printf("EEPROM STORE LOG DATA!\n");
510
511  //Zeiger auf Resevierten Ram Speicher, der für das speichern der Daten zuständig ist
512  logData = (log_data_t *) eepromLogData;
513  logData->cycleCounter = 0;
514  logData->maxVoltage = 0;
515  logData->minVoltage = UINT16_MAX;
516  logData->maxTemperature = INT16_MIN;
517  logData->minTemperature = INT16_MAX;
518  logData->criticalOvervoltageTime = 0;
519  logData->criticalUndervoltageTime = 0;
520  logData->criticalOverTempTime = 0;
521  logData->criticalUnderTempTime = 0;
522 
523
524  /****************PAGE_LÖSCHEN********************/ 
525  HAL_FLASH_Unlock();
526
527  // check for PG bit set if so clear bit
528  FLASH_WaitForLastOperation(1000);
529  if(READ_BIT(FLASH->CR, FLASH_CR_PG)) 
530  {
531    CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
532  }
533
534  /* Fill EraseInit structure*/
535  EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
536  EraseInitStruct.Page        = FLASH_PAGE_NB - 1;  // Page löschen
537  EraseInitStruct.NbPages     = 1;
538
539  /* erase Sektoren daten dürfen nicht im instuction cache liegen  */
540  if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK)
541  {
542    printf("Error while deleting log data area in flash\n");
543    return HAL_ERROR;
544  }
545
546  /****************IM_FLASH_SPEICHERN********************/
547
548  /* programmiere uint64_t */
549  uint32_t startAdress =  USER_EEPROM_BASE_ADRESS + FLASH_PAGE_SIZE;
550  Address = startAdress;
551  x = 0;
552  while (Address < (startAdress + sizeof(log_data_t)))
553  {
554    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, Address, eepromLogData[x]) == HAL_OK)
555    {
556      Address = Address + 8;
557      x ++;
558    }
559   else
560    {
561        printf("Error while saving data to flash\n");
562        return HAL_ERROR;
563    }
564  }
565
566  /* Lock the Flash */
567  HAL_FLASH_Lock();
568
569  return HAL_OK;
570}
571
572
573
574HAL_StatusTypeDef EEPROM_readConfig(sys_data_t * data)
575{
576  eeprom_stored_data_t * dataToStore;
577
578  /****************WERTE_AUS_FLASH_LESEN********************/
579 
580 
581  if(getEEPROMData(USER_EEPROM_BASE_ADRESS, (uint8_t *)eepromData, sizeof(eepromData)) != HAL_OK) return HAL_ERROR;
582
583  dataToStore = (eeprom_stored_data_t *) eepromData;
584 
585  // Schnittstellenparameter
586  data->s.baudrate = dataToStore->changedData.baudrate;           
587  data->s.parityMode = dataToStore->changedData.parityMode;     
588  data->s.stopBits = dataToStore->changedData.stopBits;     
589  data->s.slaveAddress = dataToStore->changedData.slaveAddress; 
590
591  //   // Cell Parameter
592  data->s.ovpAlarm = dataToStore ->changedData.ovpAlarm;
593  data->s.lvpAlarm = dataToStore ->changedData.lvpAlarm;
594  data->s.ovpStart = dataToStore ->changedData.ovpStart;
595  data->s.ovpStop  = dataToStore ->changedData.ovpStop;
596  data->s.lvpStart = dataToStore ->changedData.lvpStart;
597  data->s.lvpStop  = dataToStore ->changedData.lvpStop;
598  data->s.vShutdownStart    = dataToStore->changedData.vShutdownStart;
599  data->s.vShutdownStop     = dataToStore->changedData.vShutdownStop;
600  data->s.otShutdownStart   = dataToStore->changedData.otShutdownStart;
601  data->s.otShutdownStop    = dataToStore->changedData.otShutdownStop;
602  data->s.utpChargeStart    = dataToStore->changedData.utpChargeStart;
603  data->s.utpChargeStop     = dataToStore->changedData.utpChargeStop;
604  data->s.utpDischargeStart = dataToStore->changedData.utpDischargeStart;
605  data->s.utpDischargeStop  = dataToStore->changedData.utpDischargeStop; 
606  data->s.lvpTime           = dataToStore->changedData.lvpTime;
607  data->s.defaultBalVoltage = dataToStore->changedData.defaultBalVoltage;
608
609
610  // tempco
611  data->s.refTemp = dataToStore ->changedData.refTemp;
612  data->s.ovpAlarmTempco = dataToStore ->changedData.ovpAlarmTempco;
613  data->s.lvpAlarmTempco =  dataToStore ->changedData.lvpAlarmTempco;
614  data->s.ovpStartTempco = dataToStore ->changedData.ovpStartTempco;
615  data->s.ovpStopTempco = dataToStore->changedData.ovpStopTempco;
616  data->s.lvpStartTempco = dataToStore->changedData.lvpStartTempco;
617  data->s.lvpStopTempco = dataToStore->changedData.lvpStopTempco;
618  data->s.vShutdownStartTempco = dataToStore->changedData.vShutdownStartTempco;
619  data->s.vShutdownStopTempco = dataToStore->changedData.vShutdownStopTempco;
620  data->s.balancerVoltageTempco = dataToStore->changedData.balancerVoltageTempco;
621  savedLockKey =  dataToStore->changedData.lockKey;
622  if (savedLockKey != 0) sysData.s.writeLocked = 1 ;
623  //  Geräteinformation
624  data->s.deviceSn = dataToStore->deviceInfo.SN;
625 
626
627  // prüfe Eeprom Status Infos
628  if(dataToStore->eepromState.structureSize != sizeof(eeprom_stored_data_t)) return HAL_ERROR;
629  if(dataToStore->eepromState.revisionInfo != 0) return HAL_ERROR;
630  if(dataToStore->eepromState.firstStartId != FIRST_START_ID) return HAL_ERROR;
631
632  return HAL_OK;
633}
634
635
636
637HAL_StatusTypeDef EEPROM_readLogData()
638{
639  log_data_t * logData;
640
641  /****************WERTE_AUS_FLASH_LESEN********************/
642 
643 
644  if(getEEPROMData(USER_EEPROM_BASE_ADRESS + FLASH_PAGE_SIZE, (uint8_t *)eepromLogData, sizeof(eepromLogData)) != HAL_OK) return HAL_ERROR;
645
646  logData = (log_data_t *) eepromLogData; 
647  sysData.s.cycleCounter = logData->cycleCounter;
648  sysData.s.maxVoltage = logData->maxVoltage; 
649  sysData.s.minVoltage = logData->minVoltage;
650  sysData.s.maxTemperature = logData->maxVoltage;
651  sysData.s.minTemperature = logData->minTemperature;
652  sysData.s.criticalOverVoltageTime = logData->criticalOvervoltageTime;
653  sysData.s.criticalUnderVoltageTime = logData->criticalUndervoltageTime;
654  sysData.s.criticalOverTempTime = logData->criticalOverTempTime;
655  sysData.s.criticalUnderTempTime = logData->criticalUnderTempTime; 
656
657  return HAL_OK;
658}
Note: See TracBrowser for help on using the repository browser.