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

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

static intstm32f3_flash_write(uint32_t address, const void *src, uint32_t len){    FLASH_Status rc;    int num_half_words;    int i;    uint16_t *src16 = (uint16_t *)src;    if (address % sizeof(uint16_t)) {        /*         * Unaligned write.         */        return -1;    }    num_half_words = len / 2;    for (i = 0; i < num_half_words; i++) {        rc = FLASH_ProgramHalfWord(address, src16[i]);        if (rc != FLASH_COMPLETE) {            goto err;        }        address += 2;    }    if (num_half_words * 2 != len) {        rc = FLASH_ProgramHalfWord(address, ((uint8_t *)src)[len] << 8);        if (rc != FLASH_COMPLETE) {            goto err;        }    }    return 0;err:    return -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;}

static int32_t PIOS_Flash_Internal_WriteData(uintptr_t chip_id, uint32_t chip_offset, const uint8_t *data, uint16_t len){	PIOS_Assert(data);	PIOS_Assert((chip_offset & 0x0001) == 0)	struct pios_internal_flash_dev *flash_dev = (struct pios_internal_flash_dev *)chip_id;	if (!PIOS_Flash_Internal_Validate(flash_dev))		return -1;	/* Write the data */	for (uint16_t i = 0; i < (len & ~1); i += 2) {		/* Check if content has been changed prior to write.		 * This should enhance performance and make this compatible with the F3 chip.		 */		uint8_t temp[2];		if (PIOS_Flash_Internal_ReadData(chip_id, chip_offset + i, temp, sizeof(temp)) != 0)			return -4;		if (temp[0] == data[i] && temp[1] == data[i + 1])			continue;		FLASH_Status status;		status = FLASH_ProgramHalfWord(FLASH_BASE + chip_offset + i, data[i + 1] << 8 | data[i]);		PIOS_Assert(status == FLASH_COMPLETE);	}	/* Handle uneven writes by filling up with 0xff*/	if ((len & 1) != 0) {		FLASH_Status status;		status = FLASH_ProgramHalfWord(FLASH_BASE + chip_offset + len - 1, 0xff << 8 | data[len - 1]);		PIOS_Assert(status == FLASH_COMPLETE);	}	return 0;}

//Store the computed offsets to internal FLASHvoid store_offsets(){	union	{		float val;		struct		{			uint8_t bytes[4];		};	}extract_float;	uint32_t ADDRESS = BACKUP_ADDRESS;	uint8_t i,j;	IWDG_ReloadCounter();	FLASH_Unlock();				//unlock FLASH to enable writing	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);	//clear any pending flags	FLASH_EraseSector(BACKUP_SECTOR,VoltageRange_3);		//Erase the sector where data is to be written too	FLASH_ProgramHalfWord(ADDRESS, ASI_ZERO);	ADDRESS+=2;	for(j=0;j<6;j++)	{		extract_float.val = AN_OFFSET[j];		for(i=0;i<4;i++)		{			FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);			ADDRESS+=1;		}	}	for(i=0;i<3;i++)	{		FLASH_ProgramHalfWord(ADDRESS, MAG_OFFSET[i]);		ADDRESS+=2;	}	for(j=0;j<3;j++)	{		extract_float.val = MAG_SCALE[j];		for(i=0;i<4;i++)		{			FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);			ADDRESS+=1;		}	}	FLASH_ProgramHalfWord(ADDRESS, ground_alt_offset);	ADDRESS+=2;	for(i=0;i<8;i++)	{		FLASH_ProgramHalfWord(ADDRESS, RC_trim[i]);		ADDRESS+=2;	}	FLASH_Lock();}

/******************************************************************************** Function Name  : EE_VerifyPageFullWriteVariable* Description    : Verify if active page is full and Writes variable in EEPROM.* Input          : - VirtAddress: 16 bit virtual address of the variable*                  - Data: 16 bit data to be written as variable value* Output         : None* Return         : - Success or error status:*                      - FLASH_COMPLETE: on success*                      - PAGE_FULL: if valid page is full*                      - NO_VALID_PAGE: if no valid page was found*                      - Flash error code: on write Flash error*******************************************************************************/u16 EE_VerifyPageFullWriteVariable(u16 VirtAddress, u16 Data){  FLASH_Status FlashStatus = FLASH_COMPLETE;  u16 ValidPage = PAGE0;  u32 Address = 0x08010000, PageEndAddress = 0x080107FF;  /* Get valid Page for write operation */  ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);  /* Check if there is no valid page */  if (ValidPage == NO_VALID_PAGE)  {    return  NO_VALID_PAGE;  }  /* Get the valid Page start Address */  Address = (u32)(EEPROM_START_ADDRESS + (u32)(ValidPage * PAGE_SIZE));  /* Get the valid Page end Address */  PageEndAddress = (u32)((EEPROM_START_ADDRESS - 2) + (u32)((1 + ValidPage) * PAGE_SIZE));  /* Check each active page address starting from beginning */  while (Address < PageEndAddress)  {    /* Verify each time if Address and Address+2 contents are equal to Data and VirtAddress respectively */    if (((*(vu16*)Address) == Data) && ((*(vu16*)(Address + 2)) == VirtAddress))    {      return FLASH_COMPLETE;    }    /* Verify if Address and Address+2 contents are 0xFFFFFFFF */    if ((*(vu32*)Address) == 0xFFFFFFFF)    {      /* Set variable data */      FlashStatus = FLASH_ProgramHalfWord(Address, Data);      /* If program operation was failed, a Flash error code is returned */      if (FlashStatus != FLASH_COMPLETE)      {        return FlashStatus;      }      /* Set variable virtual address */      FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);      /* Return program operation status */      return FlashStatus;    }    else    {      /* Next address location */      Address = Address + 4;    }  }  /* Return PAGE_FULL in case the valid page is full */  return PAGE_FULL;}

/**  * @brief  Verify if active page is full and Writes variable in EEPROM.  * @param  VirtAddress: 16 bit virtual address of the variable  * @param  Data: 16 bit data to be written as variable value  * @retval Success or error status:  *           - FLASH_COMPLETE: on success  *           - PAGE_FULL: if valid page is full  *           - NO_VALID_PAGE: if no valid page was found  *           - Flash error code: on write Flash error  */static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data){  FLASH_Status FlashStatus = FLASH_COMPLETE;  uint16_t ValidPage = PAGE0;  uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE-1;  /* Get valid Page for write operation */  ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);  /* Check if there is no valid page */  if (ValidPage == NO_VALID_PAGE)  {    return  NO_VALID_PAGE;  }  //FLASH_Unlock();  /* Get the valid Page start Address */  Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));  /* Get the valid Page end Address */  PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));  /* Check each active page address starting from begining */  while (Address < PageEndAddress)  {    /* Verify if Address and Address+2 contents are 0xFFFFFFFF */    if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF)    {      /* Set variable data */      FlashStatus = FLASH_ProgramHalfWord(Address, Data);      /* If program operation was failed, a Flash error code is returned */      if (FlashStatus != FLASH_COMPLETE)      {        //FLASH_Lock();        return FlashStatus;      }      /* Set variable virtual address */      FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);      /* Return program operation status */      //FLASH_Lock();      return FlashStatus;    }    else    {      /* Next address location */      Address = Address + 4;    }  }  //FLASH_Lock();  /* Return PAGE_FULL in case the valid page is full */  return PAGE_FULL;}

/******************************************************flash 字符串写入每次存入两个字节*******************************************************/void FlashWriteStr( u32 flash_add, u16 len, u8* data ){    //char cp[12];    //u8 s = 0;    u16 byteN = 0;    uint32_t FlashData;    //FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);    //FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);    //FLASH_ErasePage(flash_add+FLASH_PAGE_SIZE * 1);    //FLASH_ErasePage(flash_add);    //sprintf( cp, "len:%d", len);    //USART1_Puts(cp);    while( len )    {        FlashData=*(vu32*)(flash_add+byteN);	 /* 读取地址中的16位数据 */        my_unTemp16.un_temp8[0] = *(data+byteN);        my_unTemp16.un_temp8[1] = *(data+byteN+1);        //my_unTemp16.un_temp8[2] = *(data+byteN+2);        //my_unTemp16.un_temp8[3] = *(data+byteN+3);        //my_unTemp16.un_temp16=(*(data+byteN))|((*(data+byteN+1))<<8)|((*(data+byteN+2))<<16)|((*(data+byteN+3))<<24);        if(FlashData==0xffffffff)        {            FLASH_Unlock();            FLASH_ProgramHalfWord(flash_add+byteN , my_unTemp16.un_temp16 );            FLASH_Lock();        }//		else if(FlashData==my_unTemp16.un_temp16)//		{  FLASH_COMPLETE//		}        else        {            FLASH_Unlock();            FLASH_ErasePage(flash_add+byteN);		  /* 擦除页 */            FLASH_ProgramHalfWord(flash_add+byteN , my_unTemp16.un_temp16 );            FLASH_Lock();        }        //sprintf( cp, "bye:%d/r/n", s);        //USART1_Puts(cp);        if( 1==len )        {            //如果数据长度是奇数,为1的时候跳出            break;        }        else        {            byteN += 2;            len -= 2;        }    }    //FLASH_Lock();}

static int32_t PIOS_Flash_Internal_WriteData(uintptr_t flash_id, uint32_t addr, uint8_t * data, uint16_t len){	PIOS_Assert(data);	PIOS_Assert((addr & 0x0001) == 0)	struct pios_internal_flash_dev * flash_dev = (struct pios_internal_flash_dev *)flash_id;	if (!PIOS_Flash_Internal_Validate(flash_dev))		return -1;	uint32_t sector_start;	uint32_t sector_size;	/* Ensure that the base address is in a valid sector */	if (!PIOS_Flash_Internal_GetSectorInfo(addr,						&sector_start,						&sector_size)) {		/* We're asking for an invalid flash address */		return -2;	}	/* Ensure that the entire write occurs within the same sector */	if ((uintptr_t)addr + len > sector_start + sector_size) {		/* Write crosses the end of the sector */		return -3;	}	/* Write the data */	for (uint16_t i = 0; i < (len & ~1); i += 2) {		/* Check if content has been changed prios to write.		 * This should enhance performance and make this compatible with the F3 chip.		 */		uint8_t temp[2];		if (PIOS_Flash_Internal_ReadData(flash_id, addr + i, temp, sizeof(temp)) != 0)			return -4;		if (temp[0] == data[i] && temp[1] == data[i + 1])			continue;		FLASH_Status status;		status = FLASH_ProgramHalfWord(addr + i, data[i + 1] << 8 | data[i]);		PIOS_Assert(status == FLASH_COMPLETE);	}	/* Handle uneven writes by filling up with 0xff*/	if ((len & 1) != 0) {		FLASH_Status status;		status = FLASH_ProgramHalfWord(addr + len - 1, 0xff << 8 | data[len - 1]);		PIOS_Assert(status == FLASH_COMPLETE);	}	return 0;}

static voidRCFS_Write( flash_file *f ){    unsigned short *p;    unsigned short *q;    int   i;    volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;    // check for valid address    if( f->addr < baseaddr )        return;    if( f->data == NULL )        return;    // Init pointers (some wierd bug in ROBOTC here)    long tmp = f->addr;    p = (unsigned short *)tmp;    q = (unsigned short *)&(f->name[0]);    // Write header    for(i=0;i<(FLASH_FILE_HEADER_SIZE/2);i++)        {        // Write 16 bit data        FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, *q++ );        }    // point at the file data, we will write as words    q = (unsigned short *)f->data;    // Write Data, datalength is now in bytes so divide datalength by 2    for(i=0;i<(f->datalength/2);i++)        {        // Write 16 bit data        FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, *q++ );        // every 128 bytes abort time slice        if( (i % 128) == 0 )            abortTimeslice();        }    // Was it an odd number of bytes ?    if( (f->datalength & 1) == 1 )        {        // pad with 0xFF and write the last byte        unsigned short b = (*(unsigned char *)q) | 0xFF00;        FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, b);        }}

mal_error_e mal_flash_write_uint16_values(unsigned int start_address, uint16_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_ProgramHalfWord(address, values[i]);		if (FLASH_COMPLETE != result) {			// We stop at first sign of error			break;		}		// Increment address		address += sizeof(uint16_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 Save_DoorInfor(Door_Infor_t *infor){			FLASH_Unlock();			FLASH_ErasePage(DOOR_INFOR_ADDR);			FLASH_ProgramHalfWord((uint32_t)DOOR_INFOR_ADDR, *(uint16_t*)infor);			FLASH_Lock();}

bool write(uint32_t addr, uint16_t * data, const uint16_t data_len){  int sector;  /* Check bounds */  if ((addr >= (SECTOR11_START_ADDR + SECTOR_SIZE_128KB)) ||      (addr < SECTOR0_START_ADDR))    return false;  /* Need to compute sector to erase */  if (addr >= SECTOR5_START_ADDR)    sector = 5 + ((addr - SECTOR5_START_ADDR)/SECTOR_SIZE_128KB);  else if (addr >= SECTOR4_START_ADDR)    sector = 4;  else    sector = (addr - SECTOR0_START_ADDR)/SECTOR_SIZE_16KB;  /* Unlock flash */  FLASH_Unlock();  FLASH_EraseSector(sector * 0x08, VoltageRange_3);  /* Write data */  for (int i = 0; i < data_len; i += 2)  {    FLASH_ProgramHalfWord(addr, *data);    data++; addr += 2;   }  return true;}

uint32_t FLASH_Write_16BITS( uint32_t* FlashAddress, uint16_t* Data ,uint16_t DataLength){    __disable_irq();        for (u16 i = 0; i < (DataLength); i++)    {        if (FLASH_ProgramHalfWord(*FlashAddress, Data[i]) == FLASH_COMPLETE)        {            /* Check the written value */            if (*(u16*)*FlashAddress != Data[i])            {               /* Flash content doesn't match SRAM content */               return FLASH_WRITE_ERROR;            }         }         else         {           return FLASH_ERASE_ERROR;         }         *FlashAddress += 2;    }          __enable_irq();         return FLASH_OK;}

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

Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8 *SourceAddressPtr, Fls_LengthType Length){	FLASH_Status stResult;	Fls_LengthType len = Length;	Fls_AddressType addr = TargetAddress;	const uint8 *srcPtr = SourceAddressPtr;	while (len >= sizeof(uint32_t))	{		stResult = FLASH_ProgramWord((uint32_t)addr, (uint32_t)*(uint32_t *)srcPtr);		srcPtr += sizeof(uint32_t);		addr += sizeof(uint32_t);		len -= sizeof(uint32_t);	}	if (len == sizeof(uint16_t))	{		FLASH_ProgramHalfWord((uint32_t)addr, (uint16_t)*(uint16_t *)srcPtr);		srcPtr += sizeof(uint16_t);		addr += sizeof(uint16_t);		len -= sizeof(uint16_t);	}	return E_OK;}

//写多个数据到一个页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;}

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

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

uint16_t EE_WriteBuf(uint16_t EEAddress, uint16_t* _data, uint16_t len){	uint16_t * rData, * fData;	uint32_t adr;	uint32_t ret;	uint32_t i;	volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;	ret = 0;	// check data	rData = (uint16_t *)_data;	fData = (uint16_t *)(EEAddress + EEPROM_START_ADDRESS);	adr = EEAddress + EEPROM_START_ADDRESS;	for (i = 0; i < len; i++)	{		if (rData[i] != fData[i] )		{			ret = 1;			if (fData[i] != 0xFFFF) 			{				ret = 2;				i = len;			}		}	}		if (ret)	{		FLASH_Unlock();		FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | 			FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); 		// Clear Page		if (ret == 2)			FLASHStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);		ret = 0;		if (FLASHStatus == FLASH_COMPLETE)		{			for (i = 0; i < len; i++)			{				FLASHStatus = FLASH_ProgramHalfWord(adr, rData[i]);				adr += 2;			}			// check flash write			rData = (uint16_t *)_data;			fData = (uint16_t *)(EEAddress + EEPROM_START_ADDRESS);			for (i = 0; i < len; i++)			{				if (rData[i] != fData[i] ) ret = 1;			}		}		else		{			ret = 2;		}		FLASH_Lock();	}	return ret;}

void flash_write_ID(){    for(uint8_t i = 0; i<ID_LENGTH;i++)    {      FLASH_ProgramHalfWord(ID_ADDRESS + i*2, addressToWrite[i]);      leds_sync_toggle();    }    memset(addressToWrite , 0, ID_LENGTH);}

//不检查的写入//WriteAddr:起始地址//pBuffer:数据指针//NumToWrite:半字(16位)数   void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   { 			 		 	u16 i;	for(i=0;i<NumToWrite;i++)	{		FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);	    WriteAddr+=2;//地址增加2.	}  } 

void Write_Copy_File_Flag(uint16_t flag){    FLASH_Unlock();    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	            FLASH_ErasePage(COPY_FILE_ADDRESS);    FLASH_ProgramHalfWord(COPY_FILE_ADDRESS, flag);    FLASH_Lock();}

ot_u8 NAND_write_short(ot_u16* addr, ot_u16 data) {    ot_u8 output;    NAND_unlock();    output = (ot_u8)FLASH_ProgramHalfWord((uint32_t)addr, (uint16_t)data);    NAND_lock();    return output;}

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

/*********************************************************** 函数功能 ---> STM32 FLASH写入扇区* 入口参数 ---> Address：写入数据的起始地址*               *pBuffer：写入数据缓存*               NumWriteData：写入（半字）数量* 返回参数 ---> none * 功能说明 ---> none**********************************************************/void FLASH_Write_HaifWord_SECTOR(uint32_t Address, uint16_t *pBuffer, uint16_t NumWriteData){	uint16_t i;	for(i = 0;i < NumWriteData;i++)	{		FLASH_ProgramHalfWord(Address, pBuffer[i]);	//写入半字数据		Address += 2;	//地址增加2	}}

u16 Flash_EEPROM_Write_Data( u32 Start_Address, u16 *data, u16 No_of_Data, u8 Data_format) {   // u32 Write_Addr_Cnt=Start_Address;   u32 End_Of_Address=0;   FLASHStatus=FLASH_COMPLETE;   FLASH_EEPROM_ProgramStatus= PASSED;   FLASH_Unlock();   /*Start EEPROM*/   Flash_EEPROM_Addr= Start_Address;   End_Of_Address= Start_Address +(No_of_Data * Data_format) ;   /* Write page data*/   while((Flash_EEPROM_Addr<End_Of_Address) )   {     /* Verify if Address and Address+2 contents are 0xFFFFFFFF */     // if ((*( vu32 *)Flash_EEPROM_Addr) == 0xFFFFFFFF)     //	{     switch(Data_format)     {       case Data_8Bit :	break;       case Data_16Bit : 	FLASHStatus = FLASH_ProgramHalfWord(Flash_EEPROM_Addr, *data); 	if (FLASHStatus != FLASH_COMPLETE) 	{ 	  return FLASHStatus; 	} 	Flash_EEPROM_Addr +=2; // point to next 2byte address 	data++; 	break; 	case Data_32Bit : 	FLASHStatus = FLASH_ProgramWord(Flash_EEPROM_Addr, *data); 	if (FLASHStatus != FLASH_COMPLETE) 	{ 	return FLASHStatus; 	} 	Flash_EEPROM_Addr +=4; // point to next 4byte address 	data++; 	break;     }     /*     }	    else     {     Flash_EEPROM_Addr +=4; // point to next 4byte address     }     */	  }   FLASH_Lock();   return FLASHStatus; }

void EEPROM_Write( u32 Offset, u16 Data ){	volatile FLASH_Status FLASHStatus;	u32 Adr;	u16 cnt;	u16 Buffer[512];	Adr = EEPROM_START_ADDRESS + (Offset<<1);	if( (Data != EEPROM_Read(Offset)) && (Offset<512) )	{		for( cnt=0; cnt<512; cnt++ )		{			Buffer[cnt] = EEPROM_Read(cnt);		}		Buffer[Offset] = Data;		FLASH_Unlock();		/* Clear All pending flags */		FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);		if( (Data==0) || (EEPROM_Read(Offset)==0xFFFF) )		{			FLASHStatus = FLASH_ProgramHalfWord( Adr, Data );		}		else		{		// Erase			/* Erase the FLASH pages */			FLASHStatus = FLASH_ErasePage( EEPROM_START_ADDRESS);			Adr = EEPROM_START_ADDRESS;			for( cnt=0; cnt<512; cnt++ )			{				if( Buffer[cnt] != 0xFFFF ) FLASHStatus = FLASH_ProgramHalfWord( Adr, Buffer[cnt] );				Adr += 2;			}		}		FLASH_Lock();	}}