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

/******************************************************************************************************* * *         函数名称:  * *         函数功能:  * *         入口参数:  * *         出口参数: 无 * *             说明: * *******************************************************************************************************/void FlashWRDPUnlock(void){    uint32_t rt;    FlagStatus   RDP_state;    FLASH_Status Flash_state;    uint32_t     optcr_byte;    //如果匹配，进行Flash的读写解锁    FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);     FLASH_Unlock();    FLASH_OB_Unlock();    FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);     rt = FLASH_OB_GetWRP();        do    {        //FlashWRPLock(WRITE, WRP_Sector_All);        FLASH_OB_WRPConfig(WRP_Sector_All, DISABLE); //开启写保护    }while(FLASH_OB_Launch() != FLASH_COMPLETE);        rt = FLASH_OB_GetWRP();        RDP_state = FLASH_OB_GetRDP();    do    {        FLASH_OB_RDPConfig(OB_RDP_Level_0);//关闭读保护    }while(FLASH_OB_Launch() != FLASH_COMPLETE);        RDP_state = FLASH_OB_GetRDP();        FLASH_OB_Lock();    FLASH_Lock();    }

bool writeEEPROM(void){    // Generate compile time error if the config does not fit in the reserved area of flash.    BUILD_BUG_ON(sizeof(master_t) > FLASH_TO_RESERVE_FOR_CONFIG);    FLASH_Status status = 0;    uint32_t wordOffset;    int8_t attemptsRemaining = 3;    bool changed;    // prepare checksum/version constants    masterConfig.version = EEPROM_CONF_VERSION;    masterConfig.size = sizeof(master_t);    masterConfig.magic_be = 0xBE;    masterConfig.magic_ef = 0xEF;    masterConfig.chk = 0; // erase checksum before recalculating    masterConfig.chk = calculateChecksum((const uint8_t *) &masterConfig, sizeof(master_t));    changed = (memcmp((const master_t *)CONFIG_START_FLASH_ADDRESS, &masterConfig, sizeof(master_t)) != 0);    // write it    if(changed) {      FLASH_Unlock();      while (attemptsRemaining--) {#ifdef STM32F303        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);#endif#ifdef STM32F10X          FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);#endif          for (wordOffset = 0; wordOffset < sizeof(master_t); wordOffset += 4) {              if (wordOffset % FLASH_PAGE_SIZE == 0) {                  status = FLASH_ErasePage(CONFIG_START_FLASH_ADDRESS + wordOffset);                  if (status != FLASH_COMPLETE) {                      break;                  }              }              status = FLASH_ProgramWord(CONFIG_START_FLASH_ADDRESS + wordOffset,                      *(uint32_t *) ((char *) &masterConfig + wordOffset));              if (status != FLASH_COMPLETE) {                  break;              }          }          if (status == FLASH_COMPLETE) {              break;          }      }      FLASH_Lock();      // Flash write failed - just die now      if (status != FLASH_COMPLETE || !isEEPROMContentValid()) {          failureMode(10);      }    }    return changed;}

// Initialise EEPROM hardwarevoid eeprom_init_hw(void){  // unlock flash  FLASH_Unlock();  // Clear Flags  FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);    uint8_t mirror;  uint16_t page;  uint32_t addr;    // Read pages status  eFEE_STATUS pages_status[FEE_MIRROR_NUMBER];  eFEE_STATUS status;    for(page = 0; page < FEE_SECTORS; page++)  {    fee_pages_map[page] = 0xFF;    for(mirror = 0; mirror < FEE_MIRROR_NUMBER; mirror++)    {      addr = FEE_BASE_ADDRESS + FEE_EEPROM_SIZE * mirror + FEE_SECTOR_SIZE * page;      status = *(uint16_t *)(addr);      pages_status[mirror] = status;            if((status == eFEE_PAGE_VALID) && (fee_pages_map[page] == 0xFF))      {        fee_pages_map[page] = mirror;      }      else if(status != eFEE_PAGE_ERASED)      {        if(FLASH_ErasePage(addr) == FLASH_COMPLETE)          pages_status[mirror] = eFEE_PAGE_ERASED;        else        {          FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);          pages_status[mirror] = eFEE_PAGE_INVALID;        }      }    }    if(fee_pages_map[page] == 0xFF) //  No Valid mirror      for(mirror = 0; mirror < FEE_MIRROR_NUMBER; mirror++)      {        if(pages_status[mirror] == eFEE_PAGE_ERASED)        {          addr = FEE_BASE_ADDRESS + FEE_EEPROM_SIZE * mirror + FEE_SECTOR_SIZE * page;          if(FLASH_ProgramHalfWord(addr, eFEE_PAGE_VALID) == FLASH_COMPLETE)          {            fee_pages_map[page] = mirror;            break;          }          else            FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);        }      }  }}

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

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;}

u8* bsp_Firmware_Write(u8* writebuffer,u32 writeaddress,u16 writelength){			u8 status=0;	u16 index=0;	SleepTime=0;  FLASH_Unlock();									//解锁   FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存 	FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR|  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);	   __set_PRIMASK(1);  		  for(index=0;index<writelength;index++)		{			status=FLASH_ProgramByte(writeaddress+index,writebuffer[index]);  		}   __set_PRIMASK(0);  	  FLASH_DataCacheCmd(ENABLE);	//FLASH擦除结束,开启数据缓存	FLASH_Lock();//上锁		if(status==FLASH_COMPLETE)	{		MCU_WriteStatus=0;	}	else	{		MCU_WriteStatus=status;	}	return &MCU_WriteStatus;		}

int write_flash(uint32_t addr, uint8_t *data, uint32_t data_len){	FLASH_Status FLASHStatus = FLASH_COMPLETE;	int rep = 0, i;	uint32_t tmp;	__disable_irq();	rep = (data_len / 4);	if(data_len % 4)		rep++;	FLASH_Unlock();	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);		for(i = 0 ; i < rep ; i++) {		tmp = *((uint32_t *)data + i);		FLASHStatus = FLASH_ProgramWord(addr, tmp);		if(FLASHStatus != FLASH_COMPLETE) {			myprintf("FLASH_ProgramWord Error/r/n");			return -1;		}		addr += 4;	}	FLASH_Lock();	__enable_irq();	return data_len;}

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

void writeFlash(u8 address_num,u32 data) //address_num should start from 0 up to 255 {const u8 data_count=255;	 	 u32 flash_data[data_count];	 	 for (u8 i = 0; i < data_count; ++i) {			flash_data[i] = readFlash(i);		}				flash_data[address_num] = data;	 	  FLASH_Unlock();// you need to unlcok flash first /* Clear All pending flags */ FLASH_ClearFlag( FLASH_FLAG_EOP |  FLASH_FLAG_WRPERR |  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);//you need to erase entire sector before write anything FLASH_EraseSector(FLASH_Sector_11, VoltageRange_3); //VoltageRange_3        ((uint8_t)0x02)  /*!<Device operating range: 2.7V to 3.6V */		for (u8 i = 0; i < data_count; ++i) {   //write back the whole sector memory				FLASH_ProgramWord((u32)(startAddress + i * 4), flash_data[i]);		} FLASH_Lock();//lock flash at the end}

uint16_t flash_helper_write_new_app_data(uint32_t offset, uint8_t *data, uint32_t len) {	FLASH_Unlock();	FLASH_ClearFlag(FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |			FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);	mc_interface_unlock();	mc_interface_release_motor();	utils_sys_lock_cnt();	timeout_configure_IWDT_slowest();	for (uint32_t i = 0;i < len;i++) {		uint16_t res = FLASH_ProgramByte(flash_addr[NEW_APP_BASE] + offset + i, data[i]);		if (res != FLASH_COMPLETE) {			FLASH_Lock();			return res;		}	}	FLASH_Lock();	timeout_configure_IWDT();	utils_sys_unlock_cnt();	return FLASH_COMPLETE;}

uint16_t flash_helper_erase_new_app(uint32_t new_app_size) {	FLASH_Unlock();	FLASH_ClearFlag(FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |			FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);	new_app_size += flash_addr[NEW_APP_BASE];	mcpwm_unlock();	mcpwm_release_motor();	utils_sys_lock_cnt();	RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, DISABLE);	for (int i = 0;i < NEW_APP_SECTORS;i++) {		if (new_app_size > flash_addr[NEW_APP_BASE + i]) {			uint16_t res = FLASH_EraseSector(flash_sector[NEW_APP_BASE + i], VoltageRange_3);			if (res != FLASH_COMPLETE) {				return res;			}		} else {			break;		}	}	RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);	utils_sys_unlock_cnt();	return FLASH_COMPLETE;}

void flash_inside_write(void* address,void* data,long length) {    char old_data[2]={0};    int  old_data_int=0;     long the_last=length-1;    if (!is_valid_address(address)) return;        FLASH_Unlock();    if ((long)address%2!=0) {        flash_inside_read((void*)((long)address-1),old_data,2);        old_data[1]=*(char*)data;        memcpy(&old_data_int,old_data,sizeof(int));        FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address-1),old_data_int);        --length;    }    for (;length>1;length-=2)        FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+length-2),*(uint16_t*)((long)data+length-2));    if (length) {        flash_inside_read((void*)((long)address+the_last),old_data,2);        old_data[0]=*(char*)((long)data+the_last);        memcpy(&old_data_int,old_data,sizeof(int));        FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+the_last),old_data_int);    }    FLASH_Lock();    FLASH_ClearFlag(FLASH_FLAG_BSY|FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);}

int flashAddress(uint32_t startAddr, uint32_t *data, uint32_t len) {    FLASH_Status status;    int retries;    int ret = 1;    int i;    FLASH_Unlock();    // Clear pending flags (if any)    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);    for (i = 0; i < len; i++) {        retries = 0;        do {            status = FLASH_ProgramWord(startAddr + i*4, *(data + i));            retries++;        } while (status != FLASH_COMPLETE && retries < FLASH_RETRIES);        if (retries == FLASH_RETRIES) {            ret = 0;            break;        }    }    FLASH_Lock();    return ret;}

mal_error_e mal_flash_write_uint32_values(unsigned int start_address, uint32_t *values, uint32_t count) {	FLASH_Status result = FLASH_BUSY;	// Unlock flash registers	FLASH_Unlock();	// Clear pending flags	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);	// Write values	uint32_t i;	uint32_t address = start_address;	for (i = 0; i < count; i++) {		// Write data		result = FLASH_ProgramWord(address, values[i]);		if (FLASH_COMPLETE != result) {			// We stop at first sign of error			break;		}		// Increment address		address += sizeof(uint32_t);	}	// Lock flash registers	FLASH_Lock();	// Return result	if (FLASH_COMPLETE != result) {		return MAL_ERROR_MEMORY;	}	return MAL_ERROR_OK;}

// write data to FLASH, only within 1 page.static bool fee_write_page(uint32_t fee_addr, uint32_t len, uint8_t *pData){  uint16_t din, dout;  for(; len > 0; len--)  {    din = (uint16_t)(*(pData++)) | 0xFF00;    dout = *(uint16_t *)(fee_addr);    if(din != dout)    {      if(dout != 0xFFFF)        return false;      if(FLASH_ProgramHalfWord(fee_addr, din) != FLASH_COMPLETE)      {        FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);        return false;      }    }    fee_addr += 2;  }  return true;}

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();}

// 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();}

//**************************************************************************void eeprom_erase(void){  DATA_EEPROM_Unlock(); // разблокировка перед записью    /* Clear all pending flags */        FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR                  | FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);	    /*  Data EEPROM Fast Word program of FAST_DATA_32 at addresses defined by   DATA_EEPROM_START_ADDR and DATA_EEPROM_END_ADDR */    Address = DATA_EEPROM_START_ADDR;    NbrOfPage = ((DATA_EEPROM_END_ADDR - Address) + 1 ) >> 2;     /* Erase the Data EEPROM Memory pages by Word (32-bit) */  for(j = 0; j < NbrOfPage; j++)  {    FLASHStatus = DATA_EEPROM_EraseWord(Address + (4 * j));  }  DATA_EEPROM_Lock();    /* Check the correctness of written data */  while(Address < DATA_EEPROM_END_ADDR)  {    if(*(__IO uint32_t*)Address != 0x0)    {      DataMemoryProgramStatus = FAILED;      //ОШИБКА стирания !!!!      return;    }    Address = Address + 4;  }  }

uint16_t flash_helper_erase_new_app(uint32_t new_app_size) {	FLASH_Unlock();	FLASH_ClearFlag(FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |			FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);	new_app_size += flash_addr[NEW_APP_BASE];	mc_interface_unlock();	mc_interface_release_motor();	utils_sys_lock_cnt();	timeout_configure_IWDT_slowest();	for (int i = 0;i < NEW_APP_SECTORS;i++) {		if (new_app_size > flash_addr[NEW_APP_BASE + i]) {			uint16_t res = FLASH_EraseSector(flash_sector[NEW_APP_BASE + i], VoltageRange_3);			if (res != FLASH_COMPLETE) {				FLASH_Lock();				return res;			}		} else {			break;		}	}	FLASH_Lock();	timeout_configure_IWDT();	utils_sys_unlock_cnt();	return FLASH_COMPLETE;}

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;}

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);}

/*********************************************************** * 函数名：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);}

//External Functionsvoid arch_IntfInit(){	FLASH_Unlock();    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |                   FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);}

bool HardwareEEPROM::put(char * src, size_t size){    FLASH_Status status = (FLASH_Status)0;    FLASH_Unlock();    for (unsigned int tries = 3; tries; tries--) {        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);        status = FLASH_COMPLETE;        for (size_t i=0; i<size && status==FLASH_COMPLETE; i+=2) {            uint16_t datum = 0;            memcpy(&datum, &src[i], (i+2>size)?1:2); // handle odd-length data            status = FLASH_ProgramHalfWord(FLASH_WRITE_ADDR+i, datum);        }        if (status == FLASH_COMPLETE)            break;    }    FLASH_Lock();    return status == FLASH_COMPLETE;}

/*********************************************************** * 函数名：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 SD_TEST(void)//{//	u8 res;//	UINT bw,index;//	res=f_mount( &fatfs_SDCARD,"0:/",1 );//	res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING|FA_WRITE|FA_READ);//	res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);//	res=f_close(&file_sdif);//	res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING |FA_WRITE);//	res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);//	res=f_close(&file_sdif);//	res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING | FA_READ);//	index=0;//	while(SDTEST_ReadBuffer[31]!=0x04)//	{//		index++;//		res=f_read(&file_sdif,SDTEST_ReadBuffer,512,&bw);//	}//	f_close(&file_sdif);      //	//	//}u8 bsp_ChangeAPPtoRun(u8 App_Select){  u8 status=0;	u8 Flash_status=0;	FLASH_Unlock();									//解锁   FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存 	FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR|  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);	status=FLASH_EraseSector(FLASH_Sector_3 ,VoltageRange_3);//VCC=2.7~3.6V之间!!	if(status==FLASH_COMPLETE)	{   __set_PRIMASK(1);  	status=FLASH_ProgramByte(App_ToRun_Flag,App_Select);  //SysID   __set_PRIMASK(0);  	}  FLASH_DataCacheCmd(ENABLE);	//FLASH擦除结束,开启数据缓存	FLASH_Lock();//上锁		if(status==FLASH_COMPLETE)	{		Flash_status=0;	}	else	{		Flash_status=status;	}	return Flash_status;		}

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;}

unsigned char flash_write_operate_nocheckcomplete(u32 Address,u16 * buff,u32 len){  volatile FLASH_Status FLASHStatus;  u32 Temp_Addr;  FLASHStatus = FLASH_COMPLETE;  if(len%2) return WR_LEN_ERR;  if(Address%2) return WR_ADDRESS_ERR;  if( Address<StartAddr || Address+len>EndAddr ) return ADDRESS_LEN_ERR;    //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);  Temp_Addr=Address+len;    while((Address < Temp_Addr) )  {    FLASHStatus = FLASH_ProgramHalfWord(Address, *buff);    Address = Address + 2;    buff++;  }    FLASH_Lock();    if( FLASHStatus==FLASH_COMPLETE ) return FLASH_OP_OK;  else    return FLASHStatus;}

void Internal_EE_Write8(uint16_t position, uint8_t data){	DATA_EEPROM_Unlock();	FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR                  | FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);		DATA_EEPROM_ProgramByte(INTERNAL_8BIT_START_ADDRESS+position, data);	DATA_EEPROM_Lock();}

/* * NOTE:write flash is a slow process */static int write_whole_syscfgdata_tbl(struct syscfgdata_tbl *data){	unsigned char *page_addr;	unsigned char *data_page;	u32 all_data_len;	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);	page_addr	= (unsigned char *)SYSCFGDATA_TBL_BASE_OF_FLASH;	data_page	= (unsigned char *)data;	all_data_len	= SYSCFGDATA_TBL_SIZE_OF_FLASH;	while (all_data_len > 0) {		if (all_data_len > SIZE_PER_FLASH_PAGE) {			do_write_flash_page(page_addr, data_page, SIZE_PER_FLASH_PAGE);			page_addr += SIZE_PER_FLASH_PAGE;			data_page += SIZE_PER_FLASH_PAGE;			all_data_len -= SIZE_PER_FLASH_PAGE;		} else {			do_write_flash_page(page_addr, data, RT_ALIGN(all_data_len, 4));			all_data_len = 0;			break;		}	}	FLASH_Lock();	return FLASH_COMPLETE;}