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

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