没有 EEPROM 怎么办？不慌，用内部 Flash 模拟

/* Define to prevent recursive inclusion -------------------------------------*/

#ifndef __EEPROM_Simulation_H

#define __EEPROM_Simulation_H



/* Includes ------------------------------------------------------------------*/

#include "mm32_device.h"



/* Exported constants --------------------------------------------------------*/

#define PAGE_SIZE  (uint16_t)0x400  /* Page size = 1KByte */





/* EEPROM start address in Flash */

#define EEPROM_START_ADDRESS    ((uint32_t)0x0800F800) /* EEPROM emulation start address:

                                                  after 62KByte of used Flash memory */



/* Pages 0 and 1 base and end addresses */

#define PAGE0_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + 0x000))

#define PAGE0_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))



#define PAGE1_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))

#define PAGE1_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))



/* 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)0x0057)



/* 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)



/* Variables' number. max value is 256 for 1KByte page, max value is 512 for 2KByte page */

#define NumbOfVar               ((uint8_t)0x03)



/* Exported types --------------------------------------------------------*/

/* Exported macro --------------------------------------------------------*/

/* Exported functions ----------------------------------------------------*/

uint16_t EEPROM_Simulation_Init(void);

uint16_t EEPROM_Simulation_ReadVar(uint16_t VirtAddress, uint16_t* Data);

uint16_t EEPROM_Simulation_WriteVar(uint16_t VirtAddress, uint16_t Data);



#endif /* __EEPROM_Simulation_H */

/* Private variables ---------------------------------------------------------*/

uint16_t VarValue = 0;

uint16_t ReadValue1, ReadValue2, ReadValue3;



/* Virtual address defined by the user: 0xFFFF value is prohibited */

uint16_t VirtAddVarTab[NumbOfVar] = {0x0101, 0x0202, 0x0303};



/**

 * [url=home.php?mod=space&uid=247401]@brief[/url] eeprom_init_cmd

 */

void eeprom_init_cmd(char argc, char *argv)

{

    do

    {

        /* Unlock the Flash Program Erase controller */

        FLASH_Unlock();



        /* EEPROM Init */

        EEPROM_Simulation_Init();



        /* --- Store successively many values of the three variables in the EEPROM ---*/

        /* Store 50 values of Variable1 in EEPROM */

        for (VarValue = 0; VarValue < 50; VarValue++)

        {

            EEPROM_Simulation_WriteVar(VirtAddVarTab[0], VarValue);

        }



        /* Store 100 values of Variable2 in EEPROM */

        for (VarValue = 0; VarValue < 100; VarValue++)

        {

            EEPROM_Simulation_WriteVar(VirtAddVarTab[1], VarValue);

        }



        /* Store 45 values of Variable3 in EEPROM */

        for (VarValue = 0; VarValue < 45; VarValue++)

        {

            EEPROM_Simulation_WriteVar(VirtAddVarTab[2], VarValue);

        }



        EEPROM_Simulation_ReadVar(VirtAddVarTab[0], &ReadValue1); //ReadValue1 should be equal 49

        EEPROM_Simulation_ReadVar(VirtAddVarTab[1], &ReadValue2); //ReadValue2 should be equal 99

        EEPROM_Simulation_ReadVar(VirtAddVarTab[2], &ReadValue3); //ReadValue3 should be equal 44

        printf("\r\n ReadValue1,2,3 = 0x%x-0x%x-0x%x after init\r\n", ReadValue1, ReadValue2, ReadValue3);

        /* Lock the Flash Program Erase controller */

        FLASH_Lock();

    }

    while (0);

}



/**

 * [url=home.php?mod=space&uid=247401]@brief[/url] eeprom_rw_cmd

 */

void eeprom_rw_cmd(char argc, char *argv)

{

    u16 usEEPROM_Temp[3] = {0};



    /* Unlock the Flash Program Erase controller */

    FLASH_Unlock();

    printf("rd eep data before writing\r\n");

    EEPROM_Simulation_ReadVar(VirtAddVarTab[0], &ReadValue1);

    EEPROM_Simulation_ReadVar(VirtAddVarTab[1], &ReadValue2);

    EEPROM_Simulation_ReadVar(VirtAddVarTab[2], &ReadValue3);

    printf("\r\n ReadValue1,2,3 = 0x%x-0x%x-0x%x\r\n", ReadValue1, ReadValue2, ReadValue3);

    usEEPROM_Temp[0] = ReadValue1 ;

    usEEPROM_Temp[1] = ReadValue2 ;

    usEEPROM_Temp[2] = ReadValue3 ;



    EEPROM_Simulation_WriteVar(VirtAddVarTab[0], ReadValue1 + 1);

    EEPROM_Simulation_WriteVar(VirtAddVarTab[1], ReadValue2 + 2);

    EEPROM_Simulation_WriteVar(VirtAddVarTab[2], ReadValue3 + 3);

    printf("rd eep data atter writing\r\n");

    EEPROM_Simulation_ReadVar(VirtAddVarTab[0], &ReadValue1);

    EEPROM_Simulation_ReadVar(VirtAddVarTab[1], &ReadValue2);

    EEPROM_Simulation_ReadVar(VirtAddVarTab[2], &ReadValue3);

    printf("\r\n ReadValue1,2,3 = 0x%x-0x%x-0x%x\r\n", ReadValue1, ReadValue2, ReadValue3);

    if ((ReadValue1 == (usEEPROM_Temp[0] + 1)) && (ReadValue2 == (usEEPROM_Temp[1] + 2))  \

            && (ReadValue3 == (usEEPROM_Temp[2] + 3)))

    {

        printf("EEPROM test successed \r\n");

        DELAY_Ms(200);

        /* Lock the Flash Program Erase controller */

        FLASH_Lock();

        NVIC_SystemReset();

    }

    else

        printf("EEPROM test failed \r\n");

    /* Lock the Flash Program Erase controller */

    FLASH_Lock();

}



const static_cmd_st static_cmd[] =

{

    {"ls", shell_ls_cmd},

    {"test", shell_test_cmd},

    {"blink", blink_led_cmd},

    {"eepinit", eeprom_init_cmd},

    {"eeprw", eeprom_rw_cmd},

    {"eepinit2", eeprom_init2_cmd},

    {"eeprw2", eeprom_rw2_cmd},

    {"\0", NULL}

};

/**

  * @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 = 0x08010000, PageEndAddress = 0x080107FF;



    /* 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));



    if(usTransfer_Mutex ==1 && (Address % 0x400 == 0) )

    {

        Address = Address + 4;

    }

    

    /* 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)//erased

        {

            /* 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

  */



/* copy one the other last updated data to the new page and erase the old page

 * and set the new page to VALID_PAGE

 */

static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)

{

    FLASH_Status FlashStatus = FLASH_COMPLETE;

    uint32_t NewPageAddress = 0x080103FF, OldPageAddress = 0x08010000;

    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;

        usPageStatus0 = RECEIVE_DATA ;////

        

        /* Old page address where variable will be taken from */

        OldPageAddress = PAGE1_BASE_ADDRESS;

    }

    else if (ValidPage == PAGE0)  /* Page0 valid */

    {

        /* New page address where variable will be moved to */

        NewPageAddress = PAGE1_BASE_ADDRESS;

        usPageStatus1 = RECEIVE_DATA ;////

        

        /* Old page address where variable will be taken from */

        OldPageAddress = PAGE0_BASE_ADDRESS;

    }

    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;

//    }

    usTransfer_Mutex = 1; //加上互斥锁，避免页面开头的 2个状态标志位没有占到位

    

    /* 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 < NumbOfVar; VarIdx++)

    {

        if (VirtAddVarTab[VarIdx] != VirtAddress)  /* Check each variable except the one passed as parameter */

        {

            /* Read the other last variable updates */

            ReadStatus = EEPROM_Simulation_ReadVar(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 != FLASH_COMPLETE)

                {

                    return EepromStatus;

                }

            }

        }

    }



    /* Erase the old Page: Set old Page status to ERASED status */

    FlashStatus = FLASH_ErasePage(OldPageAddress);

    /* 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;

    } 



    usTransfer_Mutex = 0;

    if(NewPageAddress == PAGE0_BASE_ADDRESS)

    {

        usPageStatus0 = ERASED ;////

        usPageStatus1 = VALID_PAGE ;////

    }

    else

    {

        usPageStatus1 = ERASED ;////

        usPageStatus0 = VALID_PAGE ;////

    }

    /* Return last operation flash status */

    return FlashStatus;

}