自学教程：C++ FLASH_ErasePage函数代码示例

/******************************************************************************** Function Name  : EE_Format* Description    : Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0* Input          : None* Output         : None* Return         : Status of the last operation (Flash write or erase) done during*                  EEPROM formating*******************************************************************************/FLASH_Status EE_Format(void){  FLASH_Status FlashStatus = FLASH_COMPLETE;  /* Erase Page0 */  FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);  /* 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_ErasePage(PAGE1_BASE_ADDRESS);  /* Return Page1 erase operation status */  return FlashStatus;}

/************************************************* Function:		hw_flash_erase Descroption:	  Input: 	1.SectorAddress Output:  Return: 	 Other:  *************************************************/uint32_t hw_flash_erase(uint32_t SectorAddress){	#if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS)	FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR);	return FLASH_ErasePage(SectorAddress);	#else	return FLASH_ErasePage(SectorAddress);	#endif /* STM32L1XX_XD */}

//================================================static void write_mem(void){	u32 addr = 0;	u16 i = 0;	u8 temp[4];	u16 length = 0; 	u32 data = 0;	u8 crc = 0;	FLASH_Status status = FLASH_COMPLETE;			// Receive start address	for(i=0;i<4;i++)		temp[i] = USART_GetC();	crc = USART_GetC();	if(crc == (temp[0]^temp[1]^temp[2]^temp[3]))	{		mem_cpy(&addr,temp,4);		USART_PutC(ACK);		length = USART_GetC();		length = (length<<8) | USART_GetC();		for(i = 0;i<length;i++)			fwBuff[i] = USART_GetC();		crc = USART_GetC();		// Write memmory		FLASH_UnlockBank1();		if(!fUpdating)		{			// Disable systick 			SysTick->CTRL  &=~( SysTick_CTRL_CLKSOURCE_Msk | 		                   SysTick_CTRL_TICKINT_Msk   | 		                   SysTick_CTRL_ENABLE_Msk);			status = FLASH_ErasePage(FLAG_ADDR);			if(status == FLASH_COMPLETE)				status = FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATING);			fUpdating = true;		}		if(status == FLASH_COMPLETE)			status = FLASH_ErasePage(addr);		for(i = 0;i<length;i+=4)		{			mem_cpy(&data,&fwBuff[i],((length-i)>4?4:(length-i)));			if(status != FLASH_COMPLETE)				break;			status = FLASH_ProgramWord(addr,data);						addr += 4;		}		FLASH_LockBank1();		if(status == FLASH_COMPLETE)			USART_PutC(ACK);		else			USART_PutC(NACK);	}	else		USART_PutC(NACK);}

/******************************************************************************** Function Name  : FLASH_If_Erase* Description    : Erase sector* Input          : None* Output         : None* Return         : None*******************************************************************************/uint16_t FLASH_If_Erase(uint32_t SectorAddress){#ifdef STM32L1XX_MD  FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR);  FLASH_ErasePage(SectorAddress);#else  FLASH_ErasePage(SectorAddress);#endif /* STM32L1XX_MD */    return MAL_OK;}

void Erase_All_User_id(void){	uint8_t i;	FLASH_Unlock();	FLASH_ErasePage(USER_ID_PAGE0_ADDR_START);	FLASH_ErasePage(USER_ID_PAGE1_ADDR_START);	FLASH_ErasePage(USER_ID_PAGE2_ADDR_START);	FLASH_Lock();	for(i=1; i<96; i++)		lock_infor.index_map[(i-1)/MAP_SIZE] &= (~(1<<((i-1)%MAP_SIZE)));	Index_Save();}

bool writeEEPROM(bool blink){    FLASH_Status status;    uint8_t chk = 0;    const uint8_t *p;    // prepare checksum/version constants    _params.version = EEPROM_CONF_VERSION;    _params.size = sizeof(params_t);    _params.magic_be = 0xBE;    _params.magic_ef = 0xEF;    _params.chk = 0;    // recalculate checksum before writing    for (p = (const uint8_t *)&_params; p < ((const uint8_t *)&_params + sizeof(params_t)); p++)        chk ^= *p;    _params.chk = chk;    // write it    FLASH_Unlock();    for (unsigned int tries = 3; tries; tries--)    {        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);        FLASH_ErasePage(FLASH_WRITE_ADDR);        status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE);        for (unsigned int i = 0; i < sizeof(params_t) && status == FLASH_COMPLETE; i += 4)            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&_params + i));        if (status == FLASH_COMPLETE)            break;    }    FLASH_Lock();    // Flash write failed - just die now    if (status != FLASH_COMPLETE || !validEEPROM())    {        return false;    }    if (blink)    {        for (uint8_t i=0; i < 3; i++)        {            LED0_TOGGLE;            delay(100);            LED0_TOGGLE;            delay(50);        }    }    return true;}

void writeEEPROM(uint8_t b, uint8_t updateProfile){    FLASH_Status status;    int i, tries = 3;    uint8_t chk = 0;    const uint8_t *p;    // prepare checksum/version constants    mcfg.version = EEPROM_CONF_VERSION;    mcfg.size = sizeof(master_t);    mcfg.magic_be = 0xBE;    mcfg.magic_ef = 0xEF;    mcfg.chk = 0;    // when updateProfile = true, we copy contents of cfg to global configuration. when false, only profile number is updated, and then that profile is loaded on readEEPROM()    if (updateProfile) {        // copy current in-memory profile to stored configuration        memcpy(&mcfg.profile[mcfg.current_profile], &cfg, sizeof(config_t));    }    // recalculate checksum before writing    for (p = (const uint8_t *)&mcfg; p < ((const uint8_t *)&mcfg + sizeof(master_t)); p++)        chk ^= *p;    mcfg.chk = chk;    // write it    FLASH_Unlock();    while (tries--) {        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);        FLASH_ErasePage(FLASH_WRITE_ADDR);        status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE);        for (i = 0; i < sizeof(master_t) && status == FLASH_COMPLETE; i += 4)            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&mcfg + i));        if (status == FLASH_COMPLETE)            break;    }    FLASH_Lock();    // Flash write failed - just die now    if (status != FLASH_COMPLETE || !validEEPROM()) {        failureMode(10);    }    // re-read written data    loadAndActivateConfig();    if (b)        blinkLED(15, 20, 1);}

/** * Erase data on flash. * @note This operation is irreversible. * @note This operation's units is different which on many chips. * * @param addr flash address * @param size erase bytes size * * @return result */EfErrCode ef_port_erase(uint32_t addr, size_t size) {    EfErrCode result = EF_NO_ERR;    FLASH_Status flash_status;    size_t erase_pages, i;        /* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */    EF_ASSERT(addr % ERASE_MIN_SIZE == 0);        /* calculate pages */    erase_pages = size / PAGE_SIZE;    if (size % PAGE_SIZE != 0) {        erase_pages++;    }    /* start erase */    FLASH_Unlock();    FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);    for (i = 0; i < erase_pages; i++) {        flash_status = FLASH_ErasePage(addr + (PAGE_SIZE * i));        if (flash_status != FLASH_COMPLETE) {            result = EF_ERASE_ERR;            break;        }    }    FLASH_Lock();    return result;}

/*********************************************************** * 函数名：WriteflashMPeriod * 描述  ：把interval_s从CPU写入Flash * 输入  : 无 * 输出  : 无 ***********************************************************/void WriteflashMPeriod(void){	FLASHStatus = FLASH_COMPLETE;	MemoryProgramStatus = PASSED; 	FLASH_Unlock();	//FLASH解锁	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位	NbrOfPage = (EndAddr[4] - StartAddr[4]) / FLASH_PAGE_SIZE;//页面擦除子程序	FLASHStatus = FLASH_ErasePage(StartAddr[4] + (FLASH_PAGE_SIZE * NbrOfPage)); 		FlashAddress = StartAddr[4]; 	FLASHStatus = FLASH_ProgramWord(FlashAddress, gps_invalid);		FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalA);		FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalB);		FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, interval_num);		FlashAddress = FlashAddress + 4;//	FLASHStatus = FLASH_ProgramWord(FlashAddress, time_o);		FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramHalfWord(FlashAddress, interval_s);	BKP_WriteBackupRegister(BKP_DR1,interval_num);	//BKP_WriteBackupRegister(BKP_DR2,time_o);	BKP_WriteBackupRegister(BKP_DR3,interval_s);}

void ErasePage(uint32_t p_addr, unsigned char with_lock){	FLASH_Unlock();	FLASH_ErasePage(p_addr);	if (with_lock)		FLASH_Lock();}

uint8_t PIOS_BL_HELPER_FLASH_Start(){	const struct pios_board_info * bdinfo = &pios_board_info_blob;	uint32_t pageAdress = bdinfo->fw_base;	uint8_t fail = false;	while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size))	       && (fail == false)) {		for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {			if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {				fail = false;				break;			} else {				fail = true;			}		}#ifdef STM32F10X_HD		pageAdress += 2048;#elif defined (STM32F10X_MD)		pageAdress += 1024;#endif	}	return (fail == true) ? 0 : 1;}

//----清除全部刷卡记录-----------------------------------------------------void clear_CardID(){	 char DateSt[12], TimeSt[12];	storeaddrlist.RecordCount = 0;	storeaddrlist.CountAddrOffset = 0;	timeoutaddrlist.RecordCount = 0;	timeoutaddrlist.CountAddrOffset = 0;	LastSaveTime = GetRTC(DateSt, TimeSt);///获取当前时间，秒数 //需要优化;	//清除记录区  	FLASH_Unlock();  	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	FLASH_ErasePage(PLACELASTID); 	FLASH_ErasePage(POINTOFSECTION);     	FLASH_Lock();}

uint8_t FLASH_Start(){	uint32_t pageAdress;	pageAdress = START_OF_USER_CODE;	uint8_t fail = FALSE;	while ((pageAdress < START_OF_USER_CODE + SIZE_OF_CODE + SIZE_OF_DESCRIPTION)	       || (fail == TRUE)) {		for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {			if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {				fail = FALSE;				break;			} else {				fail = TRUE;			}		}#ifdef STM32F10X_HD		pageAdress += 2048;#elif defined (STM32F10X_MD)		pageAdress += 1024;#endif	}	return (fail == TRUE) ? 0 : 1;}

WORD EE_WriteVariable(WORD offset, WORD newValue){    FLASH_Status stat = FLASH_COMPLETE;    volatile WORD *pCurrentValue =   (__IO uint16_t*) (PAGE0_BASE_ADDRESS + 2 + (offset * 2));    WORD PageStatus0             = *((__IO uint16_t*)  PAGE0_BASE_ADDRESS);    WORD currentValue            = *pCurrentValue;    // first check is page is valid, and if the value did change    if(PageStatus0 == VALID_PAGE && (currentValue == newValue)) {   // page is valid, value didn't change? Good, quit        return FLASH_COMPLETE;    }    // if we got here, then either page is not valid, or the value changed    FLASH_Unlock();    FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);     stat = FLASH_ErasePage(PAGE0_BASE_ADDRESS);                         // erase page    if(stat != FLASH_COMPLETE) {        return stat;    }        stat = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);       // write VALID_PAGE marker    if(stat != FLASH_COMPLETE) {        return stat;    }    stat = FLASH_ProgramHalfWord((uint32_t) pCurrentValue, newValue);   // wite new vale    if(stat != FLASH_COMPLETE) {        return stat;    }    FLASH_Lock();    return stat;}

uint8_t PIOS_BL_HELPER_FLASH_Start(){    const struct pios_board_info * bdinfo = &pios_board_info_blob;    uint32_t pageAdress = bdinfo->fw_base;    uint8_t fail = FALSE;    while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size))            || (fail == TRUE)) {        for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {            if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {                fail = FALSE;                break;            } else {                fail = TRUE;            }        }#ifdef STM32F10X_HD        pageAdress += 2048;#else /* everything else */        pageAdress += 1024;#endif    }    return (fail == TRUE) ? 0 : 1;}

/*************************** Function : Erase the internal Flash data Input :- start address	- Number of page Output: return the FLASH status ***************************/ u16 Flash_EEPROM_ErasePage( u32 Start_Address, u16 No_of_Size) {   FLASH_Unlock();   FLASHStatus=FLASH_COMPLETE;   FLASH_EEPROM_ProgramStatus= PASSED;   Flash_EEPROM_Nb_Of_Page= No_of_Size; //   /*Clear all the flash */   FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR | FLASH_FLAG_OPTERR);   /*erase the page*/   for(EraseCounter=0; EraseCounter<Flash_EEPROM_Nb_Of_Page; EraseCounter++)   {     FLASHStatus = FLASH_ErasePage(Start_Address +(FL_EEPROM_PageSize* EraseCounter));     if (FLASHStatus != FLASH_COMPLETE)     {       return FLASHStatus;     }   }   FLASH_Lock();   return FLASHStatus; } 

//写多个数据到一个页u8 STMFLASH_Write(u32 PageAddr,u16 *pBuffer,u16 NumToWrite)	{		FLASH_Status temp_status;//状态	u16 i;		FLASH_Unlock();//解锁		temp_status = FLASH_ErasePage(PageAddr);//擦除一个页	if(temp_status != FLASH_COMPLETE)	{		FLASH_Lock();		return 0;	}		for(i=0;i<NumToWrite;i++)//数据写入	{		temp_status = FLASH_ProgramHalfWord(PageAddr+2*i,pBuffer[i]);		if(temp_status != FLASH_COMPLETE)		{			FLASH_Lock();			return 0;		}	}		FLASH_Lock();//上锁	return 1;}

int StoreApInfo(){	rtw_wifi_config_t wifi_config;	uint32_t address;#ifdef STM32F10X_XL	address = 0x08080000;	//bank2 domain#else	uint16_t sector_nb = FLASH_Sector_11;	address = flash_SectorAddress(sector_nb);#endif	wifi_config.boot_mode = 0x77665502;	memcpy(wifi_config.ssid, wifi_setting.ssid, strlen((char*)wifi_setting.ssid));	wifi_config.ssid_len = strlen((char*)wifi_setting.ssid);	wifi_config.security_type = wifi_setting.security_type;	memcpy(wifi_config.password, wifi_setting.password, strlen((char*)wifi_setting.password));	wifi_config.password_len= strlen((char*)wifi_setting.password);	wifi_config.channel = wifi_setting.channel;	printf("/n/rWritting boot mode 0x77665502 and Wi-Fi setting to flash ...");#ifdef STM32F10X_XL	FLASH_ErasePage(address);#else	flash_EraseSector(sector_nb);#endif	flash_Wrtie(address, (char *)&wifi_config, sizeof(rtw_wifi_config_t));	return 0;}

//=====================================void saveFont(u32 addr,u8* fontData,u16 length){	u32 i = 0;	u32 addr_temp;	u32 data_temp = 0;	FLASH_Status status = FLASH_COMPLETE;	addr_temp = addr;	// Unlock flash to rewrite to flash	FLASH_UnlockBank1();	// Erase pages used to store font	for(i = 0;i<3;i++)	{		status = FLASH_ErasePage(addr_temp);		addr_temp += FLASH_PAGE_SIZE;	}		// Write font data to flash	for(i = 0;i<length;i+=4)	{		memcpy(&data_temp,&fontData[i],((length-i)>4?4:(length-i)));		status = FLASH_ProgramWord(addr,data_temp);		addr += sizeof(u32);	}	FLASH_LockBank1();}

int write_whole_poweroff_info_tbl(struct poweroff_info_st *data){	u32 *ps, *pd;	int i;	FLASH_Status status;	if (NULL == data)		return -RT_ERROR;	FLASH_Unlock();	/* Clear pending flags (if any) */	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPTERR | FLASH_FLAG_WRPRTERR |					FLASH_FLAG_PGERR | FLASH_FLAG_BSY);	status = FLASH_ErasePage((rt_uint32_t)POWEROFF_INFO_TBL_BASE_OF_FLASH); /* wait for complete in FLASH_ErasePage() */	if (FLASH_COMPLETE != status)		while(1); //return status;	ps = (u32 *)data;	pd = (u32 *)POWEROFF_INFO_TBL_BASE_OF_FLASH;	for (i=0; i < RT_ALIGN(POWEROFF_INFO_TBL_SIZE_OF_FLASH, 4)/4; i++) {		status = FLASH_ProgramWord((u32)pd, *ps); /* wait for complete in FLASH_ProgramWord()  */		if (FLASH_COMPLETE != status)			while(1); //return status;		++pd;		++ps;	}	FLASH_Lock();	return FLASH_COMPLETE;}

/*********************************************************** * 函数名：Write_GPS_Info * 描述  ：把GPS信息从CPU写入Flash * 输入  : 无 * 输出  : 无 ***********************************************************/void Write_Flash_GPS_Info(void){	FLASHStatus = FLASH_COMPLETE;	MemoryProgramStatus = PASSED;	FLASH_Unlock();	//FLASH解锁	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位		NbrOfPage = (EndAddr[10] - StartAddr[10]) / FLASH_PAGE_SIZE; //页面擦除子程序	FLASHStatus = FLASH_ErasePage(StartAddr[10] + (FLASH_PAGE_SIZE * NbrOfPage));	FlashAddress = StartAddr[10];	FLASHStatus = FLASH_ProgramWord(FlashAddress, jingdu);	FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, weidu);	FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, sog);	FlashAddress = FlashAddress + 4;	FLASHStatus = FLASH_ProgramWord(FlashAddress, direction);		BKP_WriteBackupRegister(BKP_DR4,(u16)(jingdu >> 16));	BKP_WriteBackupRegister(BKP_DR5,(u16)(weidu >> 16));	BKP_WriteBackupRegister(BKP_DR7,(u16)jingdu);	BKP_WriteBackupRegister(BKP_DR8,(u16)weidu);	BKP_WriteBackupRegister(BKP_DR9,sog);	BKP_WriteBackupRegister(BKP_DR10,direction);}

/**  * @brief   Main program  * @param  None  * @retval None  */int main(void){		RCC_Configuration();	GPIO_Configuration();	USART_Configuration();		SysTick_Config(SystemCoreClock/10);	// Enable the LSI OSC  	RCC_LSICmd(ENABLE);	// Wait till LSI is ready 	while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {};	 	IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);	// IWDG counter clock: LSI/256 	IWDG_SetPrescaler(IWDG_Prescaler_256);	IWDG_SetReload(0x0FFF);	// Reload IWDG counter 	IWDG_ReloadCounter();	// Enable IWDG (the LSI oscillator will be enabled by hardware) 	IWDG_Enable(); 		// Write memmory	FLASH_UnlockBank1();	FLASH_ErasePage(FLAG_ADDR);	FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATED);	FLASH_LockBank1();		updateFW_control();}

void cmd_page_erase(){	int adrs=BSWAP32(PacketFromPC.adrs);	if( check_flash_adrs(adrs)) {		FLASH_ErasePage(adrs);	}}

/******************************************************************************** Function Name  : FLASH_If_Erase* Description    : Erase sector* Input          : None* Output         : None* Return         : None*******************************************************************************/uint16_t FLASH_If_Erase(uint32_t Add){  /* Unlock the internal flash */  FLASH_Unlock();  FLASH_ClearFlags();#if defined (STM32F2XX) || defined (STM32F4XX)  /* Disable sector write protection if it's already protected */  uint16_t OB_WRP_Sector = FLASH_SectorToWriteProtect(FLASH_INTERNAL, Add);  FLASH_WriteProtection_Disable(OB_WRP_Sector);  /* Check which sector has to be erased */  uint16_t FLASH_Sector = FLASH_SectorToErase(FLASH_INTERNAL, Add);  FLASH_Status status = FLASH_EraseSector(FLASH_Sector, VoltageRange_3);#elif defined(STM32F10X_CL)  /* Call the standard Flash erase function */  FLASH_ErasePage(Add);#endif /* STM32F2XX */  /* Lock the internal flash */  FLASH_Lock();  if (status != FLASH_COMPLETE) return MAL_FAIL;  return MAL_OK;}

Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length){	Fls_AddressType pageStart = 0;	Fls_AddressType erased = 0;	u32 page = 0;	u32 pageIndex;	/* Unlock the Flash Program Erase controller */	FLASH_Unlock();	/* Clear All pending flags */	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	/* Find first sector. */	page = (TargetAddress - flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress) / flsConfigPtr->FlsSectorList[0].FlsPageSize;	pageStart = flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress + page * flsConfigPtr->FlsSectorList[0].FlsPageSize;	//page = Length / flsConfigPtr->FlsSectorList[0].FlsPageSize;	/* Erase the pages... */	for (pageIndex = page; erased < Length; pageIndex++)	{		volatile FLASH_Status status = FLASH_BUSY;		while(status != FLASH_COMPLETE){			status = FLASH_ErasePage((uint32_t)pageStart);		}		erased += flsConfigPtr->FlsSectorList[0].FlsPageSize;		pageStart += flsConfigPtr->FlsSectorList[0].FlsPageSize;	}	return E_OK;}

static int32_t PIOS_Flash_Internal_EraseSector(uintptr_t flash_id, uint32_t addr){	struct pios_internal_flash_dev * flash_dev = (struct pios_internal_flash_dev *)flash_id;	if (!PIOS_Flash_Internal_Validate(flash_dev))		return -1;#if defined(PIOS_INCLUDE_WDG)	PIOS_WDG_Clear();#endif	uint32_t sector_start;	uint32_t sector_size;	if (!PIOS_Flash_Internal_GetSectorInfo(addr,						&sector_start,						&sector_size)) {		/* We're asking for an invalid flash address */		return -2;	}	FLASH_Status ret = FLASH_ErasePage(sector_start);	if (ret != FLASH_COMPLETE)		return -3;	return 0;}

void writeParams(uint8_t b){    FLASH_Status status;    uint32_t i;    uint8_t chk = 0;    const uint8_t *p;    cfg.version    = EEPROM_CONF_VERSION;    cfg.size       = sizeof(config_t);    cfg.magic_be   = 0xBE;    cfg.magic_ef   = 0xEF;    cfg.chk        = 0;    for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); p++) chk ^= *p; // recalculate checksum before writing    cfg.chk = chk;    FLASH_Unlock();                                                                       // write it    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);      for (i = 0; i < FLASH_PAGES_FORCONFIG; i++)                                           // Erase the pages here    {        while (FLASH_ErasePage(FLASH_WRITE_ADDR + (i * FLASH_PAGE_SIZE)) != FLASH_COMPLETE);    }    for (i = 0; i < sizeof(config_t); i += 4)                                             // Write that config now.    {        status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *) ((char *) &cfg + i));        if (status != FLASH_COMPLETE) break;                                              // TODO: fail    }    FLASH_Lock();    readEEPROM();    if (b) blinkLED(15, 20, 1);}

void writeParams(void){    FLASH_Status status;    uint32_t i;    uint8_t chk = 0;    const uint8_t *p;        cfg.version = EEPROM_CONF_VERSION;    cfg.size = sizeof(config_t);    cfg.magic_be = 0xBE;    cfg.magic_ef = 0xEF;    cfg.chk = 0;    // recalculate checksum before writing    for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); ++p)        chk ^= *p;    cfg.chk = chk;        // write it    FLASH_Unlock();    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);    if (FLASH_ErasePage(FLASH_WRITE_ADDR) == FLASH_COMPLETE) {        for (i = 0; i < sizeof(config_t); i += 4) {            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&cfg + i));            if (status != FLASH_COMPLETE)                while(1);//break; // TODO: fail        }    }    FLASH_Lock();    readEEPROM();}

void Erase_All_id(void){		uint8_t i;		FLASH_Unlock();	FLASH_ErasePage(USER_ID_PAGE0_ADDR_START);	FLASH_ErasePage(USER_ID_PAGE1_ADDR_START);	FLASH_ErasePage(USER_ID_PAGE2_ADDR_START);	FLASH_ErasePage(ADMIN_ID_PAGE4_ADDR_START);	FLASH_Lock();		lock_infor.work_mode = NORMAL;	for(i=0; i<4; i++)		lock_infor.index_map[i]=0;	Index_Save();}

// write to a specified page in flash// page_addr: the page address that write tovoid write_embedded_flash_with_addr_len(uint32_t page_addr, uint8_t *buf, uint16_t len) {	uint32_t saddr = page_addr;			// start address for the page to write	uint32_t eaddr = saddr+len;	// end addrees for that page	uint32_t *pbuf = (uint32_t*)buf;	// Unlock the Flash Program Erase controller	FLASH_Unlock();	// Clear All pending flags 	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_SIZERR);	// Erase the FLASH pages 	FLASHStatus = FLASH_ErasePage(saddr);		// write buf to that page	while((saddr < eaddr) && (FLASHStatus == FLASH_COMPLETE)) {		FLASHStatus = FLASH_FastProgramWord(saddr, *(pbuf));	//problem		saddr = saddr + 4;		pbuf++;	}	if (FLASHStatus != FLASH_COMPLETE) {		HardFault_Handler();//enter_unexpected();  do something here;	}	// Lock flash	FLASH_Lock();}