diff --git a/Makefile b/Makefile
index 93bfccb771613b510a042179f370c1947bcbc45a..854ba855c03974b624529ac1d5aa7d9ab9e29a35 100755
--- a/Makefile
+++ b/Makefile
@@ -30,7 +30,8 @@ AS = $(TCHAIN_PREFIX)gcc
ASFLAGS = $(COMPILE_OPTS) -c
LD = $(TCHAIN_PREFIX)gcc
-LDFLAGS = -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -Wl,-Map=$@.map,-cref $(INCLUDE_DIRS) $(LIBRARY_DIRS) -T $(STM32_LINKER_SCRIPTS_PATH)/$(LINKER_SCRIPT_FILE) -nostartfiles
+#LDFLAGS = -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -Wl,-Map=$@.map,-cref $(INCLUDE_DIRS) $(LIBRARY_DIRS) -T $(STM32_LINKER_SCRIPTS_PATH)/$(LINKER_SCRIPT_FILE) -nostartfiles
+LDFLAGS = -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -Wl,-Map=$@.map,-cref $(INCLUDE_DIRS) $(LIBRARY_DIRS) -T linker_script/STM32F4_1024FLASH_192RAM.ld -nostartfiles
OBJCP = $(TCHAIN_PREFIX)objcopy
OBJCPFLAGS_HEX = -O ihex
diff --git a/include/eeprom.h b/include/eeprom.h
new file mode 100755
index 0000000000000000000000000000000000000000..0ddcbc73fdb4086579505f8703290a640d5f9899
--- /dev/null
+++ b/include/eeprom.h
@@ -0,0 +1,88 @@
+/**
+ ******************************************************************************
+ * @file EEPROM_Emulation/inc/eeprom.h
+ * @author MCD Application Team
+ * @version V1.0.0
+ * @date 10-October-2011
+ * @brief This file contains all the functions prototypes for the EEPROM
+ * emulation firmware library.
+ ******************************************************************************
+ * @attention
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __EEPROM_H
+#define __EEPROM_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx.h"
+
+/* Exported constants --------------------------------------------------------*/
+/* Define the size of the sectors to be used */
+#define PAGE_SIZE (uint32_t)0x4000 /* Page size = 16KByte */
+
+/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
+ be done by word */
+#define VOLTAGE_RANGE (uint8_t)VoltageRange_3
+
+/* EEPROM start address in Flash */
+#define EEPROM_START_ADDRESS ((uint32_t)0x08004000) /* 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 FLASH_Sector_1
+
+#define PAGE1_BASE_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + 0x4000))
+#define PAGE1_END_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
+#define PAGE1_ID FLASH_Sector_2
+
+/* Used Flash pages for EEPROM emulation */
+#define PAGE0 ((uint16_t)0x0000)
+#define PAGE1 ((uint16_t)0x0001)
+
+/* No valid page define */
+#define NO_VALID_PAGE ((uint16_t)0x00AB)
+
+/* Page status definitions */
+#define ERASED ((uint16_t)0xFFFF) /* Page is empty */
+#define RECEIVE_DATA ((uint16_t)0xEEEE) /* Page is marked to receive data */
+#define VALID_PAGE ((uint16_t)0x0000) /* 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)
+
+/* Virtual address defined by the user: 0xFFFF value is prohibited */
+#define DEVICE_MODEL_OFFSET ((uint16_t)0x0000)
+#define FIRMWARE_VERSION_OFFSET ((uint16_t)0x0002)
+#define DEVICE_ID_OFFSET ((uint16_t)0x0003)
+#define BAUDRATE_OFFSET ((uint16_t)0x0004)
+#define RETURN_DELAY_OFFSET ((uint16_t)0x0005)
+#define RETURN_LEVEL_OFFSET ((uint16_t)0x0010)
+
+/* Exported types ------------------------------------------------------------*/
+/* Exported macro ------------------------------------------------------------*/
+/* Exported functions ------------------------------------------------------- */
+uint16_t EE_Init(void);
+uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
+uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
+
+#endif /* __EEPROM_H */
+
+/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
diff --git a/linker_script/STM32F4_1024FLASH_192RAM.ld b/linker_script/STM32F4_1024FLASH_192RAM.ld
new file mode 100644
index 0000000000000000000000000000000000000000..540f0b978714910357480af367ee54e4de4ec718
--- /dev/null
+++ b/linker_script/STM32F4_1024FLASH_192RAM.ld
@@ -0,0 +1,195 @@
+/*
+*****************************************************************************
+**
+** File : stm32_flash.ld
+**
+** Abstract : Linker script for STM32F4 Devices with 1024KByte FLASH
+** and 192KByte RAM
+**
+** Set heap size, stack size and stack location according
+** to application requirements.
+**
+** Set memory bank area and size if external memory is used.
+**
+** Target : STMicroelectronics STM32
+**
+** Environment : GNU compiler
+**
+** Distribution: The file is distributed “as is,” without any warranty
+** of any kind.
+**
+** (c)Copyright Atollic AB.
+** You may use this file as-is or modify it according to the needs of your
+** project. This file may only be built (assembled or compiled and linked)
+** using the Atollic TrueSTUDIO(R) product. The use of this file together
+** with other tools than Atollic TrueSTUDIO(R) is not permitted.
+**
+*****************************************************************************
+*/
+
+/* Entry Point */
+ENTRY(Reset_Handler)
+
+/* Highest address of the user mode stack */
+_estack = 0x2001FFFF; /* end of RAM */
+
+/* Generate a link error if heap and stack don't fit into RAM */
+_Min_Heap_Size = 0; /* required amount of heap */
+_Min_Stack_Size = 0x400; /* required amount of stack */
+
+/* Specify the memory areas */
+MEMORY
+{
+FLASH1 (rx) : ORIGIN = 0x08000000, LENGTH = 16K
+EEPROM (rw) : ORIGIN = 0x08004000, LENGTH = 32K
+FLASH2 (rx) : ORIGIN = 0x0800C000, LENGTH = 976K
+RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
+CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
+}
+
+/* Define output sections */
+SECTIONS
+{
+ /* The startup code goes first into FLASH */
+ .isr_vector :
+ {
+ . = ALIGN(4);
+ KEEP(*(.isr_vector)) /* Startup code */
+ . = ALIGN(4);
+ } >FLASH1
+
+ .eeprom :
+ {
+ . = ALIGN(4);
+ *(.eeprom)
+ . = ALIGN(4);
+ } >EEPROM
+
+ /* The program code and other data goes into FLASH */
+ .text :
+ {
+ . = ALIGN(4);
+ *(.text) /* .text sections (code) */
+ *(.text*) /* .text* sections (code) */
+ *(.glue_7) /* glue arm to thumb code */
+ *(.glue_7t) /* glue thumb to arm code */
+ *(.eh_frame)
+
+ KEEP (*(.init))
+ KEEP (*(.fini))
+
+ . = ALIGN(4);
+ _etext = .; /* define a global symbols at end of code */
+ } >FLASH2
+
+ /* Constant data goes into FLASH */
+ .rodata :
+ {
+ . = ALIGN(4);
+ *(.rodata) /* .rodata sections (constants, strings, etc.) */
+ *(.rodata*) /* .rodata* sections (constants, strings, etc.) */
+ . = ALIGN(4);
+ } >FLASH2
+
+ .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH2
+ .ARM : {
+ __exidx_start = .;
+ *(.ARM.exidx*)
+ __exidx_end = .;
+ } >FLASH2
+
+ .preinit_array :
+ {
+ PROVIDE_HIDDEN (__preinit_array_start = .);
+ KEEP (*(.preinit_array*))
+ PROVIDE_HIDDEN (__preinit_array_end = .);
+ } >FLASH2
+ .init_array :
+ {
+ PROVIDE_HIDDEN (__init_array_start = .);
+ KEEP (*(SORT(.init_array.*)))
+ KEEP (*(.init_array*))
+ PROVIDE_HIDDEN (__init_array_end = .);
+ } >FLASH2
+ .fini_array :
+ {
+ PROVIDE_HIDDEN (__fini_array_start = .);
+ KEEP (*(SORT(.fini_array.*)))
+ KEEP (*(.fini_array*))
+ PROVIDE_HIDDEN (__fini_array_end = .);
+ } >FLASH2
+
+ /* used by the startup to initialize data */
+ _sidata = LOADADDR(.data);
+
+ /* Initialized data sections goes into RAM, load LMA copy after code */
+ .data :
+ {
+ . = ALIGN(4);
+ _sdata = .; /* create a global symbol at data start */
+ *(.data) /* .data sections */
+ *(.data*) /* .data* sections */
+
+ . = ALIGN(4);
+ _edata = .; /* define a global symbol at data end */
+ } >RAM AT> FLASH2
+
+ _siccmram = LOADADDR(.ccmram);
+
+ /* CCM-RAM section
+ *
+ * IMPORTANT NOTE!
+ * If initialized variables will be placed in this section,
+ * the startup code needs to be modified to copy the init-values.
+ */
+ .ccmram :
+ {
+ . = ALIGN(4);
+ _sccmram = .; /* create a global symbol at ccmram start */
+ *(.ccmram)
+ *(.ccmram*)
+
+ . = ALIGN(4);
+ _eccmram = .; /* create a global symbol at ccmram end */
+ } >CCMRAM AT> FLASH2
+
+
+ /* Uninitialized data section */
+ . = ALIGN(4);
+ .bss :
+ {
+ /* This is used by the startup in order to initialize the .bss secion */
+ _sbss = .; /* define a global symbol at bss start */
+ __bss_start__ = _sbss;
+ *(.bss)
+ *(.bss*)
+ *(COMMON)
+
+ . = ALIGN(4);
+ _ebss = .; /* define a global symbol at bss end */
+ __bss_end__ = _ebss;
+ } >RAM
+
+ /* User_heap_stack section, used to check that there is enough RAM left */
+ ._user_heap_stack :
+ {
+ . = ALIGN(4);
+ PROVIDE ( end = . );
+ PROVIDE ( _end = . );
+ . = . + _Min_Heap_Size;
+ . = . + _Min_Stack_Size;
+ . = ALIGN(4);
+ } >RAM
+
+
+
+ /* Remove information from the standard libraries */
+ /DISCARD/ :
+ {
+ libc.a ( * )
+ libm.a ( * )
+ libgcc.a ( * )
+ }
+
+ .ARM.attributes 0 : { *(.ARM.attributes) }
+}
diff --git a/src/bioloid_stm32.c b/src/bioloid_stm32.c
index 84e7c860d8937929a7c61b4d60374c2824f69e5c..e9b0ebdc29a627ef91ab43a7c0d2eae8ea0613e1 100644
--- a/src/bioloid_stm32.c
+++ b/src/bioloid_stm32.c
@@ -5,12 +5,35 @@
#include "dynamixel.h"
#include "dynamixel_master_uart.h"
#include "dynamixel_slave_spi.h"
+#include "eeprom.h"
+
+uint8_t read_operation(uint8_t address, uint8_t length, uint8_t *data)
+{
+ uint8_t i;
+ uint16_t eeprom_data;
+
+ if(address >= DEVICE_MODEL_OFFSET && address <= RETURN_LEVEL_OFFSET ) // EEPROM region
+ {
+ for(i=0;i<length;i++)
+ {
+ if(EE_ReadVariable(address+i,&eeprom_data)==1)
+ return DYN_INST_ERROR;
+ else
+ data[i]=(uint8_t)eeprom_data;
+ }
+ return DYN_NO_ERROR;
+ }
+ else// RAM region
+ {
+ }
+}
int32_t main(void)
{
uint8_t inst_packet[1024];
uint8_t status_packet[1024];
- uint8_t data[1024];
+ uint8_t data[1024],error;
+ uint16_t address;
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOD Periph clock enable */
@@ -24,6 +47,8 @@ int32_t main(void)
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
+ /* initialize EEPROM */
+ EE_Init();
/* initialize the 1ms system timer */
time_init();
/* initialize the dynamixel master interface */
@@ -31,7 +56,8 @@ int32_t main(void)
dyn_master_set_timeout(10);
/* initialize the dynamixel slave interface*/
dyn_slave_init();
- dyn_slave_set_address(13);
+ EE_ReadVariable(DEVICE_ID_OFFSET,&address);
+ dyn_slave_set_address((uint8_t)address);
while(1) /* main function does not return */
{
@@ -46,7 +72,21 @@ int32_t main(void)
{
// process the packet
GPIO_ToggleBits(GPIOD, GPIO_Pin_15);
- dyn_slave_send_status_packet(DYN_NO_ERROR,0,data);
+ switch(dyn_get_instruction(inst_packet))
+ {
+ case DYN_PING: dyn_slave_send_status_packet(DYN_NO_ERROR,0,data);
+ break;
+ case DYN_READ: error=read_operation(dyn_get_read_address(inst_packet),dyn_get_read_length(inst_packet),data);
+ if(error==DYN_NO_ERROR)
+ dyn_slave_send_status_packet(error,dyn_get_read_length(inst_packet),data);
+ else
+ dyn_slave_send_status_packet(DYN_NO_ERROR,0,data);
+ break;
+ case DYN_WRITE:
+ break;
+ default:
+ break;
+ }
}
else// the packet is addressed to another device
{
diff --git a/src/eeprom.c b/src/eeprom.c
new file mode 100755
index 0000000000000000000000000000000000000000..6765b910f3875560cbc01b380017c7c27279c3a9
--- /dev/null
+++ b/src/eeprom.c
@@ -0,0 +1,638 @@
+/**
+ ******************************************************************************
+ * @file EEPROM_Emulation/src/eeprom.c
+ * @author MCD Application Team
+ * @version V1.0.0
+ * @date 10-October-2011
+ * @brief This file provides all the EEPROM emulation firmware functions.
+ ******************************************************************************
+ * @attention
+ *
+ * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
+ * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
+ * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
+ * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
+ * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
+ ******************************************************************************
+ */
+
+/** @addtogroup EEPROM_Emulation
+ * @{
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "eeprom.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+#define EEPROM_SIZE 0x6
+#define DEFAULT_DEVICE_MODEL 0x7300
+#define DEFAULT_FIRMWARE_VERSION 0x13
+#define DEFAULT_DEVICE_ID 0x0D
+#define DEFAULT_BAUDRATE 0x01
+#define DEFAULT_RETURN_DELAY 0x00
+#define DEFAULT_RETURN_LEVEL 0x02
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+
+/* Global variable used to store variable value in read sequence */
+uint16_t DataVar = 0;
+
+// EEPROM memory map
+uint16_t eeprom_data[] __attribute__ ((section (".eeprom")))={VALID_PAGE,
+ 0xFFFF,
+ DEFAULT_DEVICE_MODEL&0xFF,// model number LSB
+ DEVICE_MODEL_OFFSET,
+ DEFAULT_DEVICE_MODEL>>8,// model number MSB
+ DEVICE_MODEL_OFFSET+1,
+ DEFAULT_FIRMWARE_VERSION,// firmware version
+ FIRMWARE_VERSION_OFFSET,
+ DEFAULT_DEVICE_ID,// default device id
+ DEVICE_ID_OFFSET,
+ DEFAULT_BAUDRATE,// default baudrate
+ BAUDRATE_OFFSET,
+ DEFAULT_RETURN_DELAY,// return delay time
+ RETURN_DELAY_OFFSET,
+ DEFAULT_RETURN_LEVEL,
+ RETURN_LEVEL_OFFSET};// return level
+
+/* Private function prototypes -----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+static FLASH_Status EE_Format(void);
+static uint16_t EE_FindValidPage(uint8_t Operation);
+static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
+static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
+
+/**
+ * @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
+ */
+uint16_t EE_Init(void)
+{
+ uint16_t PageStatus0 = 6, PageStatus1 = 6;
+ uint16_t VarIdx = 0;
+ uint16_t EepromStatus = 0, ReadStatus = 0;
+ int16_t x = -1;
+ uint16_t FlashStatus;
+
+ /* Get Page0 status */
+ PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
+ /* Get Page1 status */
+ PageStatus1 = (*(__IO uint16_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 */
+ FlashStatus = FLASH_EraseSector(PAGE0_ID,VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
+ {
+ /* Erase Page0 */
+ FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ /* Mark Page1 as valid */
+ FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ 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 erase/program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ break;
+
+ case RECEIVE_DATA:
+ if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
+ {
+ /* Transfer data from Page1 to Page0 */
+ for (VarIdx = 0; VarIdx < EEPROM_SIZE; VarIdx++)
+ {
+ if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == eeprom_data[VarIdx])
+ {
+ x = VarIdx;
+ }
+ if (VarIdx != x)
+ {
+ /* Read the last variables' updates */
+ ReadStatus = EE_ReadVariable(eeprom_data[VarIdx], &DataVar);
+ /* In case variable corresponding to the virtual address was found */
+ if (ReadStatus != 0x1)
+ {
+ /* Transfer the variable to the Page0 */
+ EepromStatus = EE_VerifyPageFullWriteVariable(eeprom_data[VarIdx], DataVar);
+ /* If program operation was failed, a Flash error code is returned */
+ if (EepromStatus != FLASH_COMPLETE)
+ {
+ return EepromStatus;
+ }
+ }
+ }
+ }
+ /* Mark Page0 as valid */
+ FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ /* Erase Page1 */
+ FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
+ {
+ /* Erase Page1 */
+ FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ /* Mark Page0 as valid */
+ FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ 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 != FLASH_COMPLETE)
+ {
+ 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 != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
+ {
+ /* Erase Page1 */
+ FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ else /* Page0 valid, Page1 receive */
+ {
+ /* Transfer data from Page0 to Page1 */
+ for (VarIdx = 0; VarIdx < EEPROM_SIZE; VarIdx++)
+ {
+ if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == eeprom_data[VarIdx])
+ {
+ x = VarIdx;
+ }
+ if (VarIdx != x)
+ {
+ /* Read the last variables' updates */
+ ReadStatus = EE_ReadVariable(eeprom_data[VarIdx], &DataVar);
+ /* In case variable corresponding to the virtual address was found */
+ if (ReadStatus != 0x1)
+ {
+ /* Transfer the variable to the Page1 */
+ EepromStatus = EE_VerifyPageFullWriteVariable(eeprom_data[VarIdx], DataVar);
+ /* If program operation was failed, a Flash error code is returned */
+ if (EepromStatus != FLASH_COMPLETE)
+ {
+ return EepromStatus;
+ }
+ }
+ }
+ }
+ /* Mark Page1 as valid */
+ FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ /* Erase Page0 */
+ FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ }
+ 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 != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ break;
+ }
+
+ return FLASH_COMPLETE;
+}
+
+/**
+ * @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.
+ */
+uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
+{
+ uint16_t ValidPage = PAGE0;
+ uint16_t AddressValue = 0x5555, ReadStatus = 1;
+ uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
+
+ /* 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 - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
+
+ /* Check each active page address starting from end */
+ while (Address > (PageStartAddress + 2))
+ {
+ /* Get the current location content to be compared with virtual address */
+ AddressValue = (*(__IO uint16_t*)Address);
+
+ /* Compare the read address with the virtual address */
+ if (AddressValue == VirtAddress)
+ {
+ /* Get content of Address-2 which is variable value */
+ *Data = (*(__IO uint16_t*)(Address - 2));
+
+ /* 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
+ */
+uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+ uint16_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 FLASH_Status EE_Format(void)
+{
+ FLASH_Status FlashStatus = FLASH_COMPLETE;
+
+ /* Erase Page0 */
+ FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
+
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+
+ /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
+ FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
+
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+
+ /* Erase Page1 */
+ FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
+
+ /* Return Page1 erase operation status */
+ return FlashStatus;
+}
+
+/**
+ * @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 uint16_t EE_FindValidPage(uint8_t Operation)
+{
+ uint16_t PageStatus0 = 6, PageStatus1 = 6;
+
+ /* Get Page0 actual status */
+ PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
+
+ /* Get Page1 actual status */
+ PageStatus1 = (*(__IO uint16_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 uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+ FLASH_Status FlashStatus = FLASH_COMPLETE;
+ uint16_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));
+
+ /* Get the valid Page end Address */
+ PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * 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) == 0xFFFFFFFF)
+ {
+ /* Set variable data */
+ FlashStatus = FLASH_ProgramHalfWord(Address, Data);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+ /* Set variable virtual address */
+ FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
+ /* Return program operation status */
+ return FlashStatus;
+ }
+ else
+ {
+ /* Next address location */
+ Address = Address + 4;
+ }
+ }
+
+ /* Return PAGE_FULL in case the valid page is full */
+ return PAGE_FULL;
+}
+
+/**
+ * @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 uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
+{
+ FLASH_Status FlashStatus = FLASH_COMPLETE;
+ uint32_t NewPageAddress = EEPROM_START_ADDRESS;
+ uint16_t OldPageId=0;
+ uint16_t ValidPage = PAGE0, VarIdx = 0;
+ uint16_t EepromStatus = 0, ReadStatus = 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;
+ }
+ 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;
+ }
+ else
+ {
+ return NO_VALID_PAGE; /* No valid Page */
+ }
+
+ /* Set the new Page status to RECEIVE_DATA status */
+ FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, RECEIVE_DATA);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ 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 != FLASH_COMPLETE)
+ {
+ return EepromStatus;
+ }
+
+ /* Transfer process: transfer variables from old to the new active page */
+ for (VarIdx = 0; VarIdx < EEPROM_SIZE; VarIdx++)
+ {
+ if (eeprom_data[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */
+ {
+ /* Read the other last variable updates */
+ ReadStatus = EE_ReadVariable(eeprom_data[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(eeprom_data[VarIdx], DataVar);
+ /* If program operation was failed, a Flash error code is returned */
+ if (EepromStatus != FLASH_COMPLETE)
+ {
+ return EepromStatus;
+ }
+ }
+ }
+ }
+
+ /* Erase the old Page: Set old Page status to ERASED status */
+ FlashStatus = FLASH_EraseSector(OldPageId, VOLTAGE_RANGE);
+ /* If erase operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+
+ /* Set new Page status to VALID_PAGE status */
+ FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, VALID_PAGE);
+ /* If program operation was failed, a Flash error code is returned */
+ if (FlashStatus != FLASH_COMPLETE)
+ {
+ return FlashStatus;
+ }
+
+ /* Return last operation flash status */
+ return FlashStatus;
+}
+
+/**
+ * @}
+ */
+
+/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/