cli 기능 추가

Project/.vscode/settings.json

@@ -10,6 +10,8 @@
         "app_log.h": "c",
         "app_i2c_master.h": "c",
         "ak9757w_def.h": "c",
-        "ak9757w.h": "c"
+        "ak9757w.h": "c",
+        "eeprom.h": "c",
+        "eeprom_address.h": "c"
     }
 }

Project/Application/app_cli.c

@@ -1,7 +1,9 @@
 #include "app_cli.h"
 #include "sw_timer.h"
 #include "app_uart.h"
+#include "ak9757w.h"
 #include <stdlib.h>
+#include "app_log.h"
 
 #define CLI_KEY_BACK              0x7F
 #define CLI_KEY_DEL               0x7E
@@ -95,6 +97,10 @@ static uint32_t uartWrite(uint8_t* pTxData, uint32_t txLen);
 
 void cliShowList(cli_args_t *args);
 void cliMemoryDump(cli_args_t *args);
+void cli_AKM_Cmd(cli_args_t *args);
+
+
+
 
 bool cliInit(void);
 void cliMain(void);
@@ -146,6 +152,7 @@ bool cliInit(void)
 
     cliAdd("help", cliShowList);
     cliAdd("md"  , cliMemoryDump);
+    cliAdd("akm" , cli_AKM_Cmd);
 
     return true;
 }
@@ -824,6 +831,114 @@ void cliMemoryDump(cli_args_t *args)
 }
 
 
+void cli_AKM_Cmd(cli_args_t *args)
+{
+    uint32_t updatetime;
+    int    argc = args->argc;
+    char **argv = args->argv;
+
+
+    if(argc < 1)
+    {
+        cliPrintf(">> AKM CMD \r\n");
+        cliPrintf(">>\t CMD List \r\n");
+        cliPrintf(">>\t Start\r\n");
+        cliPrintf(">>\t Stop\r\n");
+        cliPrintf(">>\t SP (save parameter)\r\n");
+        cliPrintf(">>\t EP (erase parameter)\r\n");
+        cliPrintf(">>\t DP (display parameter)\r\n");
+        cliPrintf(">>\t ID\r\n");
+        cliPrintf(">>\t Update millisec\r\n");
+        cliPrintf(">>\t WR reg_addr data\r\n");
+        cliPrintf(">>\t RR reg_addr read len\r\n");        
+        return;
+    }
+
+    if(argc == 1)
+    {
+        if(strcmp(argv[0], "start") == 0)
+        {
+            AK9757W_Start_Stop(true);
+        }
+        else if(strcmp(argv[0], "stop") == 0)
+        {
+            AK9757W_Start_Stop(false);
+        }
+        else if(strcmp(argv[0], "id") == 0)
+        {
+            cliPrintf("ID : %08X\r\n", AK9757W_GetID());        
+        }
+        else if(strcmp(argv[0], "sp") == 0)
+        {
+            AK9757W_SaveParameter();
+        }
+        else if(strcmp(argv[0], "ep") == 0)
+        {
+            AK9757W_DeleteParameter();
+        }
+        else if(strcmp(argv[0], "dp") == 0)
+        {
+            AK9757W_DispalyParameter();
+        }
+    }
+    else if(argc == 2)
+    {
+        if(strcmp(argv[0], "update") == 0)
+        {
+            updatetime = (int)strtoul((const char * ) argv[1], (char **)NULL, (int) 0);
+            if(updatetime < 100)
+            {
+                cliPrintf(">>\t update time error\r\n");        
+            }
+            else
+            {
+                AK9757W_UpdateTime(updatetime);
+            }
+        }
+    }
+    else if(argc == 3)
+    {
+        if(strcmp(argv[0], "rr") == 0)
+        {
+            uint32_t Addr;
+            uint32_t readSize;
+            uint8_t ReadBuff[100];
+            Addr = (int)strtoul((const char * ) argv[1], (char **)NULL, (int) 0);
+            readSize = (int)strtoul((const char * ) argv[2], (char **)NULL, (int) 0);
+
+            if((readSize == 0) || (Addr > 0xFF) || (readSize > 100))
+                return;
+
+            if(AK9757W_ReadReg(Addr, readSize, &ReadBuff[0]) == true)
+            {
+                uint8_t i;
+                cliPrintf("\r\n");
+                for(i = 0 ; i < readSize ; i++)                
+                {
+                    cliPrintf("%02X ", ReadBuff[i]);
+                    if((i % 16) == 15)
+                        cliPrintf("\r\n");
+                }
+                cliPrintf("\r\n");
+            }
+        }
+        else if(strcmp(argv[0], "wr") == 0)
+        {
+            uint32_t writeAddr;
+            uint32_t writeData;
+
+            writeAddr = (int)strtoul((const char * ) argv[1], (char **)NULL, (int) 0);
+            writeData = (int)strtoul((const char * ) argv[2], (char **)NULL, (int) 0);
+
+            if(writeAddr > 0xFF || writeData > 0xFF)
+                return;
+            
+            AK9757W_WriteReg(writeAddr, writeData);
+
+        }
+    }
+}
+
 
 
 static void uartPrintf(const char *format, ...)

Project/Application/app_i2c_master.c

@@ -17,7 +17,11 @@ bool I2C_Master_Initialization(mxc_i2c_regs_t* pI2C_Handler, i2c_speed_t Speed)
 
     pI2C_Master = pI2C_Handler;
     I2C_Shutdown(pI2C_Master);
+    
     error = I2C_Init(pI2C_Master, Speed, &sys_i2c_master_cfg);  
+	if(error != E_NO_ERROR)
+        return false;
+
     I2C_SetTimeout(pI2C_Master, 100);
 
     if(pI2C_Handler == MXC_I2C0)
@@ -40,7 +44,7 @@ bool I2C_Master_Initialization(mxc_i2c_regs_t* pI2C_Handler, i2c_speed_t Speed)
 
 static void I2C_Master_Handler(void)
 {
-    UART_Handler(pI2C_Master);
+    I2C_Handler(pI2C_Master);
 }
 
 
@@ -73,7 +77,7 @@ int32_t I2C_Master_Read(uint8_t SlaveAddress, uint8_t* pRxBuffer, uint32_t RxLen
     if(pI2C_Master == NULL)
         return E_NULL_PTR;    
         
-    if(ret = I2C_MasterRead(pI2C_Master, (SlaveAddress << 1), &pRxBuffer[0], RxLen, false) != RxLen)
+    if((ret = I2C_MasterRead(pI2C_Master, (SlaveAddress << 1), &pRxBuffer[0], RxLen, false)) != RxLen)
     {
         I2C_Master_Initialization(TEMP_I2C_INSTANCE, TEMP_I2C_SPEED);
         return E_COMM_ERR;
@@ -89,13 +93,13 @@ int32_t I2C_Master_WriteRead(uint8_t SlaveAddress, uint8_t* pWriteBuff, uint32_t
     if(pI2C_Master == NULL)
         return E_NULL_PTR;
 
-    if(ret = I2C_MasterWrite(pI2C_Master, (SlaveAddress << 1), &pWriteBuff[0], TxLen, true) != TxLen)
+    if((ret = I2C_MasterWrite(pI2C_Master, (SlaveAddress << 1), &pWriteBuff[0], TxLen, true)) != TxLen)
     {
         I2C_Master_Initialization(TEMP_I2C_INSTANCE, TEMP_I2C_SPEED);
         return E_COMM_ERR;
     }
     
-    if(ret = I2C_MasterRead(pI2C_Master, (SlaveAddress << 1), &pRxBuffer[0], RxLen, false) != RxLen)
+    if((ret = I2C_MasterRead(pI2C_Master, (SlaveAddress << 1), &pRxBuffer[0], RxLen, false)) != RxLen)
     {
         I2C_Master_Initialization(TEMP_I2C_INSTANCE, TEMP_I2C_SPEED);
         return E_COMM_ERR;

Project/Application/app_oled.c

@@ -58,6 +58,7 @@ bool Oled_Initialization(void)
     //OLED_POWER_OFF;
 
     SW_Timer_Callback_Register(SW_TIMER_RUN_CONTINUE, 1, Oled_Process);
+	return true;
 }
 
 
@@ -213,7 +214,7 @@ bool Oled_SetTemperature(uint16_t Temperature)
             oled_draw_temp = Temperature;
         }
     }
-    
+	return true;
 }
 
 

Project/Application/app_uart.c

@@ -148,6 +148,7 @@ int32_t App_Uart_Print(uint8_t* pTxBuffer)
         App_Uart_Transmit(pTxBuffer[index]);
         index++;
     }
+	return true;
 }
 
 

Project/Application/eeprom/cammsys_flash.c

@@ -0,0 +1,236 @@
+#include "board_config.h"
+#include "cammsys_flash.h"
+
+
+#define FLASH_PAGE_ADDR             0x00000000
+#define FLASH_PAGE_MAX              32
+#define FLASH_PAGE_SIZE             8192
+
+
+
+
+
+void Flash_Initialization(void)
+{
+    const sys_cfg_t sys_flash_cfg = NULL;
+	FLC_Init(&sys_flash_cfg);
+}
+
+
+/*
+APIs
+
+*/
+int flash_verify(uint32_t address, uint32_t length, uint8_t *data)
+{
+  volatile uint8_t *ptr;
+
+  for (ptr = (uint8_t *)address; ptr < (uint8_t *)(address + length); ptr++, data++) {
+    if (*ptr != *data) {
+//        printf("Verify failed at 0x%x (0x%x != 0x%x)\n", (unsigned int)ptr, (unsigned int)*ptr, (unsigned int)*data);
+        return E_UNKNOWN;
+    }
+  }
+
+  return E_NO_ERROR;
+}
+
+/******************************************************************************/
+int flash_uninit(void)
+{
+	FLC_ClearFlags(MXC_F_FLC_INTR_DONE | MXC_F_FLC_INTR_AF);
+    return  0;  // Finished without Errors
+}
+
+/******************************************************************************/
+/*
+ *  Erase complete Flash Memory
+ *    Return Value:   0 - OK,  1 - Failed
+ */
+int flash_erase_chip(void)
+{
+	return FLC_MassErase();
+}
+
+/******************************************************************************/
+/*
+ *  Erase given page address in Flash Memory
+ *    Parameter:      address:  Sector Address
+ *    Return Value:   0 - OK,  1 - Failed
+ */
+int flash_erase_page(unsigned long address)
+{
+	return FLC_PageErase(address);
+}
+
+int flash_program_page(unsigned long address, unsigned long size, unsigned char *buffer8)
+{
+	uint32_t dest_addr;
+	int i = 0;
+	uint32_t *buffer32 = (uint32_t *)buffer8;
+
+    for (dest_addr = address; dest_addr < (address + size); dest_addr += 4) {
+        // Write a word
+        if (FLC_Write32(dest_addr, buffer32[i]) != E_NO_ERROR) {
+          //  printf("Failure in writing a word.\n");
+            break;
+        }
+
+        i++;
+    }
+
+	// Verify if page is written properly
+	if (flash_verify(address, size, (uint8_t*)buffer8) != E_NO_ERROR) {
+		//printf("%ld bytes are not written properly.\n", size);
+		return -1;
+	}
+
+//	printf("* %d data succefully written to address %X, and verified.\n", size, address);
+	return 0;
+}
+
+
+
+
+int Flash_Check_Mem(uint32_t startaddr, uint32_t length, uint32_t data)
+{    
+    uint32_t *ptr;
+    for (ptr = (uint32_t *)startaddr; ptr < (uint32_t *)(startaddr + length); ptr++) 
+    {
+
+        if (*ptr != data)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool Flash_Erase(uint32_t Address, uint32_t length)
+{
+    bool ret = false;
+
+	uint32_t i;
+    int16_t  start_page_num = -1;
+    volatile  uint32_t page_count = 0;
+    uint8_t retrycount;
+    
+    
+    for (i=0; i<FLASH_PAGE_MAX; i++)
+    {
+        if (flashInPage(i, Address, length) == true)
+        {
+            if (start_page_num < 0)
+            {
+                start_page_num = i;
+            }
+            page_count++;
+        }
+    }
+    
+    if (page_count > 0)
+    {
+        int i;
+        int delayCount;
+
+        for (i = 0 ; i < page_count ; i++)
+        {
+            if(flash_erase_page(((start_page_num + i) * FLASH_PAGE_SIZE)) != E_NO_ERROR)
+            {
+                flash_uninit();
+                
+                return false;
+            }
+
+            if(Flash_Check_Mem(((start_page_num + i) * FLASH_PAGE_SIZE), FLASH_PAGE_SIZE, 0xFFFFFFFF) == false)
+            {
+                flash_uninit();
+                return false;
+            }            
+        }
+        ret = true;
+    }
+
+    return ret;    
+}
+
+
+bool flashInPage(uint16_t sector_num, uint32_t addr, uint32_t length)
+{
+    
+    bool ret = false;
+
+    uint32_t sector_start;
+    uint32_t sector_end;
+    uint32_t flash_start;
+    uint32_t flash_end;
+
+
+    sector_start = FLASH_PAGE_ADDR + (sector_num * FLASH_PAGE_SIZE);
+    sector_end   = sector_start + FLASH_PAGE_SIZE - 1;
+    flash_start  = addr;
+    flash_end    = addr + length - 1;
+
+
+    if (sector_start >= flash_start && sector_start <= flash_end)
+    {
+        ret = true;
+    }
+
+    if (sector_end >= flash_start && sector_end <= flash_end)
+    {
+        ret = true;
+    }
+
+    if (flash_start >= sector_start && flash_start <= sector_end)
+    {
+        ret = true;
+    }
+
+    if (flash_end >= sector_start && flash_end <= sector_end)
+    {
+        ret = true;
+    }
+
+    return ret;
+}
+
+bool Flash_Write(uint32_t addr, uint8_t *p_data, uint32_t length)
+{
+    
+    bool ret = true;
+
+    if (addr%4 != 0)
+    {
+        return false;
+    }
+    
+    
+    if(flash_program_page(addr, length, p_data) != E_NO_ERROR)
+    {
+        return false;
+    }
+
+    return ret;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Project/Application/eeprom/cammsys_flash.h

@@ -0,0 +1,25 @@
+/** \file cammsys_flash.h */ 
+#if !defined(CAMMSYS_FLASH_H__D6BE3B3A_5B0B_4307_A526_9F29866A6975__INCLUDED_)
+#define CAMMSYS_FLASH_H__D6BE3B3A_5B0B_4307_A526_9F29866A6975__INCLUDED_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+
+
+
+void Flash_Initialization(void);
+int flash_verify(uint32_t address, uint32_t length, uint8_t *data);
+int flash_uninit(void);
+int flash_erase_chip(void);
+int flash_erase_page(unsigned long address);
+int flash_program_page(unsigned long address, unsigned long size, unsigned char *buffer8);
+int Flash_Check_Mem(uint32_t startaddr, uint32_t length, uint32_t data);
+bool Flash_Erase(uint32_t Address, uint32_t length);
+bool flashInPage(uint16_t sector_num, uint32_t addr, uint32_t length);
+bool Flash_Write(uint32_t addr, uint8_t *p_data, uint32_t length);
+
+
+
+
+#endif

Project/Application/eeprom/eeprom.c

@@ -0,0 +1,826 @@
+/**
+******************************************************************************
+* @file    EEPROM/EEPROM_Emulation/src/eeprom.c 
+* @author  MCD Application Team
+* @brief   This file provides all the EEPROM emulation firmware functions.
+******************************************************************************
+* @attention
+*
+* <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V. 
+* All rights reserved.</center></h2>
+*
+* Redistribution and use in source and binary forms, with or without 
+* modification, are permitted, provided that the following conditions are met:
+*
+* 1. Redistribution of source code must retain the above copyright notice, 
+*    this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+* 3. Neither the name of STMicroelectronics nor the names of other 
+*    contributors to this software may be used to endorse or promote products 
+*    derived from this software without specific written permission.
+* 4. This software, including modifications and/or derivative works of this 
+*    software, must execute solely and exclusively on microcontroller or
+*    microprocessor devices manufactured by or for STMicroelectronics.
+* 5. Redistribution and use of this software other than as permitted under 
+*    this license is void and will automatically terminate your rights under 
+*    this license. 
+*
+* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" 
+* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT 
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
+* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT 
+* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+******************************************************************************
+*/
+/** @addtogroup EEPROM_Emulation
+ * @{
+ */ 
+
+/* Includes ------------------------------------------------------------------*/
+#include "board_config.h"
+#include "cammsys_flash.h"
+#include "eeprom.h"
+#include "eeprom_address.h"
+
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+
+/* Global variable used to store variable value in read sequence */
+uint16_t DataVar = 0;
+
+/* Virtual address defined by the user: 0xFFFF value is prohibited */
+
+
+/* Private function prototypes -----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+static uint32_t EE_Format(void);
+static uint32_t EE_FindValidPage(uint8_t Operation);
+static uint32_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
+static uint32_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
+static uint32_t EE_Transfer_Write_Variable(uint32_t writeaddress, uint16_t VirtAddress, uint16_t Data);
+static uint32_t EE_VerifyPageFullyErased(uint32_t Address);
+static uint32_t EE_WriteData(uint32_t address, uint32_t data);
+
+uint32_t EE_EraseAll()
+{
+    if (flash_erase_page(PAGE0_BASE_ADDRESS) != E_NO_ERROR)
+        return EE_ERROR;
+    
+    if (flash_erase_page(PAGE1_BASE_ADDRESS) != E_NO_ERROR)
+        return EE_ERROR;
+
+    return EE_OK;
+}
+
+/**
+ * @brief  Restore the pages to a known good state in case of page's status
+ *   corruption after a power loss.
+ * @param  None.
+ * @retval - Flash error code: on write Flash error
+ *         - FLASH_COMPLETE: on success
+ */
+uint32_t EE_Init(void)
+{
+    uint32_t PageStatus0 = 6, PageStatus1 = 6;
+    uint16_t VarIdx = 0;
+    uint32_t EepromStatus = 0, ReadStatus = 0;
+    int16_t x = -1;
+    uint32_t FlashStatus;
+    uint32_t SectorError = 0;
+
+    Flash_Initialization();
+
+    /* Get Page0 status */
+    PageStatus0 = (*(__IO uint32_t*)PAGE0_BASE_ADDRESS);
+    /* Get Page1 status */
+    PageStatus1 = (*(__IO uint32_t*)PAGE1_BASE_ADDRESS);
+
+    /* Check for invalid header states and repair if necessary */
+    switch (PageStatus0)
+    {
+    case ERASED:
+        if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */
+        {
+            /* Erase Page0 */
+            if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
+            {
+                if (flash_erase_page(PAGE0_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+        }
+        else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
+        {
+            /* Erase Page0 */
+            if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
+            { 
+                if (flash_erase_page(PAGE0_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+            /* Mark Page1 as valid */
+            FlashStatus = EE_WriteData(PAGE1_BASE_ADDRESS, VALID_PAGE);
+            if (FlashStatus != EE_OK)
+                return FlashStatus;
+        }
+        else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
+        {
+            /* Erase both Page0 and Page1 and set Page0 as valid page */
+            FlashStatus = EE_Format();
+            if (FlashStatus != EE_OK)
+                return FlashStatus;
+        }
+        break;
+
+    case RECEIVE_DATA:
+        if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
+        {
+            /* Transfer data from Page1 to Page0 */
+            EE_Item eeItem;
+            for (VarIdx = 0; VarIdx < EE_INDEX_MAX; VarIdx++)
+            {
+                eeItem.buf = *(__IO uint32_t*)(PAGE0_BASE_ADDRESS+4);
+                if (eeItem.index == VarIdx)
+                {
+                    x = VarIdx;
+                }
+                if (VarIdx != x)
+                {
+                    /* Read the last variables' updates */
+                    ReadStatus = EE_ReadVariable(VarIdx, &DataVar);
+                    /* In case variable corresponding to the virtual address was found */
+                    if (ReadStatus != 0x1)
+                    {
+                        /* Transfer the variable to the Page0 */
+                        EepromStatus = EE_VerifyPageFullWriteVariable(VarIdx, DataVar);
+                        /* If program operation was failed, a Flash error code is returned */
+                        if (EepromStatus != EE_OK)
+                        {
+                            return EepromStatus;
+                        }
+                    }
+                }
+            }
+            /* Mark Page0 as valid */
+            FlashStatus = EE_WriteData(PAGE0_BASE_ADDRESS, VALID_PAGE);
+            /* If program operation was failed, a Flash error code is returned */
+            if (FlashStatus != EE_OK)
+                return FlashStatus;
+            
+            /* Erase Page1 */
+            if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
+            { 
+                if (flash_erase_page(PAGE1_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+        }
+        else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
+        {
+            /* Erase Page1 */
+            if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
+            { 
+                if (flash_erase_page(PAGE1_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+            /* Mark Page0 as valid */
+            FlashStatus = EE_WriteData(PAGE0_BASE_ADDRESS, VALID_PAGE);
+            /* If program operation was failed, a Flash error code is returned */
+            if (FlashStatus != EE_OK)
+                return FlashStatus;
+        }
+        else /* Invalid state -> format eeprom */
+        {
+            /* Erase both Page0 and Page1 and set Page0 as valid page */
+            FlashStatus = EE_Format();
+            /* If erase/program operation was failed, a Flash error code is returned */
+            if (FlashStatus != EE_OK)
+            {
+                return FlashStatus;
+            }
+        }
+        break;
+
+    case VALID_PAGE:
+        if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */
+        {
+            /* Erase both Page0 and Page1 and set Page0 as valid page */
+            FlashStatus = EE_Format();
+            /* If erase/program operation was failed, a Flash error code is returned */
+            if (FlashStatus != EE_OK)
+            {
+                return FlashStatus;
+            }
+        }
+        else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
+        {
+            /* Erase Page1 */
+            if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
+            { 
+                if (flash_erase_page(PAGE1_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+        }
+        else /* Page0 valid, Page1 receive */
+        {
+            /* Transfer data from Page0 to Page1 */
+            EE_Item eeItem;
+            for (VarIdx = 0; VarIdx < EE_INDEX_MAX; VarIdx++)
+            {
+                eeItem.buf = *(__IO uint32_t*)(PAGE1_BASE_ADDRESS + 4);
+                if (eeItem.index == VarIdx)
+                {
+                    x = VarIdx;
+                }
+                if (VarIdx != x)
+                {
+                    /* Read the last variables' updates */
+                    ReadStatus = EE_ReadVariable(VarIdx, &DataVar);
+                    /* In case variable corresponding to the virtual address was found */
+                    if (ReadStatus != 0x1)
+                    {
+                        /* Transfer the variable to the Page1 */
+                        EepromStatus = EE_VerifyPageFullWriteVariable(VarIdx, DataVar);
+                        /* If program operation was failed, a Flash error code is returned */
+                        if (EepromStatus != EE_OK)
+                        {
+                            return EepromStatus;
+                        }
+                    }
+                }
+            }
+            /* Mark Page1 as valid */
+            FlashStatus = EE_WriteData(PAGE1_BASE_ADDRESS, VALID_PAGE);        
+            /* If program operation was failed, a Flash error code is returned */
+            if (FlashStatus != EE_OK)
+                return FlashStatus;
+            
+            /* Erase Page0 */
+            if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
+            { 
+                if (flash_erase_page(PAGE0_BASE_ADDRESS) != E_NO_ERROR)
+                    return EE_ERROR;
+            }
+        }
+        break;
+
+    default:  /* Any other state -> format eeprom */
+        /* Erase both Page0 and Page1 and set Page0 as valid page */
+        FlashStatus = EE_Format();
+        /* If erase/program operation was failed, a Flash error code is returned */
+        if (FlashStatus != EE_OK)
+        {
+            return FlashStatus;
+        }
+        break;
+    }
+
+    return EE_OK;
+}
+
+/**
+ * @brief  Verify if specified page is fully erased.
+ * @param  Address: page address
+ *   This parameter can be one of the following values:
+ *     @arg PAGE0_BASE_ADDRESS: Page0 base address
+ *     @arg PAGE1_BASE_ADDRESS: Page1 base address
+ * @retval page fully erased status:
+ *           - 0: if Page not erased
+ *           - 1: if Page erased
+ */
+uint32_t EE_VerifyPageFullyErased(uint32_t Address)
+{
+    uint32_t ReadStatus = 1;
+    uint32_t AddressValue = 0x5555;
+    uint32_t endAddress = 0;
+    EE_Item eeItem;
+
+    if (Address == PAGE0_BASE_ADDRESS)
+        endAddress = PAGE0_END_ADDRESS;
+    else if (Address == PAGE1_BASE_ADDRESS)
+        endAddress = PAGE1_END_ADDRESS;
+    
+    /* Check each active page address starting from end */
+    while (Address < endAddress)
+    {
+        /* Get the current location content to be compared with virtual address */
+        AddressValue = (*(__IO uint32_t*)Address);
+
+        /* Compare the read address with the virtual address */
+        if (AddressValue != ERASED)
+        {
+            /* In case variable value is read, reset ReadStatus flag */
+            ReadStatus = 0;
+
+            break;
+        }
+        /* Next address location */
+        Address = Address + 4;
+    }
+  
+    /* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */
+    return ReadStatus;
+}
+
+/**
+ * @brief  Returns the last stored variable data, if found, which correspond to
+ *   the passed virtual address
+ * @param  VirtAddress: Variable virtual address
+ * @param  Data: Global variable contains the read variable value
+ * @retval Success or error status:
+ *           - 0: if variable was found
+ *           - 1: if the variable was not found
+ *           - NO_VALID_PAGE: if no valid page was found.
+ */
+uint32_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
+{
+    uint32_t ValidPage = PAGE0;
+    uint32_t AddressValue = 0x5555, ReadStatus = 1;
+    uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
+    EE_Item eeItem;
+
+    /* Get active Page for read operation */
+    ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
+
+    /* Check if there is no valid page */
+    if (ValidPage == NO_VALID_PAGE)
+    {
+        return  NO_VALID_PAGE;
+    }
+
+    /* Get the valid Page start Address */
+    PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
+
+    /* Get the valid Page end Address */
+    Address = (uint32_t)((EEPROM_START_ADDRESS - 4) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
+
+    /* Check each active page address starting from end */
+    while (Address >= (PageStartAddress + 4))
+    {
+        /* Get the current location content to be compared with virtual address */
+        eeItem.buf = (*(__IO uint32_t*)Address);
+
+        /* Compare the read address with the virtual address */
+        if (eeItem.index == VirtAddress)
+        {
+            /* Get content of Address-2 which is variable value */
+            *Data = eeItem.data;
+
+            /* In case variable value is read, reset ReadStatus flag */
+            ReadStatus = 0;
+
+            break;
+        }
+        else
+        {
+            /* Next address location */
+            Address = Address - 4;
+        }
+    }
+
+    /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
+    return ReadStatus;
+}
+
+
+/**
+ * @brief  Writes/upadtes variable data in EEPROM.
+ * @param  VirtAddress: Variable virtual address
+ * @param  Data: 16 bit data to be written
+ * @retval Success or error status:
+ *           - FLASH_COMPLETE: on success
+ *           - PAGE_FULL: if valid page is full
+ *           - NO_VALID_PAGE: if no valid page was found
+ *           - Flash error code: on write Flash error
+ */
+uint32_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t Status = 0;
+
+    /* Write the variable virtual address and value in the EEPROM */
+    Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
+
+    /* In case the EEPROM active page is full */
+    if (Status == PAGE_FULL)
+    {
+        /* Perform Page transfer */
+        Status = EE_PageTransfer(VirtAddress, Data);
+    }
+
+    /* Return last operation status */
+    return Status;
+}
+
+/**
+ * @brief  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE
+ * @param  None
+ * @retval Status of the last operation (Flash write or erase) done during
+ *         EEPROM formating
+ */
+static uint32_t EE_Format(void)
+{
+    uint32_t FlashStatus = EE_OK;
+    uint32_t SectorError = 0;
+
+    /* Erase Page0 */
+    if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
+    {
+        if (flash_erase_page(PAGE0_BASE_ADDRESS) != E_NO_ERROR)
+            return EE_ERROR;
+    }
+    /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
+    FlashStatus = EE_WriteData(PAGE0_BASE_ADDRESS, VALID_PAGE);
+    /* If program operation was failed, a Flash error code is returned */
+    if (FlashStatus != EE_OK)
+        return FlashStatus;
+
+    /* Erase Page1 */
+    if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
+    {  
+        if (flash_erase_page(PAGE1_BASE_ADDRESS) != E_NO_ERROR)
+            return EE_ERROR;
+    }
+  
+    return EE_OK;
+}
+
+/**
+ * @brief  Find valid Page for write or read operation
+ * @param  Operation: operation to achieve on the valid page.
+ *   This parameter can be one of the following values:
+ *     @arg READ_FROM_VALID_PAGE: read operation from valid page
+ *     @arg WRITE_IN_VALID_PAGE: write operation from valid page
+ * @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case
+ *   of no valid page was found
+ */
+static uint32_t EE_FindValidPage(uint8_t Operation)
+{
+    uint32_t PageStatus0 = 6, PageStatus1 = 6;
+
+    /* Get Page0 actual status */
+    PageStatus0 = (*(__IO uint32_t*)PAGE0_BASE_ADDRESS);
+
+    /* Get Page1 actual status */
+    PageStatus1 = (*(__IO uint32_t*)PAGE1_BASE_ADDRESS);
+
+    /* Write or read operation */
+    switch (Operation)
+    {
+    case WRITE_IN_VALID_PAGE:   /* ---- Write operation ---- */
+        if (PageStatus1 == VALID_PAGE)
+        {
+            /* Page0 receiving data */
+            if (PageStatus0 == RECEIVE_DATA)
+            {
+                return PAGE0;         /* Page0 valid */
+            }
+            else
+            {
+                return PAGE1;         /* Page1 valid */
+            }
+        }
+        else if (PageStatus0 == VALID_PAGE)
+        {
+            /* Page1 receiving data */
+            if (PageStatus1 == RECEIVE_DATA)
+            {
+                return PAGE1;         /* Page1 valid */
+            }
+            else
+            {
+                return PAGE0;         /* Page0 valid */
+            }
+        }
+        else
+        {
+            return NO_VALID_PAGE;   /* No valid Page */
+        }
+
+    case READ_FROM_VALID_PAGE:  /* ---- Read operation ---- */
+        if (PageStatus0 == VALID_PAGE)
+        {
+            return PAGE0;           /* Page0 valid */
+        }
+        else if (PageStatus1 == VALID_PAGE)
+        {
+            return PAGE1;           /* Page1 valid */
+        }
+        else
+        {
+            return NO_VALID_PAGE ;  /* No valid Page */
+        }
+
+    default:
+        return PAGE0;             /* Page0 valid */
+    }
+}
+
+/**
+ * @brief  Verify if active page is full and Writes variable in EEPROM.
+ * @param  VirtAddress: 16 bit virtual address of the variable
+ * @param  Data: 16 bit data to be written as variable value
+ * @retval Success or error status:
+ *           - FLASH_COMPLETE: on success
+ *           - PAGE_FULL: if valid page is full
+ *           - NO_VALID_PAGE: if no valid page was found
+ *           - Flash error code: on write Flash error
+ */
+
+static uint32_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t FlashStatus = EE_OK;
+    uint32_t ValidPage = PAGE0;
+    uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE;
+
+    /* Get valid Page for write operation */
+    ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
+  
+    /* Check if there is no valid page */
+    if (ValidPage == NO_VALID_PAGE)
+    {
+        return  NO_VALID_PAGE;
+    }
+
+    /* Get the valid Page start Address */
+    Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE) + 4);
+
+    /* Get the valid Page end Address */
+    PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 4) + (uint32_t)((ValidPage + 1) * PAGE_SIZE));
+
+    /* Check each active page address starting from begining */
+    while (Address <= PageEndAddress)
+    {
+        /* Verify if Address and Address+2 contents are 0xFFFFFFFF */
+        if ((*(__IO uint32_t*)Address) == ERASED)
+        {
+            EE_Item eeItem;
+            eeItem.index = VirtAddress;
+            eeItem.data = Data;
+            
+            /* Set variable data */
+            FlashStatus = EE_WriteData(Address, eeItem.buf);
+            
+            return FlashStatus;
+        }
+        else
+        {
+            /* Next address location */
+            Address = Address + 4;
+        }
+    }
+
+    /* Return PAGE_FULL in case the valid page is full */    
+    return PAGE_FULL;
+}
+
+static uint32_t EE_Transfer_Write_Variable(uint32_t writeaddress, uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t FlashStatus = EE_OK;
+    uint32_t ValidPage = PAGE0;
+    uint32_t Address = writeaddress, PageEndAddress = writeaddress+PAGE_SIZE;
+
+    /* Check each active page address starting from begining */
+    while (Address <= PageEndAddress)
+    {
+        /* Verify if Address and Address+2 contents are 0xFFFFFFFF */
+        if ((*(__IO uint32_t*)Address) == ERASED)
+        {
+            EE_Item eeItem;
+            eeItem.index = VirtAddress;
+            eeItem.data = Data;
+            
+            /* Set variable data */
+            FlashStatus = EE_WriteData(Address, eeItem.buf);
+            
+            return FlashStatus;
+        }
+        else
+        {
+            /* Next address location */
+            Address = Address + 4;
+        }
+    }
+
+    /* Return PAGE_FULL in case the valid page is full */    
+    return PAGE_FULL;
+}
+
+
+/**
+ * @brief  Returns the last stored variable data, if found, which correspond to
+ *   the passed virtual address
+ * @param  VirtAddress: Variable virtual address
+ * @param  Data: Global variable contains the read variable value
+ * @retval Success or error status:
+ *           - 0: if variable was found
+ *           - 1: if the variable was not found
+ *           - NO_VALID_PAGE: if no valid page was found.
+ */
+static uint32_t EE_Transfer_ReadVariable(uint32_t OldAddress, uint16_t VirtAddress, uint16_t* Data)
+{
+    uint32_t ValidPage = PAGE0;
+    uint32_t AddressValue = 0x5555, ReadStatus = 1;
+    uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
+    EE_Item eeItem;    
+
+    /* Get the valid Page start Address */
+    PageStartAddress = OldAddress;
+
+    /* Get the valid Page end Address */
+    Address = (uint32_t)((PageStartAddress - 4) + (uint32_t)PAGE_SIZE);
+
+    /* Check each active page address starting from end */
+    while (Address >= (PageStartAddress + 4))
+    {
+        /* Get the current location content to be compared with virtual address */
+        eeItem.buf = (*(__IO uint32_t*)Address);
+
+        /* Compare the read address with the virtual address */
+        if (eeItem.index == VirtAddress)
+        {
+            /* Get content of Address-2 which is variable value */
+            *Data = eeItem.data;
+
+            /* In case variable value is read, reset ReadStatus flag */
+            ReadStatus = 0;
+
+            break;
+        }
+        else
+        {
+            /* Next address location */
+            Address = Address - 4;
+        }
+    }
+
+    /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
+    return ReadStatus;
+}
+
+
+
+
+/**
+ * @brief  Transfers last updated variables data from the full Page to
+ *   an empty one.
+ * @param  VirtAddress: 16 bit virtual address of the variable
+ * @param  Data: 16 bit data to be written as variable value
+ * @retval Success or error status:
+ *           - FLASH_COMPLETE: on success
+ *           - PAGE_FULL: if valid page is full
+ *           - NO_VALID_PAGE: if no valid page was found
+ *           - Flash error code: on write Flash error
+ */
+static uint32_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t FlashStatus = EE_OK;
+    uint32_t NewPageAddress = EEPROM_START_ADDRESS;
+    uint32_t OldPageAddress = EEPROM_START_ADDRESS;    
+    uint16_t OldPageId=0;
+    uint16_t ValidPage = PAGE0, VarIdx = 0;
+    uint32_t EepromStatus = 0, ReadStatus = 0;
+    uint32_t SectorError = 0;
+
+    /* Get active Page for read operation */
+    ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
+
+    if (ValidPage == PAGE1)       /* Page1 valid */
+    {
+        /* New page address where variable will be moved to */
+        NewPageAddress = PAGE0_BASE_ADDRESS;
+
+        /* Old page ID where variable will be taken from */
+        OldPageId = PAGE1_ID;
+        OldPageAddress = PAGE1_BASE_ADDRESS;
+    }
+    else if (ValidPage == PAGE0)  /* Page0 valid */
+    {
+        /* New page address  where variable will be moved to */
+        NewPageAddress = PAGE1_BASE_ADDRESS;
+
+        /* Old page ID where variable will be taken from */
+        OldPageId = PAGE0_ID;
+        OldPageAddress = PAGE0_BASE_ADDRESS;
+    }
+    else
+    {
+        return NO_VALID_PAGE;       /* No valid Page */
+    }
+
+    /* Set the new Page status to RECEIVE_DATA status */
+    FlashStatus = EE_WriteData(NewPageAddress, VALID_PAGE);
+    /* If program operation was failed, a Flash error code is returned */
+    if (FlashStatus != EE_OK)
+        return FlashStatus;
+  
+    /* Write the variable passed as parameter in the new active page */
+    EepromStatus = EE_Transfer_Write_Variable(NewPageAddress, VirtAddress, Data);
+    /* If program operation was failed, a Flash error code is returned */
+    if (EepromStatus != EE_OK)
+    {
+        return EepromStatus;
+    }
+
+    /* Transfer process: transfer variables from old to the new active page */
+    for (VarIdx = 0; VarIdx < EE_INDEX_MAX; VarIdx++)
+    {
+        if (VarIdx != VirtAddress)  /* Check each variable except the one passed as parameter */
+        {
+            /* Read the other last variable updates */
+            ReadStatus = EE_Transfer_ReadVariable(OldPageAddress, VarIdx, &DataVar);
+            /* In case variable corresponding to the virtual address was found */
+            if (ReadStatus != 0x1)
+            {
+                /* Transfer the variable to the new active page */
+                EepromStatus = EE_Transfer_Write_Variable(NewPageAddress, VarIdx, DataVar);
+                /* If program operation was failed, a Flash error code is returned */
+                if (EepromStatus != EE_OK)
+                {
+                    return EepromStatus;
+                }
+            }
+        }
+    }
+
+    /* Erase the old Page: Set old Page status to ERASED status */
+    if (flash_erase_page(OldPageAddress) != E_NO_ERROR)
+        return EE_ERROR;  
+    
+    /* Return last operation flash status */
+    return FlashStatus;
+
+#if 0 
+
+    /* Set the new Page status to RECEIVE_DATA status */
+    FlashStatus = EE_WriteData(NewPageAddress, RECEIVE_DATA);
+    /* If program operation was failed, a Flash error code is returned */
+    if (FlashStatus != EE_OK)
+        return FlashStatus;
+  
+    /* Write the variable passed as parameter in the new active page */
+    EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
+    /* If program operation was failed, a Flash error code is returned */
+    if (EepromStatus != EE_OK)
+    {
+        return EepromStatus;
+    }
+
+    /* Transfer process: transfer variables from old to the new active page */
+    for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++)
+    {
+        if (VirtAddVarTab[VarIdx] != VirtAddress)  /* Check each variable except the one passed as parameter */
+        {
+            /* Read the other last variable updates */
+            ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
+            /* In case variable corresponding to the virtual address was found */
+            if (ReadStatus != 0x1)
+            {
+                /* Transfer the variable to the new active page */
+                EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
+                /* If program operation was failed, a Flash error code is returned */
+                if (EepromStatus != EE_OK)
+                {
+                    return EepromStatus;
+                }
+            }
+        }
+    }
+
+    /* Erase the old Page: Set old Page status to ERASED status */
+    if (flash_erase_page(OldPageAddress) != E_NO_ERROR)
+        return EE_ERROR;
+  
+    /* Set new Page status to VALID_PAGE status */
+    FlashStatus = EE_WriteData(NewPageAddress, VALID_PAGE);
+    /* If program operation was failed, a Flash error code is returned */
+    if (FlashStatus != EE_OK)
+        return FlashStatus;
+
+    /* Return last operation flash status */
+    return FlashStatus;
+#endif    
+}
+
+/**
+ * @}
+ */
+
+
+static uint32_t EE_WriteData(uint32_t address, uint32_t data)
+{
+    return (Flash_Write(address, (uint8_t *)&data, 4) ? EE_OK : EE_ERROR);
+}
+
+
+
+/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

Project/Application/eeprom/eeprom.h

@@ -0,0 +1,125 @@
+/**
+  ******************************************************************************
+  * @file    EEPROM/EEPROM_Emulation/inc/eeprom.h 
+  * @author  MCD Application Team
+  * @brief   This file contains all the functions prototypes for the EEPROM 
+  *          emulation firmware library.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V. 
+  * All rights reserved.</center></h2>
+  *
+  * Redistribution and use in source and binary forms, with or without 
+  * modification, are permitted, provided that the following conditions are met:
+  *
+  * 1. Redistribution of source code must retain the above copyright notice, 
+  *    this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright notice,
+  *    this list of conditions and the following disclaimer in the documentation
+  *    and/or other materials provided with the distribution.
+  * 3. Neither the name of STMicroelectronics nor the names of other 
+  *    contributors to this software may be used to endorse or promote products 
+  *    derived from this software without specific written permission.
+  * 4. This software, including modifications and/or derivative works of this 
+  *    software, must execute solely and exclusively on microcontroller or
+  *    microprocessor devices manufactured by or for STMicroelectronics.
+  * 5. Redistribution and use of this software other than as permitted under 
+  *    this license is void and will automatically terminate your rights under 
+  *    this license. 
+  *
+  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" 
+  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT 
+  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
+  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT 
+  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
+  ******************************************************************************
+  */ 
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __EEPROM_H
+#define __EEPROM_H
+
+/* Includes ------------------------------------------------------------------*/
+
+/* Exported constants --------------------------------------------------------*/
+/* EEPROM emulation firmware error codes */
+#define HAL_OK     (uint32_t)0 
+#define EE_OK      (uint32_t)0
+#define EE_ERROR   (uint32_t)1
+#define EE_BUSY    (uint32_t)2
+#define EE_TIMEOUT (uint32_t)3
+
+/* Define the size of the sectors to be used */
+#define PAGE_SIZE               (uint32_t)0x2000  /* Page size = 8KByte */
+
+/* Device voltage range supposed to be [2.7V to 3.6V], the operation will 
+   be done by word  */
+#define VOLTAGE_RANGE           (uint8_t)VOLTAGE_RANGE_3
+
+/* EEPROM start address in Flash */
+#define EEPROM_START_ADDRESS  ((uint32_t)0x0003C000) /* EEPROM emulation start address:
+                                                  from sector2 : after 16KByte of used 
+                                                  Flash memory */
+
+/* Pages 0 and 1 base and end addresses */
+#define PAGE0_BASE_ADDRESS    ((uint32_t)(EEPROM_START_ADDRESS + 0x0000))
+#define PAGE0_END_ADDRESS     ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))
+#define PAGE0_ID              0
+
+#define PAGE1_BASE_ADDRESS    ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))
+#define PAGE1_END_ADDRESS     ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
+#define PAGE1_ID              1
+
+/* Used Flash pages for EEPROM emulation */
+#define PAGE0                 ((uint32_t)0x0000)
+#define PAGE1                 ((uint32_t)0x0001) /* Page nb between PAGE0_BASE_ADDRESS & PAGE1_BASE_ADDRESS*/
+
+/* No valid page define */
+#define NO_VALID_PAGE         ((uint32_t)0x00AB)
+
+/* Page status definitions */
+#define ERASED                ((uint32_t)0xFFFFFFFF)     /* Page is empty */
+#define RECEIVE_DATA          ((uint32_t)0xEEEEEEEE)     /* Page is marked to receive data */
+//#define RECEIVE_DATA          ((uint32_t)0x00000000)     /* Page is marked to receive data */
+#define VALID_PAGE            ((uint32_t)0x00000000)     /* Page containing valid data */
+
+/* Valid pages in read and write defines */
+#define READ_FROM_VALID_PAGE  ((uint8_t)0x00)
+#define WRITE_IN_VALID_PAGE   ((uint8_t)0x01)
+
+/* Page full define */
+#define PAGE_FULL             ((uint8_t)0x80)
+
+/* Variables' number */
+//#define NB_OF_VAR             ((uint8_t)0x03)
+
+typedef struct {
+    union {
+        struct {
+            uint16_t index;
+            uint16_t data;
+        };
+        uint32_t buf;
+    };
+} EE_Item;
+
+/* Exported types ------------------------------------------------------------*/
+/* Exported macro ------------------------------------------------------------*/
+/* Exported functions ------------------------------------------------------- */
+uint32_t EE_EraseAll();
+uint32_t EE_Init(void);
+uint32_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
+uint32_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
+
+#endif /* __EEPROM_H */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Project/Application/eeprom/eeprom_address.c

@@ -0,0 +1,41 @@
+#include "eeprom_address.h"
+#include "eeprom.h"
+
+
+
+
+
+
+void Eeprom_Initialization(void)
+{
+    
+    EE_Init();
+    
+}
+
+
+bool Eeprom_Get_Parameter(PARAMETER_INFO_BUFF* pParameterBuff)
+{
+    uint16_t i;
+    bool bRet = true;
+    
+    for(i = 0 ; i < EE_INDEX_MAX ; i++)
+    {
+        pParameterBuff->Parameter_Buff[i] = 0x0000;
+        EE_ReadVariable(i, &pParameterBuff->Parameter_Buff[i]);
+    }
+    return bRet;
+}
+
+bool Eeprom_Save_Parameter(PARAMETER_INFO_BUFF* pParameterBuff)
+{
+    uint16_t i;
+    bool bRet = true;
+    for(i = 0 ; i < EE_INDEX_MAX ; i++)
+    {        
+        EE_WriteVariable(i, pParameterBuff->Parameter_Buff[i]);
+    }
+
+    return bRet;
+}
+

Project/Application/eeprom/eeprom_address.h

@@ -0,0 +1,58 @@
+/** \file eeprom_address.h */ 
+#if !defined(EEPROM_ADDRESS_H__0037090D_999E_4298_A974_8283B405EB08__INCLUDED_)
+#define EEPROM_ADDRESS_H__0037090D_999E_4298_A974_8283B405EB08__INCLUDED_
+
+#include "board_config.h"
+
+
+typedef enum
+{
+    EE_INDEX_ISSAVE,
+    EE_INDEX_ID_H,
+    EE_INDEX_ID_L,
+    EE_INDEX_PA_53,
+    EE_INDEX_PA_54,
+    EE_INDEX_PA_55,
+    EE_INDEX_PA_56,
+    EE_INDEX_PA_57,
+    EE_INDEX_PA_58,
+    EE_INDEX_PA_59,
+    EE_INDEX_PA_5A,
+    EE_INDEX_PA_5B,    
+    EE_INDEX_CHECKSUM,
+    EE_INDEX_MAX,
+}EEPROM_INDEX;
+
+
+#pragma pack(push, 2)
+typedef struct _parameter_info
+{
+    uint16_t    isSaveParameter;
+    uint16_t    Parameter_ID_H;
+    uint16_t    Parameter_ID_L;
+    uint16_t    Parameter_PARA_53;
+    uint16_t    Parameter_PARA_54;
+    uint16_t    Parameter_PARA_55;
+    uint16_t    Parameter_PARA_56;
+    uint16_t    Parameter_PARA_57;
+    uint16_t    Parameter_PARA_58;
+    uint16_t    Parameter_PARA_59;
+    uint16_t    Parameter_PARA_5A;
+    uint16_t    Parameter_PARA_5B;
+    uint16_t    CheckSum;
+}PARAMETER_INFO;
+#pragma pack(pop)
+
+#pragma pack(push, 2)
+typedef union _parameter_info_buff
+{
+    PARAMETER_INFO  Parameter_Info;
+    uint16_t        Parameter_Buff[EE_INDEX_MAX];
+}PARAMETER_INFO_BUFF;
+#pragma pack(pop)
+
+void Eeprom_Initialization(void);
+bool Eeprom_Get_Parameter(PARAMETER_INFO_BUFF* pParameterBuff);
+bool Eeprom_Save_Parameter(PARAMETER_INFO_BUFF* pParameterBuff);
+
+#endif

Project/Application/main.c

@@ -15,7 +15,8 @@
 #include "app_log.h"
 #include "app_cli.h"
 #include "app_oled.h"
-
+#include "cammsys_flash.h"
+#include "eeprom.h"
 
 
 
@@ -48,6 +49,8 @@ int main(void)
     App_CLI_Initialization();
     Oled_Initialization();
 	AK9757W_Initialization();    
+    Eeprom_Initialization();
+
     
     __enable_irq();         
     App_Led_OutputSet(APP_LED_1, APP_LED_MODE_TOGGLE, 100, 900);    	

Project/Application/sensor/ak9757w.c

@@ -4,12 +4,14 @@
 #include "app_log.h"
 #include "sw_timer.h"
 #include "app_oled.h"
+#include "eeprom_address.h"
 
 
 
 #define AK9757W_CHIPID_READ_WAIT_TIME   100
 #define AK9757W_ERROR_PRINT_INTERVAL    1000
 #define AK9757W_MEASUREMENT_INTERVAL    1000
+#define AK9757W_MAGIC_KEY               0xA55A
 
 
 
@@ -17,14 +19,15 @@
 
 static AK9757W_HANDLER  AK9757W_Handler;
 static AK9757W_HANDLER* pHandler = &AK9757W_Handler; 
+static PARAMETER_INFO_BUFF  ParameterInfo;
 
 const uint8_t default_cntl_reg_data[] = {0x20, 0xFF, 0xFE, 0x4A, 0xE1, 0x00, 0x00, 0x00, 0xDF, 0xE0};
 //const uint8_t default_cntl_reg_data[] = {0x20, 0xFF, 0xFE, 0x42, 0xE1, 0x00, 0x00, 0x00, 0xDF, 0xE0};
 const uint8_t default_fcoef_reg_data[] = {0x29, 0xF3, 0x57, 0x30, 0x6B, 0xBE, 0x21, 0x61, 0x8D, 0x10, 0x8D, 0xBF, 0x01, 0x0C, 0xFE};
 const uint8_t default_gcoef_reg_data[] = {0x37, 0x7D, 0x48, 0x40, 0xF1, 0xB7, 0x33, 0x83, 0x5C, 0x20, 0x40, 0xAB, 0x12, 0x70, 0x40};
 const uint8_t default_xcoef_reg_data[] = {0x45, 0xC7, 0xA0, 0x32, 0x78, 0x42, 0x23, 0x75, 0x92, 0x16, 0xC5, 0x42, 0x08, 0x15, 0x60};
-//const uint8_t default_gir_oir_gts_ots_git_reg_data[] = {0x53, 0xE0, 0x94, 0x12, 0x00, 0x00, 0x0D, 0x14, 0x00, 0x00};
+const uint8_t default_gir_oir_gts_ots_git_reg_data[] = {0x53, 0xE0, 0x94, 0x12, 0x00, 0x00, 0x0D, 0x14, 0x00, 0x00};
-const uint8_t default_gir_oir_gts_ots_git_reg_data[] = {0x53, 0xE0, 0x1C, 0x0E, 0x00, 0x00, 0xE1, 0x2F, 0x02, 0x00};
+//const uint8_t default_gir_oir_gts_ots_git_reg_data[] = {0x53, 0xE0, 0x1C, 0x0E, 0x00, 0x00, 0xE1, 0x2F, 0x02, 0x00};
 
 
 
@@ -39,7 +42,7 @@ static bool AK9757W_Set_XCOEF4_0_Parameter(void);
 static bool AK9757W_Set_IR_TS_IT_Parameter(void);
 static bool AK9757W_Calc_Parameter(void);
 static bool AK9757W_Read_RawData(void);
-static bool AK9757W_Process(void);
+static void AK9757W_Process(void);
 static void AK9757W_Next_Step(AK9757W_STEP nextStep);
 static uint16_t AK9757W_Get_Tout(uint16_t TOUT);
 static int16_t AK9757W_14BitTo16Bit(uint16_t Data);
@@ -58,6 +61,7 @@ bool AK9757W_Initialization(void)
     AK9757W_Handler.PreStep = STEP_INIT;
     AK9757W_Handler.Step = STEP_INIT;
     AK9757W_Handler.isMeasurementStart = true;
+    AK9757W_Handler.UpdateTime_Millisec = AK9757W_MEASUREMENT_INTERVAL;
 
     SW_Timer_Callback_Register(SW_TIMER_RUN_CONTINUE, 1, AK9757W_Process);
     return true;
@@ -67,7 +71,7 @@ bool AK9757W_Initialization(void)
 
 
 
-static bool AK9757W_Process(void)
+static void AK9757W_Process(void)
 {
     switch(pHandler->Step)
     {
@@ -170,7 +174,7 @@ static bool AK9757W_Process(void)
             }
         break;
         case STEP_MEASUREMENT:
-            if((millis() - pHandler->TickCount) >= AK9757W_MEASUREMENT_INTERVAL)
+            if((millis() - pHandler->TickCount) >= pHandler->UpdateTime_Millisec)
             {
                 pHandler->TickCount = millis();
                 AK9757W_Read_RawData();
@@ -180,6 +184,7 @@ static bool AK9757W_Process(void)
 
         case STEP_WAIT_STOP:
             if(AK9757W_Set_Mode(AK9757W_MODE_STAND_BY_MODE) == false){
+                pHandler->isMeasurementStart = false;
                 AK9757W_Next_Step(STEP_ERROR);
             }
             else{                
@@ -356,7 +361,38 @@ static bool AK9757W_Set_IR_TS_IT_Parameter(void)
 {
     int error;
     uint8_t i;
-    memcpy(&pHandler->IR_TS_IT_Info.IR_TS_IT_Buff[0], &default_gir_oir_gts_ots_git_reg_data[1], (sizeof(default_gir_oir_gts_ots_git_reg_data)-1));
+
+    Eeprom_Get_Parameter(&ParameterInfo);
+    if(ParameterInfo.Parameter_Info.isSaveParameter == AK9757W_MAGIC_KEY)
+    {
+        uint16_t CheckSum = 0;
+        uint32_t readChipID;
+
+        readChipID = (uint32_t)(ParameterInfo.Parameter_Info.Parameter_ID_H << 16) | (uint32_t)ParameterInfo.Parameter_Info.Parameter_ID_L;
+
+        for(i = 0 ; i < EE_INDEX_CHECKSUM ; i++)
+        {
+            CheckSum += ParameterInfo.Parameter_Buff[i];
+        }
+
+        if(ParameterInfo.Parameter_Info.CheckSum == CheckSum && readChipID == pHandler->SensorID)
+        {            
+            for(i = 0 ; i < 9 ; i ++)
+            {
+                pHandler->IR_TS_IT_Info.IR_TS_IT_Buff[i] = ParameterInfo.Parameter_Buff[EE_INDEX_PA_53 + i];
+            }
+            dbg_printf(LOG_LEVEL_DEBUG, "Parameter write eeprom\r\n");
+        }
+        else
+        {
+            memcpy(&pHandler->IR_TS_IT_Info.IR_TS_IT_Buff[0], &default_gir_oir_gts_ots_git_reg_data[1], (sizeof(default_gir_oir_gts_ots_git_reg_data)-1));        
+        }
+    }
+    else
+    {
+        memcpy(&pHandler->IR_TS_IT_Info.IR_TS_IT_Buff[0], &default_gir_oir_gts_ots_git_reg_data[1], (sizeof(default_gir_oir_gts_ots_git_reg_data)-1));        
+    }
+    
     error = I2C_Master_Write(TEMP_I2C_ADDRESS, &default_gir_oir_gts_ots_git_reg_data[0], sizeof(default_gir_oir_gts_ots_git_reg_data));
     if(error != E_NO_ERROR)
     {
@@ -660,5 +696,147 @@ static void AK9757W_Next_Step(AK9757W_STEP nextStep)
 
 bool AK9757W_Start_Stop(bool isStartStop)
 {
+    if(isStartStop == true)
+    {
+        if(pHandler->isMeasurementStart == false)
+        {
+            pHandler->isMeasurementStart = true;
+            AK9757W_Next_Step(STEP_INIT);
+        }
+    }
+    else
+    {
+        if(pHandler->isMeasurementStart == true)
+            AK9757W_Next_Step(STEP_WAIT_STOP);
+    }
+    return true;
+}
+
+bool AK9757W_UpdateTime(uint32_t Millisec)
+{
+    if(pHandler->isMeasurementStart == true)
+        return false;    
+
+    pHandler->UpdateTime_Millisec = Millisec;
+    return true;
+}
+
+
+bool AK9757W_ReadReg(uint8_t RegAddr, uint32_t readLen, uint8_t* pReadBuff)
+{
+    int error;    
+
+    if(pHandler->isMeasurementStart == true)
+        return false;    
+
+    error = I2C_Master_WriteRead(TEMP_I2C_ADDRESS, &RegAddr, 1, &pReadBuff[0], readLen);    
+    if(error != E_NO_ERROR)
+    {        
+        return false;
+    }    
+    return true;
+}
+
+
+bool AK9757W_WriteReg(uint8_t WriteAddr, uint8_t WriteData)
+{
+    uint8_t TxBuff[2];
+    int error;
+    
+    if(pHandler->isMeasurementStart == true)
+        return false;
+
+    TxBuff[0] = WriteAddr;
+    TxBuff[1] = WriteData;
+    
+    error = I2C_Master_Write(TEMP_I2C_ADDRESS, &TxBuff[0], 2);    
+    if(error != E_NO_ERROR)
+    {        
+        return false;
+    }    
+    return true;
+}
+
+
+uint32_t AK9757W_GetID(void)
+{
+    return pHandler->SensorID;
+}
+
+bool AK9757W_SaveParameter(void)
+{
+    uint8_t i;
+    int error;
+
+    uint8_t RegAddr;
+    uint8_t RxBuff[9];
+
+    uint16_t CheckSum;
+
+    if(pHandler->isMeasurementStart == true)
+        return false;    
+    RegAddr = AK9757W_REG_PARAMETER;
+    error = I2C_Master_WriteRead(TEMP_I2C_ADDRESS, &RegAddr, 1, &RxBuff[0], 9);    
+    if(error != E_NO_ERROR)
+    {        
+        return false;
+    }    
+
+    CheckSum = 0x0000;
+
+    
+    
+
+
+    ParameterInfo.Parameter_Info.isSaveParameter = AK9757W_MAGIC_KEY;
+    ParameterInfo.Parameter_Info.Parameter_ID_H = (pHandler->SensorID >> 16) & 0xFFFF;
+    ParameterInfo.Parameter_Info.Parameter_ID_L = (pHandler->SensorID >> 0) & 0xFFFF;        
+    ParameterInfo.Parameter_Info.Parameter_PARA_53 = RxBuff[0];
+    ParameterInfo.Parameter_Info.Parameter_PARA_54 = RxBuff[1];
+    ParameterInfo.Parameter_Info.Parameter_PARA_55 = RxBuff[2];
+    ParameterInfo.Parameter_Info.Parameter_PARA_56 = RxBuff[3];
+    ParameterInfo.Parameter_Info.Parameter_PARA_57 = RxBuff[4];
+    ParameterInfo.Parameter_Info.Parameter_PARA_58 = RxBuff[5];
+    ParameterInfo.Parameter_Info.Parameter_PARA_59 = RxBuff[6];
+    ParameterInfo.Parameter_Info.Parameter_PARA_5A = RxBuff[7];
+    ParameterInfo.Parameter_Info.Parameter_PARA_5B = RxBuff[8];
+
+    for(i = 0 ; i < EE_INDEX_CHECKSUM ; i++)
+    {
+        CheckSum += ParameterInfo.Parameter_Buff[i];
+    }
+    ParameterInfo.Parameter_Info.CheckSum = CheckSum;
+
+    Eeprom_Save_Parameter(&ParameterInfo);
+    return true;
+    
+}
+
+bool AK9757W_DeleteParameter(void)
+{
+    uint8_t i;
+    for(i = 0 ; i < EE_INDEX_MAX ; i++)
+    {
+        ParameterInfo.Parameter_Buff[i] = 0x0000;
+    }
+    Eeprom_Save_Parameter(&ParameterInfo);
+}
+
+bool AK9757W_DispalyParameter(void)
+{
+    uint8_t i;
+    Eeprom_Get_Parameter(&ParameterInfo);
+    printf("MagicKey = 0x%04X\r\n", ParameterInfo.Parameter_Info.isSaveParameter);
+    printf("SensorID = 0x%04X%04X\r\n", ParameterInfo.Parameter_Info.Parameter_ID_H, ParameterInfo.Parameter_Info.Parameter_ID_L);
+
+    for(i = 0 ; i < 9 ; i++)
+    {
+        printf("Reg(%02X) = %02X\r\n", 0x53+i, ParameterInfo.Parameter_Buff[EE_INDEX_PA_53 + i]);
+    }
+    printf("CheckSum = 0x%04X\r\n", ParameterInfo.Parameter_Info.CheckSum);
+
+
+    
+        
     
 }

Project/Application/sensor/ak9757w.h

@@ -9,5 +9,12 @@
 
 bool AK9757W_Initialization(void);
 bool AK9757W_Start_Stop(bool isStartStop);
+bool AK9757W_UpdateTime(uint32_t Millisec);
+bool AK9757W_ReadReg(uint8_t RegAddr, uint32_t readLen, uint8_t* pReadBuff);
+bool AK9757W_WriteReg(uint8_t WriteAddr, uint8_t WriteData);
+bool AK9757W_SaveParameter(void);
+bool AK9757W_DeleteParameter(void);
+bool AK9757W_DispalyParameter(void);
+uint32_t AK9757W_GetID(void);
 
 #endif

Project/Application/sensor/ak9757w_def.h

@@ -412,6 +412,7 @@ typedef struct _ak9757w_handler
 
 
     bool    isMeasurementStart;
+    uint32_t UpdateTime_Millisec;
 
 
 }AK9757W_HANDLER;

Project/Compiler/AKM_Temperature_Demo.uvoptx

@@ -148,34 +148,41 @@
           <Name></Name>
         </SetRegEntry>
       </TargetDriverDllRegistry>
-      <Breakpoint/>
+      <Breakpoint>
+        <Bp>
+          <Number>0</Number>
+          <Type>0</Type>
+          <LineNumber>810</LineNumber>
+          <EnabledFlag>1</EnabledFlag>
+          <Address>8786</Address>
+          <ByteObject>0</ByteObject>
+          <HtxType>0</HtxType>
+          <ManyObjects>0</ManyObjects>
+          <SizeOfObject>0</SizeOfObject>
+          <BreakByAccess>0</BreakByAccess>
+          <BreakIfRCount>1</BreakIfRCount>
+          <Filename>..\Application\sensor\ak9757w.c</Filename>
+          <ExecCommand></ExecCommand>
+          <Expression>\\AKM_Temperature_Demo\../Application/sensor/ak9757w.c\810</Expression>
+        </Bp>
+      </Breakpoint>
       <WatchWindow1>
         <Ww>
           <count>0</count>
           <WinNumber>1</WinNumber>
-          <ItemText>RxBuff</ItemText>
+          <ItemText>ParameterInfo</ItemText>
         </Ww>
         <Ww>
           <count>1</count>
           <WinNumber>1</WinNumber>
-          <ItemText>ToutTemp,0x0A</ItemText>
+          <ItemText>RxBuff</ItemText>
-        </Ww>
-        <Ww>
-          <count>2</count>
-          <WinNumber>1</WinNumber>
-          <ItemText>pHandler</ItemText>
-        </Ww>
-        <Ww>
-          <count>3</count>
-          <WinNumber>1</WinNumber>
-          <ItemText>RetTemp,0x0A</ItemText>
         </Ww>
       </WatchWindow1>
       <MemoryWindow1>
         <Mm>
           <WinNumber>1</WinNumber>
           <SubType>0</SubType>
-          <ItemText>cacheMemLcd</ItemText>
+          <ItemText>0x3c000</ItemText>
           <AccSizeX>0</AccSizeX>
         </Mm>
       </MemoryWindow1>
@@ -233,7 +240,7 @@
 
   <Group>
     <GroupName>Application</GroupName>
-    <tvExp>1</tvExp>
+    <tvExp>0</tvExp>
     <tvExpOptDlg>0</tvExpOptDlg>
     <cbSel>0</cbSel>
     <RteFlg>0</RteFlg>
@@ -803,4 +810,48 @@
     </File>
   </Group>
 
+  <Group>
+    <GroupName>Eeprom</GroupName>
+    <tvExp>1</tvExp>
+    <tvExpOptDlg>0</tvExpOptDlg>
+    <cbSel>0</cbSel>
+    <RteFlg>0</RteFlg>
+    <File>
+      <GroupNumber>8</GroupNumber>
+      <FileNumber>44</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\Application\eeprom\cammsys_flash.c</PathWithFileName>
+      <FilenameWithoutPath>cammsys_flash.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+    <File>
+      <GroupNumber>8</GroupNumber>
+      <FileNumber>45</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\Application\eeprom\eeprom.c</PathWithFileName>
+      <FilenameWithoutPath>eeprom.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+    <File>
+      <GroupNumber>8</GroupNumber>
+      <FileNumber>46</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\Application\eeprom\eeprom_address.c</PathWithFileName>
+      <FilenameWithoutPath>eeprom_address.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+  </Group>
+
 </ProjectOpt>

Project/Compiler/AKM_Temperature_Demo.uvprojx

@@ -322,7 +322,7 @@
             <PlainCh>0</PlainCh>
             <Ropi>0</Ropi>
             <Rwpi>0</Rwpi>
-            <wLevel>1</wLevel>
+            <wLevel>2</wLevel>
             <uThumb>0</uThumb>
             <uSurpInc>0</uSurpInc>
             <uC99>1</uC99>
@@ -339,7 +339,7 @@
               <MiscControls></MiscControls>
               <Define>TARGET=32660,TARGET_REV=0x4131</Define>
               <Undefine></Undefine>
-              <IncludePath>..\SDK\Device;..\SDK\Device\Include;..\SDK\Driver\Include;..\SDK\Driver\Source;..\SDK\FlashLoader;..\SDK\Startup;..\Application;..\Application\oled_ssd1306;..\Application\resource;..\Application\sensor</IncludePath>
+              <IncludePath>..\SDK\Device;..\SDK\Device\Include;..\SDK\Driver\Include;..\SDK\Driver\Source;..\SDK\FlashLoader;..\SDK\Startup;..\Application;..\Application\oled_ssd1306;..\Application\resource;..\Application\sensor;..\Application\eeprom</IncludePath>
             </VariousControls>
           </Cads>
           <Aads>
@@ -357,7 +357,7 @@
               <MiscControls></MiscControls>
               <Define></Define>
               <Undefine></Undefine>
-              <IncludePath></IncludePath>
+              <IncludePath>..\Application;..\Application\eeprom;..\Application\oled_ssd1306;..\Application\resource;..\Application\sensor;..\SDK;..\SDK\Device;..\SDK\Device\Include;..\SDK\Driver;..\SDK\Driver\Source;..\SDK\Driver\Include;..\SDK\FlashLoader;..\SDK\Startup</IncludePath>
             </VariousControls>
           </Aads>
           <LDads>
@@ -630,6 +630,26 @@
             </File>
           </Files>
         </Group>
+        <Group>
+          <GroupName>Eeprom</GroupName>
+          <Files>
+            <File>
+              <FileName>cammsys_flash.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\Application\eeprom\cammsys_flash.c</FilePath>
+            </File>
+            <File>
+              <FileName>eeprom.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\Application\eeprom\eeprom.c</FilePath>
+            </File>
+            <File>
+              <FileName>eeprom_address.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\Application\eeprom\eeprom_address.c</FilePath>
+            </File>
+          </Files>
+        </Group>
       </Groups>
     </Target>
   </Targets>

Project/Compiler/Listings/startup_max32660.lst

@@ -773,10 +773,20 @@ ARM Macro Assembler    Page 12
               00000000 
 Command Line: --debug --xref --diag_suppress=9931 --cpu=Cortex-M4.fp.sp --apcs=
 interwork --depend=.\objects\startup_max32660.d -o.\objects\startup_max32660.o 
--IC:\Users\befs\AppData\Local\Arm\Packs\Maxim\MAX32660\1.5.0\Libraries\CMSIS\De
+-I..\Application -I..\Application\eeprom -I..\Application\oled_ssd1306 -I..\App
-vice\Maxim\MAX32660\Include -IC:\Keil_v5\ARM\CMSIS\Include --predefine="__MICRO
+lication\resource -I..\Application\sensor -I..\SDK -I..\SDK\Device -I..\SDK\Dev
-LIB SETA 1" --predefine="__UVISION_VERSION SETA 533" --predefine="MAX32660 SETA
+ice\Include -I..\SDK\Driver -I..\SDK\Driver\Source -I..\SDK\Driver\Include -I..
- 1" --list=.\listings\startup_max32660.lst ..\SDK\Startup\startup_max32660.s
+\SDK\FlashLoader -I..\SDK\Startup -IC:\Users\befs\AppData\Local\Arm\Packs\Maxim
+\MAX32660\1.5.0\Libraries\CMSIS\Device\Maxim\MAX32660\Include -IC:\Keil_v5\ARM\
+
+
+
+ARM Macro Assembler    Page 13 
+
+
+CMSIS\Include --predefine="__MICROLIB SETA 1" --predefine="__UVISION_VERSION SE
+TA 533" --predefine="MAX32660 SETA 1" --list=.\listings\startup_max32660.lst ..
+\SDK\Startup\startup_max32660.s