/**
 * @brief  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE
 * @param  None
 * @retval Status of the last operation (Flash write or erase) done during
 *         EEPROM formating
 */
static FLASH_Status EE_Format(void) {
	FLASH_Status FlashStatus = FLASH_COMPLETE;

	/* Erase Page0 */
	FlashStatus = FLASH_EraseSector(PAGE0_ID, FLASH_VOLTAGE_RANGE );

	/* 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_EraseSector(PAGE1_ID, FLASH_VOLTAGE_RANGE );

	/* Return Page1 erase operation status */
	return FlashStatus;
}
Esempio n. 2
0
FLASH_Status eraseHelper(uint32_t pageAddress)
{  
#if defined(SERIES_STM32F37x) || defined(SERIES_STM32F30x)
  return FLASH_ErasePage(pageAddress);
#else
  if (pageAddress == PAGE0_BASE_ADDRESS)
    return FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
  else if (pageAddress == PAGE1_BASE_ADDRESS)
    return FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
  else
    return FLASH_ERROR_PROGRAM;
#endif
}
Esempio n. 3
0
u8 bsp_Firmware_Erase(u8 APP_Select)
{
	u8 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);
	if(APP_Select)
	status=FLASH_EraseSector(FLASH_Sector_6 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
	else
	status=FLASH_EraseSector(FLASH_Sector_5 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
	
	MCU_WriteStatus=status;
	return MCU_WriteStatus;

}
Esempio n. 4
0
void Flash_EraseDataBuffer()
{
    FLASH_Unlock();
    FLASH_ClearFlag( FLASH_FLAG_EOP |  FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

    // Erase Sectors
    // 8-10 is data logger
    FLASH_EraseSector(FLASH_Sector_8, VoltageRange_3);
    FLASH_EraseSector(FLASH_Sector_9, VoltageRange_3);
    FLASH_EraseSector(FLASH_Sector_10, VoltageRange_3);

    Flash_ResetFlashAddress();

    FLASH_Lock();
}
Esempio n. 5
0
/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
ErrorStatus eep_erase( void )
{
	ErrorStatus Err = SUCCESS;
	
	/* Enable the flash control register access */
	FLASH_Unlock();

	/* Erase the user Flash area ************************************************/
	/* area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR */

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

	/* Get the number of the start and end sectors */
	uwStartSector = GetSector(FLASH_USER_START_ADDR);

	/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
	   be done by word */ 
	if (FLASH_EraseSector(uwStartSector, VoltageRange_3) != FLASH_COMPLETE)
	{ 
	  /* Error occurred while sector erase. 
		 User can add here some code to deal with this error  */
		Err = ERROR;
	}
	
	FLASH_Lock(); 
	
	return Err;
}
Esempio n. 6
0
static bool restoreCalibrateParamToFlash ( CalibrateParam* p )
{
  int i ;
  int n  =  sizeof(*p) / sizeof(uint32_t) ;
  uint32_t Address = CALIBRATE_PARAM_ADDR ;
  uint32_t *d = (uint32_t *) p ;
  
  
  FLASH_Unlock();
  FLASH_EraseSector(FLASH_Sector_5,VoltageRange_3);
  
  for ( i=0;i<n;i++){
    FLASH_ProgramWord( Address, *d );
    d ++ ;
    Address += 4;
  }
  FLASH_Lock();
  

  // 检验是否正确写入
  bool ret = true ;
  d = (uint32_t *) p ;
  uint32_t *d2 = (uint32_t*)CALIBRATE_PARAM_ADDR ;
  for ( i=0; i<n; i++ )
  {
    if ( d[i] != d2[i] )
    {
      ret = false ;
      break ;
    }
  }
  
  return ret ;
}
Esempio n. 7
0
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;
}
int stm32_flash_erase(uint32_t offset, uint16_t len)
{
	uint32_t StartSector, EndSector;
	uint32_t flash_user_start_addr, flash_user_end_addr;
	uint32_t addr;
	uint8_t i;
	

	/* Get the number of the start and end sectors */
	flash_user_start_addr = ADDR_FLASH_SECTOR_0 + offset;
	flash_user_end_addr = flash_user_start_addr + len;
  StartSector = GetSector(flash_user_start_addr);
	EndSector = GetSector(flash_user_end_addr);
	
	/* Erase sector */
	for (i = StartSector; i <= EndSector; i += 8) {
    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
       be done by word */ 
    if (FLASH_EraseSector(i, VoltageRange_3) != FLASH_COMPLETE) { 
			return -1;
    }
	}

	return 0;
}
Esempio n. 9
0
/**
  * @brief  ½«²ÎÊýдÈëFLASHÖÐ
  *         
  * @param  b:ÊÇ·ñÓÐLEDÌáʾ
  * @retval none
  */
void Flash_WriteParams(uint8_t b)
{
	FLASH_Status status;
	uint32_t i;

	FLASH_Unlock();

	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGPERR | FLASH_FLAG_WRPERR);

// 	//if (FLASH_ErasePage(FLASH_WRITE_ADDR) == FLASH_COMPLETE)
	if(FLASH_EraseSector(FLASH_WRITE_SECTOR, VoltageRange_3) == 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)
			{
				System_FailureMode(1);
				break;          // TODO: fail
			}
		}
	}
	else
		System_FailureMode(1);

	FLASH_Lock();

	Flash_Read();
}
Esempio n. 10
0
const DC3Error_t FLASH_eraseSector( const uint32_t sectorAddr )
{
    DC3Error_t status = ERR_NONE;

    /* These flags have to be cleared before any operation can be done on the
     * flash memory */
    //	DBG_printf("Clearing flash flags. Status before clear: %x\n",FLASH->SR );
    FLASH_ClearFlag(
        FLASH_FLAG_PGSERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGAERR |
        FLASH_FLAG_WRPERR | FLASH_FLAG_OPERR | FLASH_FLAG_EOP
    );
    //	DBG_printf("Status after clear: %x\n",FLASH->SR );
    WRN_printf("*** Erasing Flash sector addr 0x%08x ***\n", sectorAddr);

    /*Look up the STM32 value of the sector given the sector address */
    uint16_t sector = FLASH_sectorAddrToFlashSect( sectorAddr );

    DBG_printf("Erasing sector (0x%04x) with base addr: 0x%08x...\n",
               sector, sectorAddr);
    /* This is a blocking operation but it's only for a single sector so should
     * not take that long */
    FLASH_Status flash_status = FLASH_EraseSector(sector, VoltageRange_3);
    status = FLASH_statusToErrorCode( flash_status );

    if (ERR_NONE != status) {
        ERR_printf("Flash error %d ( error 0x%08x) while erasing sector "
                   "0x%04x (base addr: 0x%08x)\n",
                   flash_status, status, sector, sectorAddr);
        DBG_printf("FLASH SR:%lx\n", FLASH->SR);
    }

    return( status );
}
Esempio n. 11
0
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;
}
Esempio n. 12
0
bool flash_write_word(uint32_t add, uint32_t value)
{
	/* Unlock the Flash to enable the flash control register access *************/ 
	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);
	
	if (FLASH_EraseSector(FLASH_Sector_11, VoltageRange_4) != FLASH_COMPLETE)
	{ 
		goto fop_error;
	}
	
	//Program the user Flash area word by word
	if (FLASH_ProgramWord(add, value) != FLASH_COMPLETE)
	{ 
		goto fop_error;
	}
	FLASH_Lock();
	return true;
	
fop_error:
		FLASH_Lock(); 
		return false;	
}
Esempio n. 13
0
/*******************************************************************************
* 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;
}
Esempio n. 14
0
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;
}
Esempio n. 15
0
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

}
Esempio n. 16
0
OSStatus internalFlashErase(uint32_t StartAddress, uint32_t EndAddress)
{
  platform_log_trace();
  OSStatus err = kNoErr;
  uint32_t StartSector, EndSector, i = 0, j = 0;
  
  /* Get the sector where start the user flash area */
  StartSector = _GetSector(StartAddress);
  EndSector = _GetSector(EndAddress);
  
  for(i = StartSector; i <= EndSector; i += 8)
  {
    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
    be done by word */
    _GetAddress(i, &StartAddress, &EndAddress);
    for(j=StartAddress; j<=EndAddress; j+=8){
      if( (*(uint32_t *)(j))!=0xFFFFFFFF )
        break;
    }
    if( j>EndAddress ) 
      continue;
    require_action(FLASH_EraseSector(i, VoltageRange_3) == FLASH_COMPLETE, exit, err = kWriteErr); 
  }
  
exit:
  return err;
}
Esempio n. 17
0
int flash_erase(const uint32_t addr, const int32_t len)
{
  int start_sector, end_sector;

  /* Check bounds */
  if (addr < SECTOR0_START_ADDR)
    return -1;

  /* Need to compute sector to erase */
  start_sector = get_sector_num(addr);
  if (len == -1)
    end_sector = 11;
  else
    end_sector = get_sector_num(addr+(len*BYTES_PER_WORD)-1);

  FLASH_Unlock();
  for (int i = start_sector; i <= end_sector; ++i)
  {
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
                    FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
    FLASH_EraseSector(i * 0x08, VoltageRange_3);
  }
  FLASH_Lock();
  return 0;
}
Esempio n. 18
0
//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;
		
}
Esempio n. 19
0
File: ee_emul.c Progetto: alepnm/lcd
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;
}
Esempio n. 20
0
void bsp_SysinfoSave(void)
{
	u8 status=0;
	u16 index=0;
	SleepTime=0;
	memcpy(MCU_ROM_Write,(u8*)ADDR_FLASH_SECTOR_7,1024+16); //?????,???????????buffer
	memcpy(MCU_ROM_Write+1024,&char_SysID_Length,1); 
	memcpy(MCU_ROM_Write+1024+1,char_SysID,char_SysID_Length); 
	memcpy(MCU_ROM_Write+1024+9,&Battery_Threshold,1);
	memcpy(MCU_ROM_Write+1024+10,&Key_Sound,1);
	
	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_7 ,VoltageRange_3);//VCC=2.7~3.6V??!!

	if(status==FLASH_COMPLETE)
	{

		  for(index=0;index<(1024+16);index++)
		{
			status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+index,MCU_ROM_Write[index]);  //SysID
		}

	}
	
  FLASH_DataCacheCmd(ENABLE);	//FLASH????,??????
	FLASH_Lock();//??	
	if(status==FLASH_COMPLETE)
	{
		MCU_WriteStatus=0;
	}
	else
	{
		MCU_WriteStatus=status;
	}
//	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_7 ,VoltageRange_3);//VCC=2.7~3.6V??!!

//	if(status==FLASH_COMPLETE)
//	{

//			status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024,char_SysID_Length);//????
//		  for(index=0;index<char_SysID_Length;index++)
//		{
//			status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+index+1,char_SysID[index]);  //SysID
//		}
//		  status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+9,Battery_Threshold);
//		  status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+10,Key_Sound);
//		  

//	}
//  FLASH_DataCacheCmd(ENABLE);	//FLASH????,??????
//	FLASH_Lock();//??
}
Esempio n. 21
0
File: flash.c Progetto: karnlund/SMR
FLASH_Status flash_open_erase_sector(uint32_t address){
	uint8_t i;

	for (i = 0; i < 12; ++i) {
		if (address == kSectorBaseAddress[i]) {
		  FLASH_EraseSector(i * 8, VoltageRange_3);
		}
	}
}
Esempio n. 22
0
//Store the computed offsets to internal FLASH
void 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();
}
Esempio n. 23
0
void writeEEPROM(uint8_t b, uint8_t updateProfile)
{
    FLASH_Status status;
    uint32_t i;
    uint8_t chk = 0;
    const uint8_t *p;
    int tries = 0;

    // 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
retry:
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);

    if (FLASH_EraseSector(FLASH_Sector_11, VoltageRange_3) == FLASH_COMPLETE) {
        for (i = 0; i < sizeof(master_t); i += 4) {
            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *) ((char *)&mcfg + i));
            if (status != FLASH_COMPLETE) {
                FLASH_Lock();
                tries++;
               if (tries < 3)
                   goto retry;
                else
                    break;
            }
        }
    }
    FLASH_Lock();
    
    // Flash write failed - just die now
    if (tries == 3 || !validEEPROM()) {
        failureMode(10);
    }

    // re-read written data
    readEEPROM();
    if (b)
        blinkLED(15, 20, 1);
}
Esempio n. 24
0
static uint32_t flash_erase(uint32_t addr)
{
    if(FLASH_EraseSector(addr) == FLASH_OK)
    {
        return BL_FLASH_OK;
    }
    else
    {
        return BL_FLASH_ERR;
    }
}
Esempio n. 25
0
sys_res arch_IntfErase(adr_t nAdr)
{
	FLASH_Status res = FLASH_COMPLETE;

	stm32_intf_Lock();
    res = FLASH_EraseSector(arch_flashGetSector(nAdr), VoltageRange_3);
	stm32_intf_Unlock();
	if (res == FLASH_COMPLETE)
		return SYS_R_OK;
	return SYS_R_TMO;
}
Esempio n. 26
0
/*
 * Erase flash page if it is not already erased. This is to save write cycles and
 * prevent the memory from getting erased in case of unstable voltage at boot.
 */
static uint16_t EE_EraseSectorIfNotEmpty(uint32_t FLASH_Sector, uint8_t VoltageRange) {
	uint8_t *addr = flash_helper_get_sector_address(FLASH_Sector);

	for (unsigned int i = 0;i < PAGE_SIZE;i++) {
		if (addr[i] != 0xFF) {
			return FLASH_EraseSector(FLASH_Sector, VoltageRange);
		}
	}

	return FLASH_COMPLETE;
}
Esempio n. 27
0
/*=====================================================================================================*/
int8_t Flash_EraseSector( uint32_t eraseSector )
{
  int8_t status = ERROR;

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_EOP    | FLASH_FLAG_OPERR  | FLASH_FLAG_WRPERR |
                  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
  status = FLASH_EraseSector(eraseSector, VoltageRange_3);
  FLASH_Lock();

  return status;
}
Esempio n. 28
0
/*
*********************************************************************************************************
*	函 数 名: bsp_WriteCpuFlash
*	功能说明: 写数据到CPU 内部Flash。
*	形    参: _ulFlashAddr : Flash地址
*			 _ucpSrc : 数据缓冲区
*			 _ulSize : 数据大小(单位是字节)
*	返 回 值: 0-成功,1-数据长度或地址溢出,2-写Flash出错(估计Flash寿命到)
*********************************************************************************************************
*/
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
{
	uint32_t i;
	uint8_t ucRet;

	/* 如果偏移地址超过芯片容量,则不改写输出缓冲区 */
	if (_ulFlashAddr + _ulSize > FLASH_BASE_ADDR + FLASH_SIZE)
	{
		return 1;
	}

	/* 长度为0时不继续操作  */
	if (_ulSize == 0)
	{
		return 0;
	}

	ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);

	if (ucRet == FLASH_IS_EQU)
	{
		return 0;
	}

	__set_PRIMASK(1);  		/* 关中断 */

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

	/* 需要擦除 */
	if (ucRet == FLASH_REQ_ERASE)
	{
		FLASH_EraseSector(bsp_GetSector(_ulFlashAddr), VoltageRange_3);
	}

	/* 按字节模式编程(为提高效率,可以按字编程,一次写入4字节) */
	for (i = 0; i < _ulSize; i++)
	{
		FLASH_ProgramByte(_ulFlashAddr++, *_ucpSrc++);
	}

  	/* Flash 加锁,禁止写Flash控制寄存器 */
  	FLASH_Lock();

  	__set_PRIMASK(0);  		/* 开中断 */

	return 0;
}
Esempio n. 29
0
/*=====================================================================================================*/
void Flash_ErasePage(u32 ErasePage)
{
	FLASH_Status FLASHStatus;

	FLASH_Unlock();
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
			FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
	FLASHStatus = FLASH_EraseSector(ErasePage, VoltageRange_3);

	while (FLASHStatus != FLASH_COMPLETE);

	FLASH_Lock();
}
Esempio n. 30
0
File: flash.c Progetto: karnlund/SMR
FLASH_Status flash_erase_sector(uint32_t address){
	uint8_t i;

	FLASH_Unlock();
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
				  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
	for (i = 0; i < 12; ++i) {
		if (address == kSectorBaseAddress[i]) {
		  FLASH_EraseSector(i * 8, VoltageRange_3);
		}
	}
	FLASH_Lock();
}