Ejemplo n.º 1
0
void conf_general_init(void) {
	// First, make sure that all relevant virtual addresses are assigned for page swapping.
	memset(VirtAddVarTab, 0, sizeof(VirtAddVarTab));

	int ind = 0;
	for (unsigned int i = 0;i < (sizeof(app_configuration) / 2);i++) {
		VirtAddVarTab[ind++] = EEPROM_BASE_MCCONF + i;
	}

	for (unsigned int i = 0;i < (sizeof(app_configuration) / 2);i++) {
		VirtAddVarTab[ind++] = EEPROM_BASE_APPCONF + i;
	}

	FLASH_Unlock();
	EE_Init();
}
Ejemplo n.º 2
0
void Flash_SaveLastGUI(void)
{
	uint8 buff[1024] = {0};

  FLASH_Unlock(); 
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR );
	if(FLASH_COMPLETE != FLASH_ErasePage(STORE_LAST_GUI_PAGE_ADDR))
	{
    return;
  }
	memcpy(buff, (uint8*)&backgroud, 1024);
	
  Flash_WriteData(STORE_LAST_GUI_PAGE_ADDR, (uint16*)buff, 1024/2);

	FLASH_Lock();
}
Ejemplo n.º 3
0
void Flash_SaveTagState(void)
{
	uint8 buff[64] = {0};

  FLASH_Unlock(); 
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR );
	if(FLASH_COMPLETE != FLASH_ErasePage(STORE_SYS_STATE_PAGE_ADDR))
	{
    return;
  }
	memcpy(buff, (uint8*)&state_para.ackflag_set, sizeof(state_para));
	
  Flash_WriteData(STORE_SYS_STATE_PAGE_ADDR, (uint16*)buff, (sizeof(state_para)+1)/2);

	FLASH_Lock();
}
Ejemplo n.º 4
0
/*=====================================================================================================*/
int8_t Flash_WritePageU8( uint32_t writeAddr, const uint8_t *writeData, uint32_t lens )
{
  int8_t status = ERROR;
  uint32_t count = 0;

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_EOP    | FLASH_FLAG_OPERR  | FLASH_FLAG_WRPERR |
                  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

  do {
    status = FLASH_ProgramByte(writeAddr + count, writeData[count]);
  } while((++count < lens) && (status == FLASH_COMPLETE));
  FLASH_Lock();

  return status;
}
static int32_t PIOS_Flash_Internal_StartTransaction(uintptr_t flash_id)
{
	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_FREERTOS)
	if (xSemaphoreTake(flash_dev->transaction_lock, portMAX_DELAY) != pdTRUE)
		return -2;
#endif	/* defined(PIOS_INCLUDE_FREERTOS) */

	/* Unlock the internal flash so we can write to it */
	FLASH_Unlock();
	return 0;
}
Ejemplo n.º 6
0
void erase_flash_page(uint32_t page_addr)
{
	FLASH_Status FLASHStatus = FLASH_COMPLETE;

	__disable_irq();
	FLASH_Unlock();

	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	

	FLASHStatus = FLASH_ErasePage(page_addr);
	if(FLASHStatus != FLASH_COMPLETE)
		myprintf("FLASH_ErasePage Error\r\n");

	FLASH_Lock();
	__enable_irq();
}
Ejemplo n.º 7
0
int hal_nvm_init_sector(HAL_NVM_HANDLE handle, unsigned long address)
{
    int sector = get_sector(address);
    int rv = HAL_NVM_E_SUCCESS;

    FLASH_Unlock();

    if (FLASH_EraseSector(sector, VoltageRange_3) != FLASH_COMPLETE)
    {
        rv = HAL_NVM_E_ERROR;
    }

    FLASH_Lock();

    return rv;
}
Ejemplo n.º 8
0
//----清除全部刷卡记录-----------------------------------------------------
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();
}
Ejemplo n.º 9
0
/***********************************************************
 * 函数名:WriteflashBoatInfo
 * 描述  :把activation_flag从CPU写入Flash,位置信息
 * 输入  : 无
 * 输出  : 无
 ***********************************************************/
void WriteflashBoatInfo(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[7] - StartAddr[7]) / FLASH_PAGE_SIZE; //页面擦除子程序
	FLASHStatus = FLASH_ErasePage(StartAddr[7] + (FLASH_PAGE_SIZE * NbrOfPage)); 

	FlashAddress = StartAddr[7]; 

	FLASHStatus = FLASH_ProgramWord(FlashAddress, boatlong);
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, boatwidth);
}
Ejemplo n.º 10
0
void FLASH_Config(void)
{
 /* Define flash programming Time*/
  FLASH_SetProgrammingTime(FLASH_PROGRAMTIME_STANDARD);
/*
  FLASH_Unlock(FLASH_MEMTYPE_PROG);
  // Wait until Flash Program area unlocked flag is set
  while (FLASH_GetFlagStatus(FLASH_FLAG_PUL) == RESET)
  {}
*/
  /* Unlock flash data eeprom memory */
  FLASH_Unlock(FLASH_MEMTYPE_DATA);
  /* Wait until Data EEPROM area unlocked flag is set*/
  while (FLASH_GetFlagStatus(FLASH_FLAG_DUL) == RESET)
  {}
}
Ejemplo n.º 11
0
void Flash_SaveTagInfo(void)
{
	uint8 buff[1024] = {0};

  FLASH_Unlock(); 
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR );
	if(FLASH_COMPLETE != FLASH_ErasePage(STORE_SYS_INFO_PAGE_ADDR))
	{
    return;
  }
	memcpy(buff, (uint8*)&tag_flash_info.net_flag_set, sizeof(tag_flash_info));
	
  Flash_WriteData(STORE_SYS_INFO_PAGE_ADDR, (uint16*)buff, (sizeof(tag_flash_info)+1)/2);

	FLASH_Lock();
}
Ejemplo n.º 12
0
/**-----------------------------------------------------------------------------
 * @brief	Effacement d'un secteur de Flash.
 *
 * @param[in]	FlashSector	Secteur a effacer.
 *
 * @return		Status	Statut de l'ecriture.
 */
uint8_t FLASH_Erase(uint8_t FlashSector)
{
	uint32_t FLASH_Sector;
	FLASH_Status Status;

	// Effacement du secteur
	switch (FlashSector)
	{
		case 0:		FLASH_Sector = FLASH_Sector_0;	break;
		case 1:		FLASH_Sector = FLASH_Sector_1;	break;
		case 2:		FLASH_Sector = FLASH_Sector_2;	break;
		case 3:		FLASH_Sector = FLASH_Sector_3;	break;
		case 4:		FLASH_Sector = FLASH_Sector_4;	break;
		case 5:		FLASH_Sector = FLASH_Sector_5;	break;
		case 6:		FLASH_Sector = FLASH_Sector_6;	break;
		case 7:		FLASH_Sector = FLASH_Sector_7;	break;
		case 8:		FLASH_Sector = FLASH_Sector_8;	break;
		case 9:		FLASH_Sector = FLASH_Sector_9;	break;
		case 10:	FLASH_Sector = FLASH_Sector_10;	break;
		case 11:	FLASH_Sector = FLASH_Sector_11;	break;
		case 0xFF:	FLASH_Sector = 0xFF;			break;
		default:	return Status_KO;				break;

	}

	// Desactivation des interruptions
	__disable_irq();

	// Deverrouillage de la flash
	FLASH_Unlock();

	if (FLASH_Sector == 0xFF)
		Status = FLASH_EraseAllSectors(VoltageRange_3);
	else
		Status = FLASH_EraseSector(FLASH_Sector, VoltageRange_3);

	// Verrouillage de la flash
	FLASH_Lock();

	// ReActivation des interruptions
	__enable_irq();

	if (Status == FLASH_COMPLETE)
		return Status_OK;

	return Status_KO;
}
Ejemplo n.º 13
0
u8* bsp_MCU_Write(u8* writebuffer,u8 blockid,u16 writelength)
{	
	
	u8 status=0;
	u16 index=0;
	SleepTime=0;
	__set_PRIMASK(1);  
	memcpy(MCU_ROM_Write,(u8*)ADDR_FLASH_SECTOR_7,1024+16); //在擦除之前,先把数据读出来放在内存buffer
	__set_PRIMASK(0);  
	
  if(blockid==1)
	{
		memcpy(MCU_ROM_Write,writebuffer,writelength); //将512byte数据写入第一个block区域
	}
	if(blockid==2)
	{
		memcpy(MCU_ROM_Write+512,writebuffer,writelength); //将512byte数据写入第二个block区域
	}
	
	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)
	{
   __set_PRIMASK(1);  
		  for(index=0;index<(1024+16);index++)
		{
			status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+index,MCU_ROM_Write[index]);  //SysID
		}
   __set_PRIMASK(0);  
	}
	
  FLASH_DataCacheCmd(ENABLE);	//FLASH擦除结束,开启数据缓存
	FLASH_Lock();//上锁	
	if(status==FLASH_COMPLETE)
	{
		MCU_WriteStatus=0;
	}
	else
	{
		MCU_WriteStatus=status;
	}
	return &MCU_WriteStatus;
		
}
Ejemplo n.º 14
0
mal_error_e mal_flash_erase_page(uint32_t page) {
	// Unlock flash registers
	FLASH_Unlock();
	// Clear pending flags
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
	// Erase page
	FLASH_Status result;
	uint32_t offset = mal_flash_get_page_size(page) * page;
	result = FLASH_ErasePage(FLASH_START_ADDRESS + offset);
	// Lock flash registers
	FLASH_Lock();
	// Return result
	if (FLASH_COMPLETE != result) {
		return MAL_ERROR_MEMORY;
	}
	return MAL_ERROR_OK;
}
Ejemplo n.º 15
0
void IAC_Init(void)
{
	 delay_init(72);
	 MCO_INIT();
	 Nvic_Init(); 
   LED_GPIO_Config();	
   I2C_INIT();
	 delay(0XFFF);
	 TIM3_Init(2500);
	 usart1_config();
	 ADC1_Init();	
	 NRF24L01_Init();
   Moto_Init();	
	 LED_SHOW();
	 FLASH_Unlock();
	 EE_Init();
}
Ejemplo n.º 16
0
void Data_Save(void)
{
	uint8_t count;
	uint8_t i,flag;
	LED4_on;
	flash_save[0].i32_data[0] = Gyro_Float;
	flash_save[0].i32_data[1] = 0x00000000;
	flash_save[1].f64_data = Gyro_Convert1;
	flash_save[2].f64_data = Gyro_Convert2;
	flash_save[3].f64_data = Encoders[0].Convert1;
	flash_save[4].f64_data = Encoders[0].Convert2;
	flash_save[5].f64_data = Encoders[0].Radius;
	flash_save[6].f64_data = Encoders[0].radian;
	flash_save[7].f64_data = Encoders[1].Convert1;
	flash_save[8].f64_data = Encoders[1].Convert2;
	flash_save[9].f64_data = Encoders[1].Radius;
	flash_save[10].f64_data = Encoders[1].radian;
	
	FLASH_Unlock();
	while(FLASH_GetFlagStatus(FLASH_FLAG_BSY)==1);
	
	FLASH_ErasePage(PAGE_ADDRESS);
	for(count=0;count < SAVEDATA_NUM;count++)
	{
		for(i=0;i<4;i++)
		{
			flag = 0;
			while(flag==0)
			{
				FLASH_ProgramHalfWord((PAGE_ADDRESS +count*8+i*2),flash_save[count].u16_data[i]);  //flash  为一个字节存储,16位数据必须地址加2
				if(flashread((PAGE_ADDRESS +count*8+i*2)) == (flash_save[count].u16_data[i]))
				{
					flag = 1;
					LED2_off;
				}
				else
					LED2_on;
			}
		}
	}
	while(FLASH_GetFlagStatus(FLASH_FLAG_BSY)==1);

	FLASH_Lock();
	
	LED4_off;
}
Ejemplo n.º 17
0
/*******************************************************************************
* Function Name  : EraseFLASH
* Description    : Brisanje flash bloka
* Input          :
* Output         :
* Return         :
*******************************************************************************/
int					FlashErase(int n) {
int					i;
						if(n == _BOOT_SECTOR) 
							return(-1);
						FLASH_Unlock();
#if defined (STM32F10X_HD)
						FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);						
						do i=FLASH_ErasePage(n); while(i==FLASH_BUSY);
#elif defined  (STM32F2XX)
						FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);	
						do i=FLASH_EraseSector(n, VoltageRange_3);	while(i==FLASH_BUSY);
#endif			
						if(i==FLASH_COMPLETE)
							return(0);
						else
							return(i);
}
/**
 * Enter calibration mode. NOTE: Calling this method will erase the calibration table.
 *
 * @param none
 * @retval FLASH_Status The status of the FLASH operations. Returns FLASH_COMPLETE on success.
 */
FLASH_Status Tekdaqc_SetCalibrationMode(void) {
	/* 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);

	FLASH_Status status = FLASH_COMPLETE;

	/* FLASH_OB_Unlock(); */

	/* Disable write protection for this sector */
	/*FLASH_OB_WRPConfig(CALIBRATION_WPSECTOR, DISABLE);

	 FLASH_OB_Launch(); */

	/* Erase the calibration sector */
	status = FLASH_EraseSector(CALIBRATION_SECTOR, FLASH_VOLTAGE_RANGE);
	if (status != FLASH_COMPLETE) {
		return status;
	}

	/* Program the user Flash area word by word area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR */
	uint32_t Address = ADDR_CALIBRATION_BASE;

	while (Address < ADDR_CALIBRATION_END) {
		status = FLASH_ProgramWord(Address, CALIBRATION_ERASE_DATA);
		if (status == FLASH_COMPLETE) {
			Address = Address + 4;
		} else {
			return status;
		}
	}

	/* Enable write protection for this sector */
	/*FLASH_OB_WRPConfig(CALIBRATION_WPSECTOR, ENABLE);

	 FLASH_OB_Launch();*/

	/* FLASH_OB_Lock(); */
	/* Disable the flash control register access */

	CalibrationModeEnabled = true;
	return status;
}
Ejemplo n.º 19
0
/***********************************************************
 * 函数名:WriteflashBoatnum
 * 描述  :把船名信息从CUP写入Flash
 * 输入  : 无
 * 输出  : 无
 ***********************************************************/
void WriteflashBoatnum(void) 
{
	u8 i;
	FLASHStatus = FLASH_COMPLETE;
	MemoryProgramStatus = PASSED;
	FLASH_Unlock();	//FLASH解锁
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
	
	NbrOfPage = (EndAddr[0] - StartAddr[0]) / FLASH_PAGE_SIZE;//页面擦除子程序
	FLASHStatus = FLASH_ErasePage(StartAddr[0] + (FLASH_PAGE_SIZE * NbrOfPage));

	FlashAddress = StartAddr[0];
	for(i=0;i<4;i++)
	{
		FLASHStatus = FLASH_ProgramWord(FlashAddress, ((boatnum[i*4+3]<<24) + (boatnum[i*4+2]<<16) + (boatnum[i*4+1]<<8) + boatnum[i*4]));
		FlashAddress = FlashAddress + 4;
	}
}
Ejemplo n.º 20
0
void STMFLASH_WriteOnePage(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)	
{
	u32 secpos;	   
	u32 offaddr;   
	if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))
		{
		return;
		}
	FLASH_Unlock();					
	
	offaddr=WriteAddr-STM32_FLASH_BASE;		
	secpos=offaddr/STM32_SECTOR_SIZE;			
	
	FLASH_ErasePage(secpos*STM32_SECTOR_SIZE+STM32_FLASH_BASE);
	STMFLASH_Write_NoCheck(WriteAddr,pBuffer,NumToWrite);		   	

	FLASH_Lock();
}
Ejemplo n.º 21
0
/***********************************************************
 * 函数名:WriteflashMUID
 * 描述  :把从ChipUniqueID_Flash写入Flash,用于程序激活
 * 输入  : 无
 * 输出  : 无
 ***********************************************************/
void WriteflashMUID(void)
{
	u8 i;
	FLASHStatus = FLASH_COMPLETE;
	MemoryProgramStatus = PASSED; 

	FLASH_Unlock();	//FLASH解锁
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位

	NbrOfPage = (EndAddr[5] - StartAddr[5]) / FLASH_PAGE_SIZE;//页面擦除子程序
	FLASHStatus = FLASH_ErasePage(StartAddr[5] + (FLASH_PAGE_SIZE * NbrOfPage)); 
	FlashAddress = StartAddr[5]; 
	for(i=0;i<=2;i++)
	{
		FLASHStatus = FLASH_ProgramWord(FlashAddress,ChipUniqueID_Flash[i]);  //将UID写入flash
		FlashAddress += 4;
	}	
}
static int flashErase(uint32_t sector)
{
	FLASH_Unlock();
	FLASH_ClearFlag(
			FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR
					| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

	/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
	 be done by word */
	if (FLASH_EraseSector(sector, VoltageRange_3) != FLASH_COMPLETE)
	{
		FLASH_Lock();
		return -1;
	}
	FLASH_Lock();

	return 0;
}
Ejemplo n.º 23
0
void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)	
{
	u32 secpos;	   //扇区地址
	u16 secoff;	   //扇区内偏移地址(16位字计算)
	u16 secremain; //扇区内剩余地址(16位字计算)	   
 	u16 i;    
	u32 offaddr;   //去掉0X08000000后的地址
	if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
	FLASH_Unlock();						//解锁
	offaddr=WriteAddr-STM32_FLASH_BASE;		//实际偏移地址.
	secpos=offaddr/STM_SECTOR_SIZE;			//扇区地址  0~127 for STM32F103RBT6
	secoff=(offaddr%STM_SECTOR_SIZE)/2;		//在扇区内的偏移(2个字节为基本单位.)
	secremain=STM_SECTOR_SIZE/2-secoff;		//扇区剩余空间大小   
	if(NumToWrite<=secremain)secremain=NumToWrite;//不大于该扇区范围
	while(1) 
	{	
		STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
		for(i=0;i<secremain;i++)//校验数据
		{
			if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  	  
		}
		if(i<secremain)//需要擦除
		{
			FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
			for(i=0;i<secremain;i++)//复制
			{
				STMFLASH_BUF[i+secoff]=pBuffer[i];	  
			}
			STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
		}else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间. 				   
		if(NumToWrite==secremain)break;//写入结束了
		else//写入未结束
		{
			secpos++;				//扇区地址增1
			secoff=0;				//偏移位置为0 	 
		   	pBuffer+=secremain;  	//指针偏移
			WriteAddr+=secremain;	//写地址偏移	   
		   	NumToWrite-=secremain;	//字节(16位)数递减
			if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
			else secremain=NumToWrite;//下一个扇区可以写完了
		}	 
	};	
	FLASH_Lock();//上锁
}
Ejemplo n.º 24
0
////Addr 写入FLASH的首地址
uint32_t EEWriteStruct(void* pBuf,uint32_t cLen,uint32_t iAddr)	 
{
	uint8_t cResult =0;
	u32 ProtectedPages;		
	u32 Addr = 0;	
	u32 i,j,k=0;
	u32 iBufStart,iBaseAddr,cBufCnt;
	cLen>>=1;
	Addr=STARTADDR;
	Addr=iAddr;
	Addr+=STARTADDR;
	iBaseAddr  		= Addr%(SECTOR_SIZE<<1)+STARTADDR;                  //计算缓冲区首地址	 
	iBufStart  		= iAddr/(SECTOR_SIZE<<1)*(SECTOR_SIZE<<1);
	cBufCnt   	= (iBufStart+cLen)/SECTOR_SIZE+1;   //要写入的缓冲区次数	 

	for(j=0;j<cBufCnt;j++)
	{		
		//全部锁定则退出编程
		Flash_ProtectMode(&ProtectedPages );  //
		if(0==ProtectedPages)
			break;
		//读出一个扇区到保存缓冲区
		for(i=0;i<SECTOR_SIZE;i++)
			PrintBuf[i] = EEHalfWord_Read(iBaseAddr+SECTOR_SIZE*j+(i<<1));
		//将要保存的数据写入到缓冲区   					
		for(i=(j==0?iBufStart:0);i<SECTOR_SIZE;i++,k++) {
			PrintBuf[i] = *((vu16*)pBuf+k);				//
			if(--cLen==0){  
			   //__nop();
			   break;}	 
		}	
				    								    
		//擦除Flash区 
		FLASH_Unlock();
		EESector_Erase(Addr+j*SECTOR_SIZE);								//擦除扇区
		//写入内容;
		for(i=0;i<SECTOR_SIZE;i++)
		{
			 EEHalfWord_Write(iBaseAddr+SECTOR_SIZE*j+(i<<1),PrintBuf[i]);   
		}	   	
		FLASH_Lock();
	}			   		   
	return cResult;
}
Ejemplo n.º 25
0
void TIM3_IRQHandler(void)
{
  __IO uint8_t data;
  __IO uint8_t *addr;

  if (TIM_GetITStatus(TIM3, TIM_IT_CC1) == RESET)
    return;

  TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
  if (mode == 0) // Read cycle
    {
      STM_EVAL_LEDToggle(LED4);
      addr = (__IO uint8_t *)(base_addr + counter);
      if (*addr)
        STM_EVAL_LEDOn(LED6);
      else
        STM_EVAL_LEDOff(LED6);
    }
  else // Write cycle
    {
      if (counter == 0) // Flash address before programming
        {
          FLASH_Unlock();
          FLASH_ClearFlag(FLASH_FLAG_EOP    | FLASH_FLAG_OPERR |
                          FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
                          FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); 
          FLASH_EraseSector(sector, VoltageRange_3);
        }
      STM_EVAL_LEDToggle(LED5);
      FLASH_ProgramByte(base_addr + counter,
                        GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0));
    }
  counter++;
  if (counter == 50)
    {
      mode++;
      counter = 0;
    }
  if (mode > 1)
    {
      TIM_Cmd(TIM3, DISABLE);
      STM_EVAL_LEDOn(LED3);
    }
}
Ejemplo n.º 26
0
int flashErase(uint32_t startAddr, uint32_t len) {
    FLASH_Status status;
    unsigned int retries;
    int ret;
    uint32_t startSector, endSector;
    uint32_t i;

    if (startAddr == 0)
        startAddr = FLASH_START_ADDR;

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

    ret = 1;

    startSector = GetSector(startAddr);
    endSector = GetSector(startAddr + len*4);

    i = startSector;
    while (i <= endSector) {
        retries = 0;
        do {
            // Device voltage range supposed to be [2.7V to 3.6V], the operation will be done by word
            status = FLASH_EraseSector(i, VoltageRange_3);
            retries++;
        } while (status != FLASH_COMPLETE && retries < FLASH_RETRIES);

        if (retries == FLASH_RETRIES) {
            ret = 0;
            break;
        }

        if (i == FLASH_Sector_11)
            i += 40;
        else
            i += 8;
    }

    FLASH_Lock();

    return ret;
}
Ejemplo n.º 27
0
/*******************************************************************************
* Function Name  : FlashProgram32
* Description    : programiranje  ali verificiranje 32 bitov, klièe  driver v knjižnici samo
*				 : èe se vsebina razlikuje od zahtevane; specifikacije enake kot FLASH_ProgramWord 
*				 : iz knjižnice
* Input          :
* Output         :
* Return         :
*******************************************************************************/
int					FlashProgram32(uint32_t Address, uint32_t Data) {
int					i;	
						if(!memcmp((const void *)Address,&Data,4))
							return(0);
						else {
							FLASH_Unlock();
#if defined (STM32F10X_HD)
							FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);						
							do i=FLASH_ProgramWord(Address,Data); while(i==FLASH_BUSY);
#elif defined  (STM32F2XX)
							FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);	
							do i=FLASH_ProgramWord(Address,Data); while(i==FLASH_BUSY);
#endif				
						}
						if(i==FLASH_COMPLETE)
							return(0);
						else
							return(i);
}
Ejemplo n.º 28
0
unsigned char RM_flash_erase_page(unsigned char page_num)
{
  volatile FLASH_Status FLASHStatus;
  FLASHStatus = FLASH_COMPLETE;
#if 0
  if(page_num>=MAX_PAGE_NUM) return PAGE_NUM_ERR;
#endif  
  //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);
  
  FLASHStatus = FLASH_ErasePage( (0x08000000+APPLICATIONADDRESS+FLASH_PAGE_SIZE * page_num));
  
  FLASH_Lock();
  if(FLASHStatus==FLASH_COMPLETE) return FLASH_OP_OK;
  else
    return FLASHStatus;
}
Ejemplo n.º 29
0
void stm32_flash_write(uint32_t address, const void * data, uint32_t length)
{
  const uint32_t end = address + length;
  uint32_t i;
  uint32_t next_page, curr_page;
  uint16_t offset;

#if STATIC_FLASH_BUFFER
  static uint8_t buf[FLASH_PAGE_SIZE];
#else
  uint8_t buf[FLASH_PAGE_SIZE];
#endif
  for(i = address; i < end;) {
    next_page = (i | (FLASH_PAGE_SIZE-1)) + 1;
    curr_page = i & ~(FLASH_PAGE_SIZE-1);
    offset = i-curr_page;
    if(next_page > end) {
      next_page = end;
    }

    // Read a page from flash and put it into a mirror buffer.
    stm32_flash_read(curr_page, buf, FLASH_PAGE_SIZE);
    // Update flash mirror data with new data.
    memcpy(buf + offset, data, next_page - i);
    // Erase flash page.
    ENERGEST_ON(ENERGEST_TYPE_FLASH_WRITE);
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    FLASH_ErasePage(i);
    // Write modified data form mirror buffer into the flash.
    uint16_t j = 0;
    while(j < FLASH_PAGE_SIZE)
    {
        FLASH_ProgramWord(curr_page + j, *(u32_t *)&buf[j]);
        j = j + 4;
    }
    FLASH_Lock();
    ENERGEST_OFF(ENERGEST_TYPE_FLASH_WRITE);

    data = (uint8_t *)data + next_page - i;
    i = next_page;
  }
}
Ejemplo n.º 30
0
/*====================================================================================================*/
void Flash_EraseSectors( u32 EraseSectorStart, u32 EraseSectorEnd )
{
    FLASH_Status FLASHStatus;

    EraseSectorStart = Flash_GetSector(EraseSectorStart);
    EraseSectorEnd   = Flash_GetSector(EraseSectorEnd);

    FLASH_Unlock();

    FLASH_ClearFlag(FLASH_FLAG_EOP    | FLASH_FLAG_OPERR  | FLASH_FLAG_WRPERR |
                    FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
    while(EraseSectorStart <= EraseSectorEnd) {
        FLASHStatus = FLASH_EraseSector(EraseSectorStart, VoltageRange_3);
        while(FLASHStatus != FLASH_COMPLETE);
        EraseSectorStart += (EraseSectorStart == FLASH_Sector_11)? 40 : 8;
    }

    FLASH_Lock();
}