✨ feat:增加flash模拟E方存储功能

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Inc/main.h

@@ -40,7 +40,7 @@ extern "C" {
 /* Includes ------------------------------------------------------------------*/
 #include "py32f0xx_hal.h"
 #include "py32f072xx_Start_Kit.h"
-
+#include "Flash_test.h"
 /* Private includes ----------------------------------------------------------*/
 /* Private defines -----------------------------------------------------------*/
 /* Exported variables prototypes ---------------------------------------------*/

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Emulated_EEPROM.c

+// #include "r_typedefs.h"
+// #include "Internal_Flash.h"
+#include "Emulated_EEPROM.h"
+#include "Emulated_EEPROM_Access.h"
+
+
+
+/****************************************************************************
+ *   !!! The following code should be generated by configuration tool !!!   *
+****************************************************************************/
+#define   EEPROM_BLOCK0_BUFFER_SIZE         256U
+uint32_t g_u32EEPROMBlock0Buffer[EEPROM_BLOCK0_BUFFER_SIZE / 4U];
+
+
+
+
+// #define   EEPROM_BLOCK0_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_UDS_FLAG_SIZE)
+// uint32_t g_u32EEPROMBlock0Buffer[EEPROM_BLOCK0_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK1_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_UDS_S27_SIZE)
+// uint32_t g_u32EEPROMBlock1Buffer[EEPROM_BLOCK1_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK2_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_UDS_S2E_SIZE)
+// uint32_t g_u32EEPROMBlock2Buffer[EEPROM_BLOCK2_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK3_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_UDS_CONFIG_SIZE)
+// uint32_t g_u32EEPROMBlock3Buffer[EEPROM_BLOCK3_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK4_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_UDS_DTC_SIZE)
+// uint32_t g_u32EEPROMBlock4Buffer[EEPROM_BLOCK4_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK5_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_ODO_SIZE)
+// uint32_t g_u32EEPROMBlock5Buffer[EEPROM_BLOCK5_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK6_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_ODO_STAMP_SIZE)
+// uint32_t g_u32EEPROMBlock6Buffer[EEPROM_BLOCK6_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK7_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_TRIP_STAMP_SIZE)
+// uint32_t g_u32EEPROMBlock7Buffer[EEPROM_BLOCK7_BUFFER_SIZE / 4U];
+
+// #define   EEPROM_BLOCK8_BUFFER_SIZE         (EEPROM_BLOCK_CTRL_BYTE_SIZE + EEPROM_BLOCK_SERVICE_INFO_SIZE)
+// uint32_t g_u32EEPROMBlock8Buffer[EEPROM_BLOCK8_BUFFER_SIZE / 4U];
+
+static const EEPROM_Block_st_t g_stEEPROMBlockTable[] = 
+{
+    /* u32StartAddr   u32EndAddr    u32DataSize                pu32DataBuffer */
+    {SECTOR_14_START_ADDR,    0x0801E7FFUL, EEPROM_BLOCK0_BUFFER_SIZE, g_u32EEPROMBlock0Buffer,},
+    // {0x08019080UL,    0x080190FFUL, EEPROM_BLOCK1_BUFFER_SIZE, g_u32EEPROMBlock1Buffer,},
+    // {0x08019100UL,    0x0801917FUL, EEPROM_BLOCK2_BUFFER_SIZE, g_u32EEPROMBlock2Buffer,},
+    // {0x08019180UL,    0x080191FFUL, EEPROM_BLOCK3_BUFFER_SIZE, g_u32EEPROMBlock3Buffer,},
+    // {0x08019200UL,    0x0801927FUL, EEPROM_BLOCK4_BUFFER_SIZE, g_u32EEPROMBlock4Buffer,},
+    // {0x08019280UL,    0x0801967FUL, EEPROM_BLOCK5_BUFFER_SIZE, g_u32EEPROMBlock5Buffer,},
+    // {0x08019680UL,    0x08019B7FUL, EEPROM_BLOCK6_BUFFER_SIZE, g_u32EEPROMBlock6Buffer,},
+    // {0x08019B80UL,    0x0802157FUL, EEPROM_BLOCK7_BUFFER_SIZE, g_u32EEPROMBlock7Buffer,},
+    // {0x08021580UL,    0x080215FFUL, EEPROM_BLOCK8_BUFFER_SIZE, g_u32EEPROMBlock8Buffer,},
+};
+
+/****************************************************************************
+ *             !!!          End of code generation          !!!             *
+****************************************************************************/
+
+EEPROM_Block_Access_st_t g_stEEPROMBlockAccess[EEPROM_TOTAL_BLOCK_NUM];
+
+void EEPROM_Init(void)
+{
+    EEPROM_Media_Access_st_t stFlashAccessFunc;
+
+    // TYW_FDL_Init();
+    
+    stFlashAccessFunc.pfnMemErase    = Test_Flash_AppointAddress_Erase;//Int_Data_Flash_Erase;
+    stFlashAccessFunc.pfnMemBlankChk = Test_APP_FlashBlank;//Int_Data_Flash_Blank_Check;
+    stFlashAccessFunc.pfnMemRead     = Test_Flash_AppointAddress_Read;//Int_Data_Flash_Read;
+    stFlashAccessFunc.pfnMemWrite    = Test_Flash_AppointAddress_Write;//Int_Data_Flash_Write;
+    
+    // Int_Data_Flash_Register_P_E_Complete_Cb(EEPROM_Mem_Access_Complete_Callback);
+    
+    EEPROM_Access_Init( g_stEEPROMBlockTable,
+                        g_stEEPROMBlockAccess,
+                        &stFlashAccessFunc,
+                        EEPROM_TOTAL_BLOCK_NUM);
+}
+
+EEPROM_Status_en_t EEPROM_Get_Status(void)
+{
+    EEPROM_Status_en_t enStatus;
+    
+    if(EEPROM_Access_Busy())
+    {
+        enStatus = EEPROM_STAT_BUSY;
+    }
+    else
+    {
+        enStatus = EEPROM_STAT_IDLE;
+    }
+    
+    return enStatus;
+}
+
+EEPROM_Block_Status_en_t EEPROM_Get_Block_Status(uint16_t u16BlockID)
+{
+    uint8_t u8BlockStatus;
+    EEPROM_Block_Status_en_t enStatus;
+    
+    u8BlockStatus = EEPROM_Block_Access_Status(u16BlockID);
+    if (u8BlockStatus == EEPROM_BLOCK_BLANK)
+    {
+        enStatus = EEPROM_STAT_BLANK;
+    }
+    else if (u8BlockStatus == EEPROM_BLOCK_ACTIVE)
+    {
+        enStatus = EEPROM_STAT_ACTIVE;
+    }
+    else
+    {
+        enStatus = EEPROM_STAT_ERROR;
+    }
+    
+    return enStatus;
+}
+
+/*u16Len是数组的长度*/
+EEPROM_RW_Result_en_t EEPROM_Read_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len)
+{
+    uint8_t u8Error;
+    EEPROM_RW_Result_en_t enResult;
+    
+    u8Error = EEPROM_Read_Block_Data(u16BlockID, u32Data, u16Len);
+    if (u8Error)
+    {
+        enResult = EEPROM_RW_FAIL;
+    }
+    else
+    {
+        enResult = EEPROM_RW_PASS;
+    }
+    
+    return enResult;
+}
+
+/*u16Len是数组的长度*/
+EEPROM_RW_Result_en_t EEPROM_Write_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len)
+{
+    uint8_t u8Error;
+    EEPROM_RW_Result_en_t enResult;
+    
+    u8Error = EEPROM_Write_Block_Data(u16BlockID, u32Data, u16Len);
+    if (u8Error)
+    {
+        enResult = EEPROM_RW_FAIL;
+    }
+    else
+    {
+        enResult = EEPROM_RW_PASS;
+    }
+    
+    return enResult;
+}
+

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Emulated_EEPROM.h

+#ifndef EMULATED_EEPROM_H__
+#define EMULATED_EEPROM_H__
+
+#include "Flash_test.h"
+
+typedef enum
+{
+  EEPROM_STAT_BLANK = 0U,
+  EEPROM_STAT_ACTIVE,
+  EEPROM_STAT_ERROR,
+}EEPROM_Block_Status_en_t;
+
+typedef enum
+{
+  EEPROM_RW_PASS = 0,
+  EEPROM_RW_FAIL,
+}EEPROM_RW_Result_en_t;
+
+typedef enum
+{
+  EEPROM_STAT_IDLE = 0,
+  EEPROM_STAT_BUSY,
+}EEPROM_Status_en_t;
+
+/****************************************************************************
+ *   !!! The following code should be generated by configuration tool !!!   *
+****************************************************************************/
+enum g_enEEPROMBlockName
+{
+    EEPROM_BLOCK_UDS_FLAG = 0U,
+    // EEPROM_BLOCK_UDS_S27 = 1U,
+    // EEPROM_BLOCK_UDS_S2E = 2U,
+    // EEPROM_BLOCK_UDS_CONFIG = 3U,
+    // EEPROM_BLOCK_UDS_DTC = 4U,
+    // EEPROM_BLOCK_ODO = 5U,
+    // EEPROM_BLOCK_ODO_STAMP = 6U,
+    // EEPROM_BLOCK_TRIP_STAMP = 7U,
+    // EEPROM_BLOCK_SERVICE_INFO = 8U,
+};
+
+#define   EEPROM_BLOCK_UDS_FLAG_SIZE        (16U)/*Life:20.0W*/
+#define   EEPROM_BLOCK_UDS_S27_SIZE         (12U)/*Life:20.0W*/
+#define   EEPROM_BLOCK_UDS_S2E_SIZE         (12U)/*Life:20.0W*/
+#define   EEPROM_BLOCK_UDS_CONFIG_SIZE      (40U)/*Life:20.0W*/
+#define   EEPROM_BLOCK_UDS_DTC_SIZE         (56U)/*Life:20.0W*/
+#define   EEPROM_BLOCK_ODO_SIZE             (4U)/*Life:1000.0W*/
+#define   EEPROM_BLOCK_ODO_STAMP_SIZE       (8U)/*Life:1000.0W*/
+#define   EEPROM_BLOCK_TRIP_STAMP_SIZE      (16U)/*Life:1000.0W*/
+#define   EEPROM_BLOCK_SERVICE_INFO_SIZE    (56U)/*Life:20.0W*/
+
+#define   EEPROM_TOTAL_BLOCK_NUM            (1U)/*创建的独立的负载均衡空间的个数*/
+
+/****************************************************************************
+ *             !!!          End of code generation          !!!             *
+****************************************************************************/
+
+extern void EEPROM_Init(void);
+
+extern EEPROM_Status_en_t       EEPROM_Get_Status(void);
+extern EEPROM_Block_Status_en_t EEPROM_Get_Block_Status(uint16_t u16BlockID);
+
+extern EEPROM_RW_Result_en_t    EEPROM_Read_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len);
+extern EEPROM_RW_Result_en_t    EEPROM_Write_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len);
+
+#endif
+

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Emulated_EEPROM_Access.c

+#include "stddef.h"
+#include "stdint.h"
+#include "Emulated_EEPROM_Access.h"
+
+typedef union
+{
+  uint32_t    u32Word[1U];
+  
+  struct
+  {
+    uint16_t  u16Index;
+    uint16_t  u16IndexInv;
+  }stField;
+}EEPROM_Ctrl_Data_un_t;
+
+typedef struct
+{
+  uint8_t    u8State;
+  uint16_t   u16BlockNum;
+  uint16_t   u16ProgLen;
+  uint32_t   u32ProgAddr;
+  uint32_t*  pu32ProgData;  
+}EEPROM_Access_Ctrl_st_t;
+
+
+
+
+
+#define   EEPROM_BLANK_CHECK_RECORD_NUM     (3U)
+#define   EEPROM_OVER_SEARCH_RECORD_NUM     (3U)
+
+#define   EEPROM_WR_STATE_IDLE              (0U)
+#define   EEPROM_WR_STATE_ERASE             (1U)
+#define   EEPROM_WR_STATE_PROG              (2U)
+
+
+
+// -------------------------------------------------------------- 
+//      CRC16计算方法1:使用2个256长度的校验表 
+// -------------------------------------------------------------- 
+static const uint8_t g_u8EEPROMCRCTableH[] =
+{ 
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x00U, 0xC1U, 0x81U, 0x40U, 0x01U, 0xC0U, 0x80U, 0x41U,
+    0x01U, 0xC0U, 0x80U, 0x41U, 0x00U, 0xC1U, 0x81U, 0x40U,
+};
+
+static const uint8_t g_u8EEPROMCRCTableL[] =
+{ 
+    0x00U, 0xC0U, 0xC1U, 0x01U, 0xC3U, 0x03U, 0x02U, 0xC2U,
+    0xC6U, 0x06U, 0x07U, 0xC7U, 0x05U, 0xC5U, 0xC4U, 0x04U,
+    0xCCU, 0x0CU, 0x0DU, 0xCDU, 0x0FU, 0xCFU, 0xCEU, 0x0EU,
+    0x0AU, 0xCAU, 0xCBU, 0x0BU, 0xC9U, 0x09U, 0x08U, 0xC8U,
+    0xD8U, 0x18U, 0x19U, 0xD9U, 0x1BU, 0xDBU, 0xDAU, 0x1AU,
+    0x1EU, 0xDEU, 0xDFU, 0x1FU, 0xDDU, 0x1DU, 0x1CU, 0xDCU,
+    0x14U, 0xD4U, 0xD5U, 0x15U, 0xD7U, 0x17U, 0x16U, 0xD6U,
+    0xD2U, 0x12U, 0x13U, 0xD3U, 0x11U, 0xD1U, 0xD0U, 0x10U,
+    0xF0U, 0x30U, 0x31U, 0xF1U, 0x33U, 0xF3U, 0xF2U, 0x32U,
+    0x36U, 0xF6U, 0xF7U, 0x37U, 0xF5U, 0x35U, 0x34U, 0xF4U,
+    0x3CU, 0xFCU, 0xFDU, 0x3DU, 0xFFU, 0x3FU, 0x3EU, 0xFEU,
+    0xFAU, 0x3AU, 0x3BU, 0xFBU, 0x39U, 0xF9U, 0xF8U, 0x38U,
+    0x28U, 0xE8U, 0xE9U, 0x29U, 0xEBU, 0x2BU, 0x2AU, 0xEAU,
+    0xEEU, 0x2EU, 0x2FU, 0xEFU, 0x2DU, 0xEDU, 0xECU, 0x2CU,
+    0xE4U, 0x24U, 0x25U, 0xE5U, 0x27U, 0xE7U, 0xE6U, 0x26U,
+    0x22U, 0xE2U, 0xE3U, 0x23U, 0xE1U, 0x21U, 0x20U, 0xE0U,
+    0xA0U, 0x60U, 0x61U, 0xA1U, 0x63U, 0xA3U, 0xA2U, 0x62U,
+    0x66U, 0xA6U, 0xA7U, 0x67U, 0xA5U, 0x65U, 0x64U, 0xA4U,
+    0x6CU, 0xACU, 0xADU, 0x6DU, 0xAFU, 0x6FU, 0x6EU, 0xAEU,
+    0xAAU, 0x6AU, 0x6BU, 0xABU, 0x69U, 0xA9U, 0xA8U, 0x68U,
+    0x78U, 0xB8U, 0xB9U, 0x79U, 0xBBU, 0x7BU, 0x7AU, 0xBAU,
+    0xBEU, 0x7EU, 0x7FU, 0xBFU, 0x7DU, 0xBDU, 0xBCU, 0x7CU,
+    0xB4U, 0x74U, 0x75U, 0xB5U, 0x77U, 0xB7U, 0xB6U, 0x76U,
+    0x72U, 0xB2U, 0xB3U, 0x73U, 0xB1U, 0x71U, 0x70U, 0xB0U,
+    0x50U, 0x90U, 0x91U, 0x51U, 0x93U, 0x53U, 0x52U, 0x92U,
+    0x96U, 0x56U, 0x57U, 0x97U, 0x55U, 0x95U, 0x94U, 0x54U,
+    0x9CU, 0x5CU, 0x5DU, 0x9DU, 0x5FU, 0x9FU, 0x9EU, 0x5EU,
+    0x5AU, 0x9AU, 0x9BU, 0x5BU, 0x99U, 0x59U, 0x58U, 0x98U,
+    0x88U, 0x48U, 0x49U, 0x89U, 0x4BU, 0x8BU, 0x8AU, 0x4AU,
+    0x4EU, 0x8EU, 0x8FU, 0x4FU, 0x8DU, 0x4DU, 0x4CU, 0x8CU,
+    0x44U, 0x84U, 0x85U, 0x45U, 0x87U, 0x47U, 0x46U, 0x86U,
+    0x82U, 0x42U, 0x43U, 0x83U, 0x41U, 0x81U, 0x80U, 0x40U,
+};
+
+/*static const uint8_t g_u8EEPROMCRCTableH[] =
+{ 
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+};
+
+static const uint8_t g_u8EEPROMCRCTableL[] =
+{ 
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+    0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U, 0x55U,
+};*/
+
+static uint16_t EEPROM_CRC_Calc(uint32_t * pu32Data, uint16_t u16Len);
+
+EEPROM_Access_Ctrl_st_t         g_stEEPROMAccess;
+EEPROM_Block_Access_st_t *      g_pstEEPROMBlock;
+
+EEPROM_Mem_Erase_Func_ptr_t     g_pfnEEPROMMemErase;
+EEPROM_Mem_Blank_Chk_Func_ptr_t g_pfnEEPROMMemBlankCheck;
+EEPROM_Mem_Read_Func_ptr_t      g_pfnEEPROMMemRead;
+EEPROM_Mem_Write_Func_ptr_t     g_pfnEEPROMMemWrite;
+
+void EEPROM_Access_Init(const  EEPROM_Block_st_t * pstBlockTable,
+                        EEPROM_Block_Access_st_t * pstBlockAccess,
+                        EEPROM_Media_Access_st_t * pstMediaAccess,
+                        uint16_t u16BlockNum)
+{
+    uint16_t  i;
+    
+    uint8_t   u8Loop;
+    uint8_t   u8Ready;
+    uint16_t  u16Index;
+    uint16_t  u16IndexBkup;
+    uint16_t  u16RecordNum;
+    uint16_t  u16MaxRecordNum[2U];
+    uint16_t  u16WordNum;
+    uint16_t  u16Result;
+    uint32_t  u32DataAddr;
+    uint32_t  u32DataAddrBase;
+    uint32_t  u32DataAddrEnd;
+    
+    EEPROM_Ctrl_Data_un_t unCtrlData;
+    
+    if ((pstBlockTable != NULL) && (pstBlockAccess != NULL) &&\
+        (pstMediaAccess != NULL) && (u16BlockNum != 0U))
+    {
+        /*** Step 1 : Setup media(data flash) access functions ***/
+        g_pfnEEPROMMemErase      = pstMediaAccess->pfnMemErase;
+        g_pfnEEPROMMemBlankCheck = pstMediaAccess->pfnMemBlankChk;
+        g_pfnEEPROMMemRead       = pstMediaAccess->pfnMemRead;
+        g_pfnEEPROMMemWrite      = pstMediaAccess->pfnMemWrite;
+        
+        /*** Step 2 : Generate flash read / write control data ***/
+        g_stEEPROMAccess.u8State     = EEPROM_WR_STATE_IDLE;
+        g_stEEPROMAccess.u16BlockNum = u16BlockNum;          /*可以操作的E方的区域（这个项目是9个，对应g_stEEPROMBlockTable这个数组）*/
+        
+        g_pstEEPROMBlock = pstBlockAccess;
+
+        for (i = 0U; i < g_stEEPROMAccess.u16BlockNum; i++)
+        {
+            u32DataAddr = pstBlockTable[i].u32EndAddr - pstBlockTable[i].u32StartAddr + 1UL;
+            
+            g_pstEEPROMBlock[i].u8Status         = EEPROM_BLOCK_BLANK;               /*内存状态，空、使用中、错误*/
+            g_pstEEPROMBlock[i].u32BaseAddr      = pstBlockTable[i].u32StartAddr;    /*内存中的起始地址*/
+            g_pstEEPROMBlock[i].u16SectorSize    = (uint16_t)u32DataAddr;            /*内存中能使用的区域的大小*/
+            g_pstEEPROMBlock[i].u8SectorOffset   = 0U;                               /*是否偏移到下一个分区*/
+            g_pstEEPROMBlock[i].u16Index         = 0U;                                  
+            g_pstEEPROMBlock[i].u16BlockSize     = (uint16_t)(pstBlockTable[i].u32DataSize);        /*数据大小（256字节）*/
+            g_pstEEPROMBlock[i].u16MaxRecordNum  = g_pstEEPROMBlock[i].u16SectorSize / g_pstEEPROMBlock[i].u16BlockSize;
+            g_pstEEPROMBlock[i].u16RecordNum     = 0U;           
+            g_pstEEPROMBlock[i].pu32Data         = pstBlockTable[i].pu32DataBuffer; /*64,64个4字节*/
+            g_pstEEPROMBlock[i].u32EndAddr       = pstBlockTable[i].u32EndAddr;
+        }
+        
+        
+        /*** Step 3 : Blank check and find start record ***/
+        for (i = 0U; i < g_stEEPROMAccess.u16BlockNum; i++)
+        {
+            /*** 
+            Step 3.1 Blank check and find start record
+              - Check if the logic data block related memory is blank.
+              - Then find out which logic sector contains the most recent record.
+              - The found sector will define the starting search point of step 3.2.
+            ***/
+                 
+            /* Search sector +0 */
+            u32DataAddrBase  = g_pstEEPROMBlock[i].u32BaseAddr;
+            u32DataAddrEnd   = u32DataAddrBase + (uint32_t)(g_pstEEPROMBlock[i].u16SectorSize) - 1UL;
+            u32DataAddr      = g_pfnEEPROMMemBlankCheck(u32DataAddrBase, u32DataAddrEnd);
+            if (u32DataAddr == 0x00000000UL)
+            {
+                u8Loop = 0U;
+                u16MaxRecordNum[0U] = 0U;
+            }
+            else if (u32DataAddr == 0xFFFFFFFFUL)
+            {
+                u8Loop = 1U;
+                u16MaxRecordNum[0U] = g_pstEEPROMBlock[i].u16MaxRecordNum;
+            }
+            else
+            {
+                u8Loop = 1U;
+                u16MaxRecordNum[0U] = (uint16_t)u32DataAddr / g_pstEEPROMBlock[i].u16BlockSize;/*当前扇区存储的数据的个数*/
+            }
+            
+            u16RecordNum = 0U;
+            u8Ready      = 0U;
+            
+            while (u8Loop)
+            {
+                /* Fetch block control data */
+                u32DataAddr = u32DataAddrBase + (uint32_t)u16RecordNum * (uint32_t)g_pstEEPROMBlock[i].u16BlockSize;
+                g_pfnEEPROMMemRead(u32DataAddr, unCtrlData.u32Word, 1UL);
+              
+                if (unCtrlData.stField.u16Index + unCtrlData.stField.u16IndexInv == 0xFFFFU)
+                {
+                    u8Loop     = 0U;
+                    u8Ready    = 1U;
+
+                    g_pstEEPROMBlock[i].u8Status        = EEPROM_BLOCK_ACTIVE;
+                    g_pstEEPROMBlock[i].u8SectorOffset  = 0U;
+                    g_pstEEPROMBlock[i].u16RecordNum    = u16RecordNum;/*除去无效数据后，从起始开始第几次记录数据开始有效*/
+                    g_pstEEPROMBlock[i].u16Index        = unCtrlData.stField.u16Index;
+                    u16IndexBkup                        = unCtrlData.stField.u16Index;
+                }
+                else
+                {
+                    u16RecordNum++;
+                    if ((u16RecordNum >= u16MaxRecordNum[0U]) || \
+                        (u16RecordNum >= EEPROM_BLANK_CHECK_RECORD_NUM))
+                    {
+                        u8Loop = 0U;/*全部的数据都无效的情况*/
+                    }
+                }
+            }
+            /*** 
+            Step 3.2 Search for the most recent record and load data
+              - Find the last record's address
+              - Load data form the address
+            ***/
+            if (g_pstEEPROMBlock[i].u8Status == EEPROM_BLOCK_ACTIVE)
+            {
+                /* Find the last record by index */
+                u32DataAddrBase  = g_pstEEPROMBlock[i].u32BaseAddr;
+                // u32DataAddrBase += (uint32_t)(g_pstEEPROMBlock[i].u16SectorSize * (uint16_t)g_pstEEPROMBlock[i].u8SectorOffset);/*之前有扇区1，为了到扇区1偏移的地址*/
+                u16Index         = g_pstEEPROMBlock[i].u16Index;/*上一步骤查出来的有效数据的第一字节的数据编号*/
+                u16RecordNum     = g_pstEEPROMBlock[i].u16RecordNum;/*除去无效数据后，从起始开始第几次记录数据开始有效*/
+                u8Loop           = 1U;
+                
+                while (u8Loop)
+                {
+                    u16RecordNum++;
+                    u16Index++;
+                    /*如果记录位置大于当前扇区的最大记录数，或者*/
+                    if ((u16RecordNum >= u16MaxRecordNum[g_pstEEPROMBlock[i].u8SectorOffset]) || \
+                        (u16RecordNum  - g_pstEEPROMBlock[i].u16RecordNum >= EEPROM_OVER_SEARCH_RECORD_NUM))
+                    {
+                        u8Loop = 0U;
+                    }
+                    else
+                    {
+                        /* Fetch block control data */
+                        u32DataAddr = u32DataAddrBase + (uint32_t)u16RecordNum * (uint32_t)g_pstEEPROMBlock[i].u16BlockSize;
+                        g_pfnEEPROMMemRead(u32DataAddr, unCtrlData.u32Word, 1UL);
+                        
+                        if (unCtrlData.stField.u16Index + unCtrlData.stField.u16IndexInv == 0xFFFFU)
+                        {
+                            if ((unCtrlData.stField.u16Index == u16Index) && (unCtrlData.stField.u16Index > g_pstEEPROMBlock[i].u16Index))
+                            {
+                                g_pstEEPROMBlock[i].u16RecordNum = u16RecordNum;
+                                g_pstEEPROMBlock[i].u16Index     = unCtrlData.stField.u16Index;
+                            }
+                        }
+                    }
+                }
+        
+                /* Load data */
+                u16RecordNum    = g_pstEEPROMBlock[i].u16RecordNum;
+                u16Index        = g_pstEEPROMBlock[i].u16Index;
+                u16IndexBkup    = u16Index;
+                u8Loop = 1U;
+                
+                do
+                {
+                    u32DataAddr = u32DataAddrBase + (uint32_t)u16RecordNum * (uint32_t)g_pstEEPROMBlock[i].u16BlockSize;
+                    g_pfnEEPROMMemRead(u32DataAddr, unCtrlData.u32Word, 1UL);
+          
+                    if (unCtrlData.stField.u16Index + unCtrlData.stField.u16IndexInv == 0xFFFFU)
+                    {
+                        if (u16Index == unCtrlData.stField.u16Index)
+                        {
+                            u16IndexBkup = u16Index;
+                            u16WordNum   = g_pstEEPROMBlock[i].u16BlockSize / 4U;
+
+                            /* Load data */
+                            g_pfnEEPROMMemRead(u32DataAddr, g_pstEEPROMBlock[i].pu32Data, (uint32_t)u16WordNum);
+                            u16Result = EEPROM_CRC_Calc(g_pstEEPROMBlock[i].pu32Data, u16WordNum - 1U);
+                            
+                            if ((uint16_t)(g_pstEEPROMBlock[i].pu32Data[u16WordNum - 1U]) == u16Result)
+                            {
+                                u8Loop = 0U;
+                            }
+                        }
+                    }
+          
+                    if (u8Loop)     /* CRC check fail */
+                    {
+                        u16Index--;   /* Go to previous record */
+
+                        if (u16IndexBkup >= u16Index)
+                        {
+                            u16Result = u16IndexBkup - u16Index;
+                        }
+                        else
+                        {
+                            u16Result = u16IndexBkup + (0xFFFFU - u16Index) + 1U;
+                        }
+                        
+                        if ((u16Result <= u16MaxRecordNum[0U]) &&\
+                            (u16Result <= EEPROM_OVER_SEARCH_RECORD_NUM))
+                        {
+                            if (u16RecordNum == 0U)   /* Cross sector access */
+                            {
+                                if (g_pstEEPROMBlock[i].u8SectorOffset)
+                                {
+                                    u32DataAddrBase -= (uint32_t)g_pstEEPROMBlock[i].u16SectorSize;
+                                    u16RecordNum     = u16MaxRecordNum[0U];
+                                    if (u16RecordNum == 0U)
+                                    {
+                                        u8Loop = 0U;
+                                        g_pstEEPROMBlock[i].u8Status = EEPROM_BLOCK_ERROR;
+                                    }
+                                    else
+                                    {
+                                        u16RecordNum -= 1U;
+                                    }
+                                }
+                                else
+                                {
+                                    u32DataAddrBase += g_pstEEPROMBlock[i].u16SectorSize;
+                                    u16RecordNum     = u16MaxRecordNum[1U];
+                                    if (u16RecordNum == 0U)
+                                    {
+                                        u8Loop = 0U;
+                                        g_pstEEPROMBlock[i].u8Status = EEPROM_BLOCK_ERROR;
+                                    }
+                                    else
+                                    {
+                                        u16RecordNum -= 1U;
+                                    }               
+                                }
+                            }
+                            else
+                            {
+                                u16RecordNum--;
+                            }
+                        }
+                        else
+                        {
+                            /* No correct data found, set error flag */
+                            u8Loop = 0U;
+                            g_pstEEPROMBlock[i].u8Status = EEPROM_BLOCK_ERROR;
+                        }
+                    }
+                }while(u8Loop);
+            }
+        }
+    }
+}
+
+uint8_t EEPROM_Access_Busy(void)
+{
+    return g_stEEPROMAccess.u8State;
+}
+
+uint8_t EEPROM_Block_Access_Status(uint16_t u16BlockID)
+{
+    uint8_t u8Status;
+    
+    u8Status = EEPROM_BLOCK_ERROR;
+    if (u16BlockID < g_stEEPROMAccess.u16BlockNum)
+    {
+        u8Status = g_pstEEPROMBlock[u16BlockID].u8Status;
+    }
+    
+    return u8Status;
+}
+
+/* u16Len : DWord(32-bit) number to be read */
+/* Retval 0 - OK     1 - Error */
+uint8_t EEPROM_Read_Block_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len)
+{
+    uint16_t i;
+    uint8_t  u8Error;
+    
+    u8Error = 1U;
+    if ((u16BlockID < g_stEEPROMAccess.u16BlockNum) && (u32Data != NULL) && (u16Len != 0U))
+    {
+        if ((g_pstEEPROMBlock[u16BlockID].u8Status == EEPROM_BLOCK_ACTIVE) && \
+            (u16Len <= (g_pstEEPROMBlock[u16BlockID].u16BlockSize - EEPROM_BLOCK_CTRL_BYTE_SIZE) / 4U))
+        {
+            for (i = 0U; i < u16Len; i++)
+            {
+                u32Data[i] = g_pstEEPROMBlock[u16BlockID].pu32Data[i + 1U];
+            }
+            
+            u8Error = 0U;
+        }
+    }
+    
+    return u8Error;
+}
+
+/* u16Len : DWord(32-bit) number to be written */
+/* Retval 0 - OK     1 - Error */
+uint8_t EEPROM_Write_Block_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len)
+{
+    uint16_t  i;
+
+    uint8_t   u8Error;
+    uint16_t  u16WordNum;
+    uint16_t  u16Result;
+    uint32_t  u32EndAddr;
+    
+    EEPROM_Ctrl_Data_un_t unCtrlData;
+
+    u8Error = 1U;
+    if ((g_stEEPROMAccess.u8State == EEPROM_WR_STATE_IDLE) && \
+        (g_stEEPROMAccess.u16BlockNum > u16BlockID) && (u32Data != NULL) && (u16Len != 0U))
+    {
+        if (u16Len <= (g_pstEEPROMBlock[u16BlockID].u16BlockSize - EEPROM_BLOCK_CTRL_BYTE_SIZE) / 4U)
+        {
+            g_stEEPROMAccess.u8State = EEPROM_WR_STATE_PROG;
+            u16WordNum = g_pstEEPROMBlock[u16BlockID].u16BlockSize / 4U - 1U;     /* CRC checksum is ignored */
+            
+            if (g_pstEEPROMBlock[u16BlockID].u8Status == EEPROM_BLOCK_ACTIVE)
+            {
+                g_pstEEPROMBlock[u16BlockID].u16RecordNum++;
+                if (g_pstEEPROMBlock[u16BlockID].u16Index < 0xFFFF)
+                {
+                    g_pstEEPROMBlock[u16BlockID].u16Index++;
+                }
+                else 
+                {
+                    g_pstEEPROMBlock[u16BlockID].u16Index = 0U;
+                }
+
+                unCtrlData.stField.u16Index = g_pstEEPROMBlock[u16BlockID].u16Index;
+                unCtrlData.stField.u16IndexInv = 0xFFFFU - unCtrlData.stField.u16Index;
+                g_pstEEPROMBlock[u16BlockID].pu32Data[0U] = unCtrlData.u32Word[0U];
+            }
+            else
+            {
+                // g_stEEPROMAccess.u8State = EEPROM_WR_STATE_ERASE;
+                g_pstEEPROMBlock[u16BlockID].u16RecordNum    = 0U;
+                g_pstEEPROMBlock[u16BlockID].u8SectorOffset  = 0U;
+                g_pstEEPROMBlock[u16BlockID].u16Index        = 0U;
+                g_pstEEPROMBlock[u16BlockID].pu32Data[0U]    = 0xFFFF0000UL;
+        
+                for (i = 1U; i < u16WordNum; i++)
+                {
+                  g_pstEEPROMBlock[u16BlockID].pu32Data[i] = 0x00000000UL;
+                }
+                g_pstEEPROMBlock[u16BlockID].u8Status = EEPROM_BLOCK_ACTIVE;
+            }
+            
+            u16Len += 1U;
+            for (i = 1U; i < u16Len; i++)
+            {
+                g_pstEEPROMBlock[u16BlockID].pu32Data[i] = u32Data[i - 1U];
+            }
+            
+            u16Result = EEPROM_CRC_Calc(g_pstEEPROMBlock[u16BlockID].pu32Data, u16WordNum);
+            g_pstEEPROMBlock[u16BlockID].pu32Data[u16WordNum] = (uint32_t)u16Result;
+            
+            g_stEEPROMAccess.u32ProgAddr  = g_pstEEPROMBlock[u16BlockID].u32BaseAddr;
+            g_stEEPROMAccess.u32ProgAddr += (uint32_t)g_pstEEPROMBlock[u16BlockID].u16BlockSize * (uint32_t)g_pstEEPROMBlock[u16BlockID].u16RecordNum;
+            /*当新写入的信息的地址起点大于内存划分最大区域减去一个Page的大小时，需要从起始地址开始重新写*/
+            if(g_stEEPROMAccess.u32ProgAddr > (g_pstEEPROMBlock[u16BlockID].u32EndAddr - ONE_PAGE_LEN + 1UL))
+            {
+                g_stEEPROMAccess.u32ProgAddr = g_pstEEPROMBlock[u16BlockID].u32BaseAddr;
+                g_pstEEPROMBlock[u16BlockID].u16RecordNum = 0U;
+            }
+            g_stEEPROMAccess.u16ProgLen   = g_pstEEPROMBlock[u16BlockID].u16BlockSize / 4U;
+            g_stEEPROMAccess.pu32ProgData = g_pstEEPROMBlock[u16BlockID].pu32Data;
+            
+            /*先执行写入区域的擦除操作*/
+            // g_stEEPROMAccess.u8State = EEPROM_WR_STATE_ERASE;
+            u32EndAddr = g_stEEPROMAccess.u32ProgAddr + ONE_PAGE_LEN - 1UL;
+            g_pfnEEPROMMemErase(g_stEEPROMAccess.u32ProgAddr, u32EndAddr);
+
+            g_pfnEEPROMMemWrite(g_stEEPROMAccess.u32ProgAddr, g_stEEPROMAccess.pu32ProgData, (uint32_t)g_stEEPROMAccess.u16ProgLen);
+
+            g_stEEPROMAccess.u8State = EEPROM_WR_STATE_IDLE;
+            // if (g_stEEPROMAccess.u8State == EEPROM_WR_STATE_ERASE)
+            // {
+            //     u32EndAddr = g_stEEPROMAccess.u32ProgAddr + (uint32_t)g_pstEEPROMBlock[u16BlockID].u16SectorSize - 1UL;
+            //     g_pfnEEPROMMemErase(g_stEEPROMAccess.u32ProgAddr, u32EndAddr);
+            // }
+            // else
+            // {
+                
+            // }
+            
+            u8Error = 0U;
+        }
+    }
+    
+    return u8Error;
+}
+
+static uint16_t EEPROM_CRC_Calc(uint32_t * pu32Data, uint16_t u16Len)
+{
+    uint16_t i;
+    
+    uint8_t  u8CRCHi;
+    uint8_t  u8CRCLo;
+    uint8_t  u8Index;
+    uint8_t *pu8DataByte;
+    uint16_t u16CRCResult;
+    
+    u16CRCResult = 0xFFFFU;
+    if (pu32Data != NULL)
+    {
+        u8CRCHi     = 0xFFU;
+        u8CRCLo     = 0xFFU;
+        u16Len    <<= 2U;      /* u16Len = u16Len * 4U */
+        pu8DataByte = (uint8_t *)pu32Data;
+        
+        for (i = 0; i < u16Len; i++)
+        {
+            u8Index  = u8CRCLo ^ pu8DataByte[i];
+            u8CRCLo  = u8CRCHi ^ g_u8EEPROMCRCTableH[u8Index];
+            u8CRCHi  = g_u8EEPROMCRCTableL[u8Index];
+        }
+        
+        u16CRCResult   = (uint16_t)u8CRCHi;
+        u16CRCResult <<= 8U;
+        u16CRCResult  |= (uint16_t)u8CRCLo;
+    }
+    
+    return u16CRCResult;
+}

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Emulated_EEPROM_Access.h

+
+#ifndef EMULATED_EEPROM_ACCESS_H__
+#define EMULATED_EEPROM_ACCESS_H__
+
+#include  <stdint.h>
+
+#define     ONE_PAGE_LEN               0x100U
+
+typedef struct
+{
+    uint32_t   u32StartAddr;
+    uint32_t   u32EndAddr;
+    uint32_t   u32DataSize;
+    uint32_t*  pu32DataBuffer;
+}EEPROM_Block_st_t;
+
+typedef struct
+{
+    uint8_t    u8Status;
+    uint8_t    u8SectorOffset;
+    uint16_t   u16SectorSize;
+    uint16_t   u16Index;
+    uint16_t   u16RecordNum;
+    uint16_t   u16MaxRecordNum;
+    uint16_t   u16BlockSize;
+    uint32_t   u32BaseAddr;
+    uint32_t   u32EndAddr;
+    uint32_t*  pu32Data;
+}EEPROM_Block_Access_st_t;
+
+typedef void     (*EEPROM_Mem_Erase_Func_ptr_t)     (uint32_t, uint32_t);
+typedef uint32_t (*EEPROM_Mem_Blank_Chk_Func_ptr_t) (uint32_t, uint32_t);
+typedef void     (*EEPROM_Mem_Read_Func_ptr_t)      (uint32_t, uint32_t*, uint32_t);
+typedef void     (*EEPROM_Mem_Write_Func_ptr_t)     (uint32_t, uint32_t*, uint32_t);
+
+typedef struct
+{
+    EEPROM_Mem_Erase_Func_ptr_t      pfnMemErase;
+    EEPROM_Mem_Blank_Chk_Func_ptr_t  pfnMemBlankChk;
+    EEPROM_Mem_Read_Func_ptr_t       pfnMemRead;
+    EEPROM_Mem_Write_Func_ptr_t      pfnMemWrite;
+}EEPROM_Media_Access_st_t;
+
+#define   EEPROM_BLOCK_BLANK                (0U)
+#define   EEPROM_BLOCK_ACTIVE               (1U)
+#define   EEPROM_BLOCK_ERROR                (2U)
+
+#define   EEPROM_BLOCK_CTRL_BYTE_SIZE       (8U)
+
+extern void EEPROM_Access_Init(const  EEPROM_Block_st_t * pstBlockTable,
+                        EEPROM_Block_Access_st_t * pstBlockAccess,
+                        EEPROM_Media_Access_st_t * pstMediaAccess,
+                        uint16_t u16BlockNum);
+
+extern uint8_t EEPROM_Access_Busy(void);
+extern uint8_t EEPROM_Block_Access_Status(uint16_t u16BlockID);
+extern uint8_t EEPROM_Read_Block_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len);
+extern uint8_t EEPROM_Write_Block_Data(uint16_t u16BlockID, uint32_t u32Data[], uint16_t u16Len);
+extern void EEPROM_Mem_Access_Complete_Callback(void);
+
+#endif
+

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Flash_test.c

+#include "Flash_test.h"
+
+// #include "main.h"
+
+// MileageData_un_t FlashData;
+
+
+/*len是数组的长度*/
+void Test_Flash_AppointAddress_Read(uint32_t u32Addr, uint32_t u32Data[], uint32_t u32Len)
+{
+    uint32_t addr = 0U;
+
+    for (uint32_t i = 0U; i < u32Len; i++ )
+    {
+      u32Data[i] = HW32_REG(u32Addr + addr);
+      addr += 4;
+    }
+    
+    return ;
+}
+
+// uint32_t TestData[8] =
+// {
+//     0xABACADAE, 0x18176527, 0x90901990, 0xDDDDCCCC, 0x98765432, 0xAFA1A5A8, 0xC8C7C5C3, 0x20250227
+// };
+
+uint32_t TestData[8] =
+{
+    0x00000001, 0xABCDEF88, 0x10101010, 0x2B2B2B2B, 0x3C3C3C3C, 0xFEFEFEFE, 0x95959595, 0x20250304
+};
+
+uint32_t TestData1[8] =
+{
+    0xAAAAAAAA, 0xBBBBBBBB, 0xCCCCCCCC, 0xDDDDDDDD, 0xEEEEEEEE, 0xFFFFFFFF, 0x99999999, 0x20250304
+};
+uint32_t TestData2[8] =
+{
+    0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666, 0x77777777, 0x88888888
+};
+
+void Test_Flash_AppointAddress_Write(uint32_t u32Addr, uint32_t u32Data[], uint32_t u32Len)
+{
+    // LoadBalancing_NVM_Data_st_t TestData;
+    static uint32_t copyData[256];
+    memset(copyData,0,sizeof(copyData));
+    uint32_t flash_program_start = u32Addr;                /* flash program start address */
+    uint32_t flash_program_end = 0U; // (SECTOR_15_START_ADDR + sizeof(TestData));  /* flash program end address */
+
+    /* Unlock Flash */
+    HAL_FLASH_Unlock();
+
+    if (u32Len < 256u)
+    {
+      for(uint32_t i = 0; i < (256 / 4); i++)
+      {
+        copyData[i] = u32Data[i];
+      }
+    }
+    flash_program_end = u32Addr + 256U;
+
+    printf("flash_program_start:%x\n\r",flash_program_start);
+    printf("flash_program_end:%x\n\r",flash_program_end);
+
+    // uint32_t *src = (uint32_t *) &TestData;                                     /* Program data */
+    uint32_t *src = (uint32_t *)copyData;
+    while (flash_program_start < flash_program_end)
+    {
+        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_PAGE, flash_program_start, src) == HAL_OK)/* Program */
+        {
+          printf("xie ru cheng gong le ,hahahahaha\n\r");
+          flash_program_start += FLASH_PAGE_SIZE; /* flash Start point first page */
+          src += FLASH_PAGE_SIZE / 4;             /* Update data point */
+        }
+        else
+        {
+          break;
+        }
+    }
+    /* Lock Flash */
+    HAL_FLASH_Lock();
+    // EEPROM_Mem_Access_Complete_Callback();
+}
+
+void Test_Flash_AppointAddress_Erase(uint32_t u32StartAddr, uint32_t u32EndAddr)
+{
+    uint32_t PAGEError = 0;
+    FLASH_EraseInitTypeDef EraseInitStruct = {0};
+
+    /* Unlock Flash */
+    HAL_FLASH_Unlock();
+  
+    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGEERASE;        /* Erase type FLASH_TYPEERASE_PAGEERASE=Page erase, FLASH_TYPEERASE_SECTORERASE=Sector Erase */
+    EraseInitStruct.PageAddress = u32StartAddr;                               /* Erase Start Address */
+    EraseInitStruct.NbPages  = ((u32EndAddr + 1 - u32StartAddr) / 0x100);    /* Number of pages that need to be erased */
+    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)  /* Executing page erasure, PAGEError returns the page with the erasure error and 0xFFFFFFFF, indicating successful erasure */
+    {
+        // APP_ErrorHandler();
+        printf("shan qu ca chu shi bai le!!!!!!!!!\n\r");
+        /* Lock Flash */
+    }
+    else
+    {
+      
+      ;
+    }
+    /* Lock Flash */
+    HAL_FLASH_Lock();
+    // EEPROM_Mem_Access_Complete_Callback();
+}
+
+void Test_Flash_AppointSector_Erase(uint32_t u32StartAddr, uint32_t u32EndAddr)
+{
+    uint32_t PAGEError = 0;
+    FLASH_EraseInitTypeDef EraseInitStruct = {0};
+
+    /* Unlock Flash */
+    HAL_FLASH_Unlock();
+  
+    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_SECTORERASE;        /* Erase type FLASH_TYPEERASE_PAGEERASE=Page erase, FLASH_TYPEERASE_SECTORERASE=Sector Erase */
+    EraseInitStruct.SectorAddress = u32StartAddr;
+    EraseInitStruct.NbSectors = ((u32EndAddr + 1 - u32StartAddr) / 0x2000);
+    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)  /* Executing page erasure, PAGEError returns the page with the erasure error and 0xFFFFFFFF, indicating successful erasure */
+    {
+        // APP_ErrorHandler();
+        printf("shan qu ca chu shi bai le!!!!!!!!!\n\r");
+        /* Lock Flash */
+    }
+    else
+    {
+        ;
+    }
+    /* Lock Flash */
+    HAL_FLASH_Lock();
+}
+
+void Data_Create_Service(void)
+{
+    // LoadBalancing_NVM_Data_st_t TestData;
+    // TestData.mileage1 = 0xABACADAE;
+    // TestData.mileage2 = 0x18176527;
+    // TestData.mileage3 = 0x90901990;
+    // TestData.mileage4 = 0xDDDDCCCC;
+    // TestData.maintenance1 = 0x98765432;
+    // TestData.maintenance2 = 0xAFA1A5A8;
+    // TestData.maintenance3 = 0xC8C7C5C3;
+    // TestData.maintenance4 = 0x20250227;
+}
+
+/**
+  * @brief  Flash Check
+  * @param  None
+  * @retval None
+  */
+ uint32_t Test_APP_FlashBlank(uint32_t u32StartAddr, uint32_t u32EndAddr)
+{
+    uint32_t addr = 0;
+    uint32_t addroffset = 0U;
+    uint8_t  blankFlag = 0U;
+    uint32_t u32Addr = 0xFFFFFFFFU;
+    uint32_t Count = (u32EndAddr - u32StartAddr + 1) / 4;
+
+
+    for (uint32_t i = 0; i < Count; i++)
+    {
+        if (0xFFFFFFFF == HW32_REG(u32StartAddr + addr))
+        {
+        addroffset = addr;
+        for (uint32_t j = 0; j < 3; j++)
+        {
+            addroffset += 4;
+            if (0xFFFFFFFF != HW32_REG(u32StartAddr + addroffset))
+            {
+            break;
+            }
+            if (j == 2)
+            {
+            blankFlag = 1U;
+            break;
+            }
+        }
+        if (blankFlag == 1U)
+        {
+            break;
+        }
+        
+        }
+        addr += 4;
+    }
+
+    printf("cha kong shi,ci shi de  u32Addr zhi wei:%x\n\r",addr);
+    // return u32Addr;
+    if (addr == 0)
+    {
+        /*如果偏移量为0，则整个区域都没有使用过，返回0xFFFFFFFF*/
+        addr = 0xFFFFFFFF;
+    }
+    else if ((addr + u32StartAddr) > (u32EndAddr + 1U))
+    {
+        addr = 0;
+    }
+    /*返回当前内存区域内有多少字节的空间没有使用*/
+    return addr;
+}
+ 
+ /**
+   * @brief  Flash Verify
+   * @param  None
+   * @retval None
+   */
+// void Test_APP_FlashVerify(void)
+//  {
+//    uint32_t addr = 0;
+ 
+//    while (addr < sizeof(DATA))
+//    {
+//      if (DATA[addr / 4] != HW32_REG(FLASH_USER_START_ADDR + addr))
+//      {
+//        APP_ErrorHandler();
+//      }
+//      addr += 4;
+//    }
+//  }
+ 
+ /**
+   * @brief  This function is executed in case of error occurrence.
+   * @param  None
+   * @retval None
+   */
+ void Test_APP_ErrorHandler(void)
+ {
+    while (1)
+    {
+    }
+ }
+

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/Flash_test.h

+#ifndef FLASH_TEST_H__
+#define FLASH_TEST_H__
+
+#include  <stdint.h>
+#include "py32f0xx_hal.h"
+
+#define     FLASH_DATA_LEN             32
+
+
+#define     SECTOR_0_START_ADDR        0x08000000
+#define     SECTOR_1_START_ADDR        0x08002000
+#define     SECTOR_2_START_ADDR        0x08004000
+#define     SECTOR_3_START_ADDR        0x08006000
+#define     SECTOR_4_START_ADDR        0x08008000
+#define     SECTOR_5_START_ADDR        0x0800A000
+#define     SECTOR_6_START_ADDR        0x0800C000
+#define     SECTOR_7_START_ADDR        0x0800E000
+#define     SECTOR_8_START_ADDR        0x08010000
+#define     SECTOR_9_START_ADDR        0x08012000
+#define     SECTOR_10_START_ADDR       0x08014000
+#define     SECTOR_11_START_ADDR       0x08016000
+#define     SECTOR_12_START_ADDR       0x08018000
+#define     SECTOR_13_START_ADDR       0x0801A000
+#define     SECTOR_14_START_ADDR       0x0801C000
+#define     SECTOR_15_START_ADDR       0x0801E000
+
+
+typedef struct
+{
+  uint32_t mileage1;
+  uint32_t mileage2;
+  uint32_t mileage3;
+  uint32_t mileage4;
+  uint32_t maintenance1;
+  uint32_t maintenance2;
+  uint32_t maintenance3;
+  uint32_t maintenance4;
+
+}LoadBalancing_NVM_Data_st_t;
+
+// typedef union
+// {
+//     uint32_t MileageData [ 8 ];
+//     struct
+//     {
+//         uint32_t mileage1;
+//         uint32_t mileage2;
+//         uint32_t mileage3;
+//         uint32_t mileage4;
+//         uint32_t maintenance1;
+//         uint32_t maintenance2;
+//         uint32_t maintenance3;
+//         uint32_t maintenance4;
+//     } LoadBalancing_NVM_Data_st_t;
+
+// } MileageData_un_t;
+
+typedef enum
+{
+  MILEAGE1 = 0,
+  MILEAGE2,
+  MILEAGE3,
+  MILEAGE4,
+  MAINTENANCE1,
+  MAINTENANCE2,
+  MAINTENANCE3,
+  MAINTENANCE4,
+
+}FLASH_Store_Data_en_t;
+
+
+// extern LoadBalancing_NVM_Data_st_t FlashData;
+extern uint32_t TestData[8];
+extern uint32_t TestData1[8];
+extern uint32_t TestData2[8];
+
+extern void Test_Flash_AppointAddress_Read(uint32_t u32Addr, uint32_t u32Data[], uint32_t u32Len);
+extern void Test_Flash_AppointAddress_Write(uint32_t u32Addr, uint32_t u32Data[], uint32_t u32Len);
+extern void Test_Flash_AppointAddress_Erase(uint32_t u32StartAddr, uint32_t u32EndAddr);
+extern void Test_Flash_AppointSector_Erase(uint32_t u32StartAddr, uint32_t u32EndAddr);
+extern void Data_Create_Service(void);
+extern uint32_t Test_APP_FlashBlank(uint32_t u32StartAddr, uint32_t u32EndAddr);
+
+#endif
\ No newline at end of file

PY32F072_Firmware_V1.0.5/Projects/PY32F072-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/main.c

@@ -29,6 +29,8 @@
   */
 /* Includes ------------------------------------------------------------------*/
 #include "main.h"
+#include "Flash_test.h"
+#include "Emulated_EEPROM.h"
 
 /* Private define ------------------------------------------------------------*/
 #define FLASH_USER_START_ADDR     0x08004000
@@ -76,55 +78,129 @@ int main(void)
   APP_SystemClockConfig();
   
   /* Initialize Button */
-  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
+  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);/*按键功能初始化*/
   
   /* Initialize LED */
-  BSP_LED_Init(LED_GREEN); 
+  BSP_LED_Init(LED_GREEN); /*LED功能初始化*/
 
   BSP_USART_Config();/*串口打印测试用，不调用串口不能打印*/
 
   
   
   /* Wait for the button to be pressed */
-  while (BSP_PB_GetState(BUTTON_USER))
-  {
-  }
+  // while (BSP_PB_GetState(BUTTON_USER))
+  // {
+  // }
+
+  // if (BSP_PB_GetState(BUTTON_USER))
+  // {
+    // Test_Flash_AppointSector_Erase(SECTOR_8_START_ADDR, 0X801FFFF);
+  // }
+  // Data_Create_Service();
   
   /* Unlock Flash */
-  HAL_FLASH_Unlock();
+  // HAL_FLASH_Unlock();
 
   /* Erase Flash */
-  APP_FlashErase();
+  // APP_FlashErase();
   
-  /* Check Flash */
-  APP_FlashBlank();
 
-  uint32_t hahaha = 0;
+  uint32_t zheshisha = 0;
   uint32_t addr = 0;
-
-  for (uint8_t i = 0; i < 128; i++)
+  static uint32_t koko[8] = {0};
+  static uint32_t laji[8] =
   {
-    hahaha = HW32_REG(FLASH_USER_START_ADDR + addr);
-    printf("%x\n\r" , hahaha);
-    addr += 4;
-  }
+      0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666, 0x77777777, 0x88888888
+  };
+
+  // for (uint8_t j = 0; j < 4; j++)
+  // {
+  //   for (uint8_t i = 0; i < 128; i++)
+  //   {
+  //     zheshisha = HW32_REG(SECTOR_8_START_ADDR + addr);
+  //     printf("%x\n\r" , zheshisha);
+  //     addr += 4;
+  //   }
+  //   printf("shan qu %d du qu wan cheng\n\r",(11+j));
+  // }
+
+  // printf("--------------------------------------\n\r" );
+  // printf("--------------------------------------\n\r" );
+  /* Check Flash */
+  // APP_FlashBlank();
 
-  /* Program Flash */
-  APP_FlashProgram();
   
+  /* Program Flash */
+  // APP_FlashProgram();
+  // EEPROM_Write_Data(SECTOR_15_START_ADDR, koko, 8);
+  // memset(koko,0,32);
+  EEPROM_Init();
+  // for(uint8_t i = 0; i < 40; i ++)
+  // {
+    // EEPROM_Write_Data(EEPROM_BLOCK_UDS_FLAG, TestData,8);
+  //   TestData[0] ++;
+  // }
+  
+  // zheshisha = 0;
+  // addr = 0;
+
+  // for (uint8_t j = 0; j < 4; j++)
+  // {
+  //   for (uint8_t i = 0; i < 128; i++;
+  //   {
+  //     zheshisha = HW32_REG(SECTOR_12_START_ADDR + addr);
+  //     printf("%x\n\r" , zheshisha);
+  //     addr += 4;
+  //   }
+  //   printf("shan qu %d du qu wan cheng\n\r",(12+j));
+  // }
+  EEPROM_Write_Data(EEPROM_BLOCK_UDS_FLAG, TestData1,8);
+
+  // EEPROM_Write_Data(EEPROM_BLOCK_UDS_FLAG, TestData2,8);
+  // EEPROM_Write_Data(EEPROM_BLOCK_UDS_FLAG, TestData,32);
+  // Test_Flash_AppointAddress_Write(0x801C300, laji, 8);
+
+  // printf("xie ru cheng gong le\n\r");
   /* Lock Flash */
-  HAL_FLASH_Lock();
+  // HAL_FLASH_Lock();
 
   /* Verify Flash */
-  APP_FlashVerify();
+  // APP_FlashVerify();
 
   BSP_LED_On(LED_GREEN);
 
-  hahaha = HW32_REG(FLASH_USER_START_ADDR);
-  printf("%x\n" , hahaha);
+  zheshisha = 0;
+  addr = 0;
+  uint32_t dizhi = SECTOR_14_START_ADDR;
+
+  for (uint8_t j = 0; j < 40; j++)
+  {
+    for (uint8_t i = 0; i < 64; i++)
+    {
+      zheshisha = HW32_REG(SECTOR_14_START_ADDR + addr);
+      if (zheshisha != 0U)
+      {
+        printf("%x\n\r" , zheshisha);
+      }
       
+      addr += 4;
+    }
+    printf("page %d du qu wan cheng\n\r",(368+j));
+    printf("zhe yi ge page de qi shi di zhi shi %x\n\r", dizhi);
+    dizhi += 0x100U;
+  }
   
+  printf("--------------- fen ge xian --------------------\n\r");
+  printf("--------------- fen ge xian --------------------\n\r");
+  printf("--------------- fen ge xian --------------------\n\r");
 
+  EEPROM_Read_Data(EEPROM_BLOCK_UDS_FLAG, koko,8);
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    printf("%x\n\r" , koko[i]);
+  }
+  printf("--------------- zhi xing jie shu --------------------\n\r");
+  printf("--------------- zai jian --------------------\n\r");
   while (1)
   {
   }
@@ -180,11 +256,16 @@ static void APP_SystemClockConfig(void)
 static void APP_FlashErase(void)
 {
   uint32_t PAGEError = 0;
+
+  uint32_t jojojo = 0U;
+
   FLASH_EraseInitTypeDef EraseInitStruct = {0};
 
   EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGEERASE;        /* Erase type FLASH_TYPEERASE_PAGEERASE=Page erase, FLASH_TYPEERASE_SECTORERASE=Sector Erase */
   EraseInitStruct.PageAddress = FLASH_USER_START_ADDR;            /* Erase Start Address */
   EraseInitStruct.NbPages  = sizeof(DATA) / FLASH_PAGE_SIZE;      /* Number of pages that need to be erased */
+  jojojo = sizeof(DATA) / FLASH_PAGE_SIZE;
+  printf("sizeof(DATA) / FLASH_PAGE_SIZE为：%x\n\r",jojojo);
   if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)  /* Executing page erasure, PAGEError returns the page with the erasure error and 0xFFFFFFFF, indicating successful erasure */
   {
     APP_ErrorHandler();