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;
}
Exemple #2
0
	/**
	*@Destructor that deallocates all memory allocated by this class
	*/
	BlockEntity::~BlockEntity()
	{
		if (GetSector() != nullptr && GetSector()->As<SectorTetromino>())
		{
			GetSector()->As<SectorTetromino>()->RemoveBlock(this);
		}
		uint32_t i = 0;

		//searches a static vector for this instance of BlockEntity
		for (i = 0; i < blocks.size(); ++i)
		{
			if (blocks[i] == this)
			{
				break;
			}
		}

		//remove it from the static vector.
		if (i < blocks.size())
		{
			blocks.erase(blocks.begin() + i);
		}

		//Unsubscribe so that on Event Dispatch, it doesn't point to a garbage location.
		Event<EventMessageAttributed>::Unsubscribe(this);
	}
Exemple #3
0
//=============================================================================
//	eFdd::AddFile
//-----------------------------------------------------------------------------
bool eFdd::AddFile(const byte* hdr, const byte* data)
{
	eUdi::eTrack::eSector* s = GetSector(0, 0, 9);
	if(!s)
		return false;
	int len = hdr[13];
	int pos = s->data[0xe4] * 0x10;
	eUdi::eTrack::eSector* dir = GetSector(0, 0, 1 + pos / 0x100);
	if(!dir)
		return false;
	if(SectorDataW(s, 0xe5) < len) //disk full
		return false;
	memcpy(dir->data + (pos & 0xff), hdr, 14);
	SectorDataW(dir, (pos & 0xff) + 14, SectorDataW(s, 0xe1));
	UpdateCRC(dir);

	pos = s->data[0xe1] + 16 * s->data[0xe2];
	s->data[0xe1] = (pos + len) & 0x0f, s->data[0xe2] = (pos + len) >> 4;
	s->data[0xe4]++;
	SectorDataW(s, 0xe5, SectorDataW(s, 0xe5) - len);
	UpdateCRC(s);

	// goto next track. s8 become invalid
	for(int i = 0; i < len; ++i, ++pos)
	{
		int cyl = pos / 32;
		int side = (pos / 16) & 1;
		if(!WriteSector(cyl, side, (pos & 0x0f) + 1, data + i * 0x100))
			return false;
	}
	return true;
}
Exemple #4
0
	/**
	*Advances our block to the next rotation state
	*/
	void BlockEntity::AdvanceState()
	{
		mState = (mState + 1) % STATES;
		lastDirection = "Rotate";
		if (!CheckCollisions().empty())
		{
			GetSector()->As<SectorTetromino>()->mUndoRotate = true;
		}
		else
		{
			GetSector()->As<SectorTetromino>()->mPlayRotate = true;
		}
	}
Exemple #5
0
SGridLocation* CPartitionGrid::Rellocate( SGridLocation* obj,const Vec3 &newPos,CEntity* pEntity )
{
	FUNCTION_PROFILER(GetISystem(),PROFILE_ENTITY);

	if (m_bResetting)
	{
		return 0;
	}

	if (obj)
	{
		LocationInfo from,to;
		GetSector(obj->nSectorIndex,from);
		GetSector(newPos,to);
		if (from.sector != to.sector)
		{
			// Relink object between sectors.
			SectorUnlink( obj,from );
			if (to.sector)
			{
				SectorLink( obj,to );
				if (from.group && from.group->nLocationCount <= 0)
					FreeGroup(from);
			}
			else
			{
				FreeLocation(obj);
				obj = 0;
			}
		}
	}
	else if (fabs(newPos.x) > 0.1f || fabs(newPos.y) > 0.1f)
	{
		// Allocate a new sector location.
		LocationInfo to;
		GetSector(newPos,to);
		if (to.sector)
		{
			obj          = AllocateLocation();
			obj->pEntity = pEntity;
			if (pEntity)
			{
				obj->pEntityClass = pEntity->GetClass();
				obj->nEntityFlags = pEntity->GetFlags();
			}
			SectorLink( obj,to );
		}
	}
	return obj;
}
Exemple #6
0
unsigned CFAT::AllocateCluster (void)
{
    m_Lock.Acquire ();

    assert (m_pFATInfo != 0);
    unsigned nCluster = m_pFATInfo->GetNextFreeCluster ();

    while (nCluster < m_pFATInfo->GetClusterCount () + 2)
    {
        assert (nCluster >= 2);

        unsigned nSectorOffset;
        TFATBuffer *pBuffer = GetSector (nCluster, &nSectorOffset, m_pFATInfo->GetReadFAT ());
        assert (pBuffer != 0);

        unsigned nClusterEntry = GetEntry (pBuffer, nSectorOffset);

        assert (m_pCache != 0);
        m_pCache->FreeSector (pBuffer, 1);

        if (nClusterEntry == 0)
        {
            for (unsigned nFAT = m_pFATInfo->GetFirstWriteFAT ();
                    nFAT <= m_pFATInfo->GetLastWriteFAT (); nFAT++)
            {
                pBuffer = GetSector (nCluster, &nSectorOffset, nFAT);
                assert (pBuffer != 0);

                SetEntry (pBuffer, nSectorOffset, m_pFATInfo->GetFATType () == FAT16 ? 0xFFFF : 0x0FFFFFFF);

                m_pCache->MarkDirty (pBuffer);
                m_pCache->FreeSector (pBuffer, 1);
            }

            m_pFATInfo->ClusterAllocated (nCluster);

            m_Lock.Release ();

            return nCluster;
        }

        nCluster++;
    }

    m_Lock.Release ();

    return 0;
}
Exemple #7
0
void EraseFlash(uint32_t Address)
{ 
  int sector = GetSector(Address);
  /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
  be done by word */ 
  FLASH_Erase_Sector(sector, FLASH_VOLTAGE_RANGE_3);
}
void CD16Image::InitImage()
{
	if (bam != NULL)
		delete bam;
    bam = GetSector(1, 1);					// Bam of an HD Image seems to start at $100
    bamStart = GetSectorOffset(1, 1);
}
Exemple #9
0
/**
  * @brief  This function does an erase of all user flash area
  * @param  StartSector: start of user flash area
  * @retval 0: user flash area successfully erased
  *         1: error occurred
  */
uint32_t FLASH_If_Erase(uint32_t StartSector)
{
  uint32_t UserStartSector;
  uint32_t SectorError;
  FLASH_EraseInitTypeDef pEraseInit;

  /* Unlock the Flash to enable the flash control register access *************/ 
  FLASH_If_Init();
  
  /* Get the sector where start the user flash area */
  UserStartSector = GetSector(APPLICATION_ADDRESS);
  
  pEraseInit.TypeErase = TYPEERASE_SECTORS;
  pEraseInit.Sector = UserStartSector;
  pEraseInit.NbSectors = 6;
  pEraseInit.VoltageRange = VOLTAGE_RANGE_3;
    
  if (HAL_FLASHEx_Erase(&pEraseInit, &SectorError) != HAL_OK)
  {
     /* Error occurred while page erase */
     return (1);
  }
  
  return (0);
}
Exemple #10
0
//=============================================================================
//	eFdd::ReadScl
//-----------------------------------------------------------------------------
bool eFdd::ReadScl(const void* data, size_t data_size)
{
	if(data_size < 9)
		return false;
	const byte* buf = (const byte*)data;
	if(memcmp(data, "SINCLAIR", 8) || int(data_size) < 9 + (0x100 + 14)*buf[8])
		return false;

	CreateTrd();
	int size = 0;
	for(int i = 0; i < buf[8]; ++i)
	{
		size += buf[9 + 14 * i + 13];
	}
	if(size > 2544)
	{
		eUdi::eTrack::eSector* s = GetSector(0, 0, 9);
		SectorDataW(s, 0xe5, size);			// free sec
		UpdateCRC(s);
	}
	const byte* d = buf + 9 + 14 * buf[8];
	for(int i = 0; i < buf[8]; ++i)
	{
		if(!AddFile(buf + 9 + 14*i, d))
			return false;
		d += buf[9 + 14*i + 13]*0x100;
	}
	return true;
}
Exemple #11
0
//컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴
//Procedure	addtoworld
//------------------------------------------------------------------------------
//Author		Paul.   
//Date		Wed 30 Aug 1995
//Modified	
//
//Description	Adds an item to the sector list
//
//Inputs	
//
//Returns	
//
//Externals
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void WorldStuff::AddToWorld(itemptr item)
{
	UWord 	sector_number;

	sector_number = GetSector(item);

#ifndef NDEBUG																				//CSB 9Aug00
#define CHECKNOTINLIST																		//CSB 9Aug00
#ifdef  CHECKNOTINLIST																		//CSB 9Aug00
	for(itemptr listitem = sectorlist[sector_number]; listitem; listitem = listitem->Next)	//CSB 9Aug00
		if(listitem == item)																//CSB 9Aug00
			INT3;	//ITEM IS ALREADY IN THIS SECTOR LIST									//CSB 9Aug00
#endif																						//CSB 9Aug00
#endif																						//CSB 9Aug00

	if(sectorlist[sector_number]==(itemptr )NULL)
		{
		//First in the list
		sectorlist[sector_number] = item;
		item->Next = (itemptr )NULL;
		}
	else
		{
		//There are already some items in the list
		item->Next = sectorlist[sector_number];
		sectorlist[sector_number] = item;
		}
}
Exemple #12
0
/**
  * @brief  Erases sector.
  * @param  Add: Address of sector to be erased.
  * @retval 0 if operation is successful, MAL_FAIL else.
  */
uint16_t Flash_If_Erase(uint32_t Add)
{
  uint32_t startsector = 0, sectorerror = 0, nbofsectors = 0;
  
  /* Variable contains Flash operation status */
  HAL_StatusTypeDef status;
  FLASH_EraseInitTypeDef eraseinitstruct;
  
  /* Get the number of sector */
  startsector = GetSector(Add);
  
  /* Get the number of sector to erase from the start sector: max number of sectors - value of Initial sector */
  nbofsectors = (USBD_DFU_MAX_NB_OF_SECTORS - startsector);
  eraseinitstruct.TypeErase = FLASH_TYPEERASE_SECTORS;
  eraseinitstruct.Banks = 0;
  eraseinitstruct.Sector = startsector;
  eraseinitstruct.NbSectors = nbofsectors;
  eraseinitstruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
  status = HAL_FLASHEx_Erase(&eraseinitstruct, &sectorerror);
  
  if (status != HAL_OK)
  {
    return 1;
  }
  return 0;
}
Exemple #13
0
void ClipLine( POINT &Start, POINT &End )
{
	INT32 ThisSector = GetSector( End ) ;
	switch ( CaseTable[(INT32)LastSector][(INT32)ThisSector] )
	{
	case 01 : GenLineToBelowLeft()	; break ;
	case 02 : GenLineToBelowRight()	; break ;
	case 03 : GenLineToAboveLeft()	; break ;
	case 04 : GenLineToAboveRight()	; break ;
	case 05 : GenLine(Start)		;
			  GenLine(End)			; break ;
	case 06 : if ( OFirstPoint )
				  GenLine(Start) ;
			  GenLine(End)			; break ;
	case 07 :
		POINT Middle ;
		Middle.x = (Start.x+End.x) >> 1 ;
		Middle.y = (Start.y+End.y) >> 1 ;
		ClipLine( Start,Middle ) ;
		ClipLine( Middle,End ) ;
		return ;
	case 10 : GenLineToBelowLeft()	; GenLineToBelowRight()	; break ;
	case 11 : GenLineToBelowLeft()	; GenLineToAboveLeft()	; break ;
	case 12 : GenLineToBelowRight()	; GenLineToAboveRight()	; break ;
	case 13 : GenLineToBelowRight()	; GenLineToBelowLeft()	; break ;
	case 14 : GenLineToAboveLeft()	; GenLineToAboveRight()	; break ;
	case 15 : GenLineToAboveLeft()	; GenLineToBelowLeft()	; break ;
	case 16 : GenLineToAboveRight()	; GenLineToBelowRight()	; break ;
	case 17 : GenLineToAboveRight()	; GenLineToAboveLeft()	; break ;
	}
	LastSector = ThisSector ;
}
/**
  * @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;
}
void CD16Image::InitBAM(int track, int sector)
{
	if (bam != NULL)
		delete bam;
	bam = NULL;
	bam = GetSector(track, sector);
	bamStart = GetSectorOffset(track, sector);
}
Exemple #16
0
void csMeshGenerator::SelfDestruct ()
{
  if (GetSector ())
  {
    size_t c = GetSector ()->GetMeshGeneratorCount ();
    while (c > 0)
    {
      c--;
      if (GetSector ()->GetMeshGenerator (c) == (iMeshGenerator*)this)
      {
        GetSector ()->RemoveMeshGenerator (c);
        return;
      }
    }
    CS_ASSERT (false);
  }
}
/////////////////////////////////////////////////////////
// Description:
//  flush one sector in ram buffer (full of 0) to hardware storage
// 
// Input:
//   sectorIndex
//
// output:
//
// Remarks:
// 
// Returns:
void FAT_SectorCache::EraseSector( UINT32 sectorIndex )
{
    BYTE* sector = GetSector( sectorIndex, TRUE );

    if(sector)
    {
        memset( sector, 0, m_bytesPerSector );
    }
}
Exemple #18
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;
}
Exemple #19
0
//=============================================================================
//	eUdi::eTrack::WriteSector
//-----------------------------------------------------------------------------
bool eUdi::eTrack::WriteSector(int sec, const byte* data)
{
	eUdi::eTrack::eSector* s = GetSector(sec);
	if(!s || !s->data)
		return false;
	int len = s->Len();
	memcpy(s->data, data, len);
	s->UpdateCRC();
	return true;
}
Exemple #20
0
//=============================================================================
//	eFdd::WriteSector
//-----------------------------------------------------------------------------
bool eFdd::WriteSector(int cyl, int side, int sec, const byte* data)
{
	eUdi::eTrack::eSector* s = GetSector(cyl, side, sec);
	if(!s || !s->data)
		return false;
	int len = s->Len();
	memcpy(s->data, data, len);
	UpdateCRC(s);
	return true;
}
Exemple #21
0
bool CTeleport::RealizeTeleport()
{
	ADDTOCALLSTACK("CTeleport::RealizeTeleport");
	if ( !IsValidPoint() || !m_ptDst.IsValidPoint() )
	{
		DEBUG_ERR(("Bad teleport coords %s\n", WriteUsed()));
		return false;
	}
	CSector *pSector = GetSector();
	return pSector ? pSector->AddTeleport(this) : false;
}
Exemple #22
0
size_t CPointBase::GetRegions( DWORD dwType, CRegionLinks & rlinks ) const
{
	ADDTOCALLSTACK("CPointBase::GetRegions");
	if ( !IsValidPoint() )
		return 0;

	CSector *pSector = GetSector();
	if ( pSector )
		return pSector->GetRegions(*this, dwType, rlinks);

	return 0;
}
Exemple #23
0
void ClipCurve( POINT &C0, POINT &C1, POINT &C2, POINT &C3 )
{
	INT32 C1Sector	= GetSector( C1 ) ;
	INT32 C2Sector	= GetSector( C2 ) ;
	INT32 ThisSector	= GetSector( C3 ) ;
//	if ( ( ( C1Sector==LastSector || C1Sector==ThisSector ) &&
//		   ( C2Sector==LastSector || C2Sector==ThisSector ) ) ||
//		 ( Region[LastSector] & Region[C1Sector] & Region[C2Sector] & Region[ThisSector] ) )
	INT32 RegionUnion = Region[LastSector] & Region[C1Sector] & Region[C2Sector] & Region[ThisSector];
	if ( ( RegionUnion & 0x0ff ) ||
		 ( (RegionUnion & 0x300) && (LastSector!=ThisSector || LastSector==12) ) ||
		 ( (C1Sector==LastSector || C1Sector==ThisSector) && (C2Sector==LastSector || C2Sector==ThisSector) ) )
	{
		switch ( CaseTable[(INT32)LastSector][(INT32)ThisSector] )
		{
		case 01 : GenLineToBelowLeft()	; break ;
		case 02 : GenLineToBelowRight()	; break ;
		case 03 : GenLineToAboveLeft()	; break ;
		case 04 : GenLineToAboveRight()	; break ;
		case 05 : GenLine(C0,FALSE) ;
				  GenCurve(C1,C2,C3)	; break ;
		case 06 : if ( OFirstPoint )
					  GenLine(C0,FALSE) ;
				  GenCurve(C1,C2,C3)	; break ;
		case 07 : SplitCurve(C0,C1,C2,C3) ; return ;
		case 10 : GenLineToBelowLeft()	; GenLineToBelowRight()	; break ;
		case 11 : GenLineToBelowLeft()	; GenLineToAboveLeft()	; break ;
		case 12 : GenLineToBelowRight()	; GenLineToAboveRight()	; break ;
		case 13 : GenLineToBelowRight()	; GenLineToBelowLeft()	; break ;
		case 14 : GenLineToAboveLeft()	; GenLineToAboveRight()	; break ;
		case 15 : GenLineToAboveLeft()	; GenLineToBelowLeft()	; break ;
		case 16 : GenLineToAboveRight()	; GenLineToBelowRight()	; break ;
		case 17 : GenLineToAboveRight()	; GenLineToAboveLeft()	; break ;
		}
		LastSector = ThisSector ;
	}
	else
		SplitCurve(C0,C1,C2,C3) ;
}
Exemple #24
0
void psLinearMovement::GetLastFullPosition (csVector3& pos, float& yrot,
    iSector*& sector)
{
  if (!mesh)  return;

  // Position
  pos = GetFullPosition ();

  // rotation
  yrot = GetYRotation ();

  // Sector
  sector = GetSector ();
}
/*------------------------------------------------------------
 * Function Name  : SD_EraseFlashOperation
 * Description    : 擦除flash操作
 * Input          : None
 * Output         : None
 * Return         : None
 *------------------------------------------------------------*/
ErrorStatus SD_EraseFlashOperation( uint16_t x, uint16_t y )
{	
	ErrorStatus Err = SUCCESS;
	uint32_t addr = 0;
	const uint8_t ERASE_FLASH_NUM = 3;
	const uint32_t erase_addr[ERASE_FLASH_NUM] = {ADDR_FLASH_SECTOR_5,ADDR_FLASH_SECTOR_6,ADDR_FLASH_SECTOR_7};
	uint8_t i = 0;
	char buff[10];
	uint8_t process = 0;

	lcd_font24(x,y,COLOR_POINT,COLOR_BACK,"> 正在擦除flash...",UPDATE_FONT);
	x += 216;
		
	/* 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); 
	
	for (i=0; i<ERASE_FLASH_NUM; ++i)
	{
		/* Get the number of the start and end sectors */
		addr = GetSector(erase_addr[i]);

		/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
		   be done by word */ 
		if (FLASH_EraseSector(addr, VoltageRange_3) != FLASH_COMPLETE)
		{ 
		  /* Error occurred while sector erase. 
			 User can add here some code to deal with this error  */
			Err = ERROR;
			break;
		}
		
		process += 30;
		usprintf(buff,"%3d%%",process);
		lcd_font24(x,y,COLOR_POINT,COLOR_BACK,buff,UPDATE_FONT);
	}
	
	bsp_DelayMS(DELAY_TIME);
	lcd_font24(x,y,COLOR_POINT,COLOR_BACK,"100%",UPDATE_FONT);
	
	FLASH_Lock(); 
	
	return Err;
}
Exemple #26
0
bool CTeleport::RealizeTeleport()
{
	ADDTOCALLSTACK("CTeleport::RealizeTeleport");
	if ( ! IsCharValid() || ! m_ptDst.IsCharValid())
	{
		DEBUG_ERR(( "CTeleport bad coords %s\n", WriteUsed() ));
		return false;
	}
	CSector *pSector = GetSector();
	if ( pSector )
		return pSector->AddTeleport(this);
	else
		return false;
}
Exemple #27
0
CRegionBase * CPointBase::GetRegion( DWORD dwType ) const
{
	ADDTOCALLSTACK("CPointBase::GetRegion");
	// What region in the current CSector am i in ?
	// We only need to update this every 8 or so steps ?
	// REGION_TYPE_AREA
	if ( ! IsValidPoint())
		return NULL;

	CSector *pSector = GetSector();
	if ( pSector )
		return pSector->GetRegion(*this, dwType);

	return NULL;
}
Exemple #28
0
void CPartitionGrid::FreeLocation( SGridLocation* obj )
{
	if (obj && !m_bResetting)
	{
		LocationInfo locInfo;
		GetSector(obj->nSectorIndex,locInfo);
		if (locInfo.sector)
		{
			SectorUnlink( obj,locInfo );
			if (locInfo.group->nLocationCount <= 0)
				FreeGroup(locInfo);
		}
		delete obj;
	}
}
Exemple #29
0
HAL_StatusTypeDef FlashInit(void)
{
  HAL_StatusTypeDef res;
  
  /* Unlock the Flash to enable the flash control register access *************/ 
  res = HAL_FLASH_Unlock();
  
  /* Clear pending flags (if any) */  
  __HAL_FLASH_CLEAR_FLAG(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 */
  StartSector = GetSector(FLASH_USER_START_ADDR);
  EndSector = GetSector(FLASH_USER_END_ADDR);
  
  /* Lock the Flash to disable the flash control register access (recommended
  to protect the FLASH memory against possible unwanted operation) *********/
  if(res == 0)
    printf("flash success!\r\n");
  else
    printf("flash error:%d\r\n",res);
  
  return res;
}
Exemple #30
0
bool eFdd::BootExist()
{
	for(int i = 0; i < 9; ++i)
	{
		const eUdi::eTrack::eSector* s = GetSector(0, 0, i);
		if(!s)
			continue;
		const byte* ptr = s->data;
		const char* b = boot_sign;
		for(; (ptr = (const byte*)memchr(ptr, *b, s->Len() - (ptr - s->data))) != NULL; ++b)
		{
			if(!*b)
				return true;
		}
	}
	return false;
}