SpiFlash同步/非同步讀寫微控制器裸機例項

阿新 • • 發佈：2019-02-03

微控制器裸機開發中會經常遇到外設速度過慢，長時間讀忙等待，但CPU又不能長時間阻塞的問題。
這種問題可以通過實現一個狀態機來非同步處理。

非同步狀態機程式碼結構示例：

enum
{
	eIDLE = 0,
	eSTART,
	eWAIT,
	eSUCCESS
};

static uint8_t stage = 0;
//啟動非同步處理	
void DoSomethingRequest()
{
	if(stage != eIDLE)
	{
		printf("AsyncMachine is busy!!!,return\n");
		return;
	}
	SomethingReq = TRUE;
}
//非同步處理任務
void AsyncMachine()
{
	
	switch(stage)
	{
		case eIDLE:
			if(SomethingReq)
			{
				stage = eSTART;
				printf("A task will be start\n");
			}
			break;
		case eSTART: 
			do_something();
			stage = eWAIT;
			printf("do something\n");
			break;
		case eWAIT: 
			if(something_state() == OK)
			{
				stage = eSUCCESS;
			}
			printf("Wait...\n");
			break;
		case eSUCCESS: 
			stage = eIDLE;
			printf("task exec success\n");
			break;
	}
}

通過把阻塞的任務單獨分離出來，交給一個狀態機子任務來處理。則應用程式只需要呼叫一個處理請求而無需原地死等，狀態機處理完成後，可以非同步回撥來通知應用程式任務已完成。

下面附上SPI FLASH 同步/非同步讀寫例項。

//SPI狀態機狀態
typedef enum 
{
	eFLASH_STATE_IDLE = 0,
	eFLASH_STATE_WRITE = 1, 
	eFLASH_STATE_READ = 2,
	eFLASH_STATE_BUSY = 3,
	eFLASH_STATE_ERASE_CHIP = 4,
	eFLASH_STATE_ERASE = 5,
}FlashState_e;
//SPI裝置結構體
typedef struct SpiDevice_s {
	SPI_TypeDef *spiHandle;//SPI物理屬性
	uint8_t *pTxBuffer;//非同步傳送快取
	uint32_t uTxDstAddr;//非同步傳送目地地址
	uint16_t wTxLen;//非同步傳送長度
	uint16_t wTxOffset; //非同步當前快取已傳送偏移 
	uint8_t *pRxBuffer;
	uint32_t uRxSrcAddr;
	uint16_t wRxLen;
	uint16_t wRxOffset; 
	void (*pWriteAsyncNotifyCallback)(); //非同步寫完成回撥通知
	void (*pEraseChipAsyncNotifyCallback)();//異不擦除回撥通知
	struct {
		FlashState_e eStage;//當前狀態機狀態
		//BOOL bTxBusy:1;   //傳送忙
		BOOL bTxReq:1;     //傳送請求
		BOOL bTxCompleted:1;//傳送完成
		//BOOL bRxBusy:1;  //讀忙
		BOOL bRxReq:1;    //讀請求
		BOOL bEraseChipReq:1;//擦整片請求
		BOOL bEraseSectorReq:1;//擦扇區請求
		BOOL bEraseSuccess:1; //擦成功
	}tState;
	void (*Init)(void);
	uint8_t (*EraseChip)(void);//同步擦
	void (*Read)(uint8_t* pBuffer,uint32_t uReadAddr,uint16_t wNumByteToRead);//同步讀
	uint32_t (*WriteByte)(uint8_t Byte, uint32_t uWriteAddr);//同步寫位元組
	uint32_t (*Write)(uint8_t* pBuffer,uint32_t uWriteAddr, uint16_t wNumByteToWrite);//同步寫
	BOOL (*WriteAsync)(uint8_t* pBuffer,uint32_t uWriteAddr, uint16_t wNumByteToWrite);//非同步寫
	BOOL (*EraseChipAsync)(void);//非同步整片擦
	BOOL (*EraseAsync)(uint32_t uAddr, uint16_t wlen);//奶步擦
	void (*WriteAsyncNotifyCallbackRegister)(void* pfn);//非同步寫完成回撥註冊
	void (*EraseChipAsyncNotifyCallbackRegister)(void *pfn);//非同步擦完成回撥註冊
}SpiDevice_t;

例項化

SpiDevice_t g_tSpiDevice = 
{
	SPI2,
	g_aTxBuffer,
	0,0,0,
	g_aRxBuffer,
	0,0,0,
	0,0,
	{0,0},
	Spi_Init,
	SPI_Flash_Erase_Chip,	//Í¬²½ÕûÆ¬²Á
	SPI_Flash_Read,				//Í¬²½¶Á
	SPI_Flash_WriteByte,	//Í¬²½Ð´×Ö½Ú
	SPI_Flash_Write,			//Í¬²½Ð´
	SPI_FlashWriteAsync,	//Òì²½Ð´
	SPI_FlashEraseChipAsync,	//Òì²½ÕûÆ¬²Á³ý
	SPI_FlashEraseAsync,
	SPI_WriteAsyncNotifyCallbackRegister,//Ð´×´Ì¬Òì²½Í¨Öª»Øµ÷
	SPI_EraseChipAsyncNotifyCallbackRegister,//²Á³ý×´Ì¬Òì²½Í¨Öª»Øµ÷
};

//SPI同步操作

/*****************
²Á³ýÒ»¸öÉÈÇø
0~511
******************/
unsigned char SPI_Flash_Erase_Sector(unsigned int Dst_Addr)  
{  
	  unsigned char cnt=0; 
	
    SPI_FLASH_Write_Enable();                  //SET WEL           
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;
		}   
    SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(SECTOR_ERASE);      
    SPI_Flash_ReadWrite_Byte((unsigned char)((Dst_Addr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((Dst_Addr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)Dst_Addr); 
    SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy();  
		return TRUE;
} 

/*64K Flash¿Õ¼ä²Á³ý*/
unsigned char SPI_Flash_Erase_64k(unsigned int Dst_Addr)  
{  
	  unsigned char cnt=0;
	
    SPI_FLASH_Write_Enable();                  //SET WEL           
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;
		} 
    SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(BLOCK_ERASE_64K);      
    SPI_Flash_ReadWrite_Byte((unsigned char)((Dst_Addr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((Dst_Addr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)Dst_Addr); 
    SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy(); 
		return TRUE;
} 

/*²Á³ýÐ¾Æ¬*/
unsigned char SPI_Flash_Erase_Chip(void)  
{   
		unsigned char cnt=0;     
		
    SPI_FLASH_Write_Enable();                  //SET WEL
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;
		}
    SPI_CS_LOW();                             
    SPI_Flash_ReadWrite_Byte(CHIP_ERASE);        
    SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy();  
		return TRUE;
}  

/*Ö¸¶¨µØÖ·¶ÁÈ¡Ö¸¶¨³¤¶ÈÊý¾Ý*/
void SPI_Flash_Read(unsigned char* pBuffer,unsigned int ReadAddr,unsigned short int NumByteToRead)  
{
    unsigned short int index; 
	
    SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(READ_DATA);         
    /*¸³ÖµµØÖ·*/
    SPI_Flash_ReadWrite_Byte((unsigned char)((ReadAddr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((ReadAddr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)ReadAddr);
          
    for(index=0;index<NumByteToRead;index++)
    {
			pBuffer[index]=SPI_Flash_ReadWrite_Byte(DUMMY); 
    }
    SPI_CS_HIGH();                                        
} 


uint32_t SPI_Flash_WriteByte(unsigned char Byte,unsigned int WriteAddr)
{
		unsigned char cnt=0;
	
		SPI_FLASH_Write_Enable();                  //SET WEL           
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
		} 
		SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)WriteAddr);
		SPI_Flash_ReadWrite_Byte(Byte);
		SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy();
		return TRUE;
		
}

uint32_t SPI_Flash_Write(unsigned char* pBuffer,unsigned int WriteAddr,unsigned short int NumByteToWrite)
{
	unsigned short int pageoffset=PAGE_SIZE-(WriteAddr%PAGE_SIZE);  /*¼ÆËã¸ÃÒ³ÖÐ»¹ÓÐ¶àÉÙÊ£Óà¿Õ¼ä*/
	unsigned char cnt=0;
	unsigned short int index;
	unsigned int pagenum =WriteAddr/PAGE_SIZE;  /*±¾´ÎÐ´ÈëµÄÒ³Êý*/
	unsigned int Addr;
	
	if(pageoffset >= NumByteToWrite)  //Ê£Óà¿Õ¼ä´óÓÚÒªÐ´µÄÊýÁ¿
	{
    SPI_FLASH_Write_Enable();                  //SET WEL           
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
		} 
		SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)WriteAddr); 
		for(index=0; index<NumByteToWrite;index++)
		{
			SPI_Flash_ReadWrite_Byte(*(pBuffer+index)); 
		}
    SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy(); 
		return TRUE;
	}
	else
	{
		/*ÏÈ½«¸ÃÒ³ÌîÂú*/
		SPI_FLASH_Write_Enable();                  //SET WEL           
    while((SPI_Flash_Read_SR()&0x2)!=0x2) 
		{
			cnt ++;
			if(cnt >200)
				return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
		} 
		SPI_CS_LOW();                            
    SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>16));   
    SPI_Flash_ReadWrite_Byte((unsigned char)((WriteAddr)>>8));  
    SPI_Flash_ReadWrite_Byte((unsigned char)WriteAddr); 
		for(index=0; index<pageoffset;index++)
		{
			SPI_Flash_ReadWrite_Byte(*(pBuffer+index)); 
		}
    SPI_CS_HIGH();                                         
    SPI_Flash_Wait_Busy(); 
		
		NumByteToWrite -=pageoffset;  /*³¤¶È¼õÈ¥Ð´ÈëÊý¾Ý*/
		pagenum++;
		Addr = pagenum*PAGE_SIZE;  //»ñÈ¡ÏÂÒ»Ò³µÄÆðÊ¼µØÖ·
		
		while(NumByteToWrite >0)
		{
			if(NumByteToWrite > PAGE_SIZE)  //ÈÔÈ»´óÓÚÒ»Ò³
			{
				SPI_FLASH_Write_Enable();                  //SET WEL           
				while((SPI_Flash_Read_SR()&0x2)!=0x2) 
				{
					cnt ++;
					if(cnt >200)
					return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
				} 
				SPI_CS_LOW();                            
				SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
				SPI_Flash_ReadWrite_Byte((unsigned char)((Addr)>>16));   
				SPI_Flash_ReadWrite_Byte((unsigned char)((Addr)>>8));  
				SPI_Flash_ReadWrite_Byte((unsigned char)Addr); 
				for(index=0; index<PAGE_SIZE;index++)
				{
					SPI_Flash_ReadWrite_Byte(*(pBuffer+index+pageoffset)); 
				}
				SPI_CS_HIGH();                                         
				SPI_Flash_Wait_Busy();
				NumByteToWrite -=PAGE_SIZE;
				pageoffset +=PAGE_SIZE;
				pagenum++;
		    Addr = pagenum*PAGE_SIZE;  //»ñÈ¡ÏÂÒ»Ò³µÄÆðÊ¼µØÖ·
			}
			else
			{
				SPI_FLASH_Write_Enable();                  //SET WEL           
				while((SPI_Flash_Read_SR()&0x2)!=0x2) 
				{
					cnt ++;
					if(cnt >200)
					return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
				} 
				SPI_CS_LOW();                            
				SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
				SPI_Flash_ReadWrite_Byte((unsigned char)((Addr)>>16));   
				SPI_Flash_ReadWrite_Byte((unsigned char)((Addr)>>8));  
				SPI_Flash_ReadWrite_Byte((unsigned char)Addr); 
				for(index=0; index<NumByteToWrite;index++)
				{
					SPI_Flash_ReadWrite_Byte(*(pBuffer+index+pageoffset)); 
				}
				SPI_CS_HIGH();                                         
				SPI_Flash_Wait_Busy();
				NumByteToWrite =0;
			}
		}
		return TRUE;
	}
}
/***********************************************************************************************
 *SPI非同步操作
 *************************************************************************************************/

/*****************************************************************************************                    									       	
º¯ÊýÃû³Æ:SPI_FlashWriteAsync非同步寫請求
º¯ÊýÃèÊö:Òì²½Ð´
ÊäÈë²ÎÊý:                                  
Êä³ö²ÎÊý:                                                        
º¯Êý·µ»Ø: 
******************************************************************************************/
BOOL SPI_FlashWriteAsync(uint8_t* pBuffer,uint32_t uWriteAddr, uint16_t wNumByteToWrite)
{
	if(wNumByteToWrite > FLASH_TX_BUFFER_SIZE)
	{
		return FALSE;
	}
	if(g_tSpiDevice.tState.eStage != eFLASH_STATE_IDLE)
	{
		Debug(eDBUG_LEVEL_ERROR,"[%d]Flash_Write:busy,return\r\n", GetTicks());
		return FALSE;
	}
	memcpy(g_tSpiDevice.pTxBuffer, pBuffer, wNumByteToWrite);
	g_tSpiDevice.wTxLen = wNumByteToWrite;
	g_tSpiDevice.uTxDstAddr = uWriteAddr;
	g_tSpiDevice.wTxOffset = 0;
	g_tSpiDevice.tState.bTxReq = TRUE; //請求標誌
	g_tSpiDevice.tState.bTxCompleted = FALSE;
	//g_tSpiDevice.tState.bTxBusy = TRUE;
	return TRUE;
}
/*****************************************************************************************                    									       	
º¯ÊýÃû³Æ:SPI_FlashWriteAsync
º¯ÊýÃèÊö:Òì²½²ÁÕûÆ¬
ÊäÈë²ÎÊý:                                  
Êä³ö²ÎÊý:                                                        
º¯Êý·µ»Ø: 
******************************************************************************************/
BOOL SPI_FlashEraseChipAsync(void)
{
	//unsigned char cnt=0;     
	
	if(g_tSpiDevice.tState.eStage != eFLASH_STATE_IDLE)
	{
		Debug(eDBUG_LEVEL_ERROR,"[%d]Flash_earse:busy,return\r\n", GetTicks());
		return FALSE;
	}
	

	g_tSpiDevice.tState.bEraseChipReq = TRUE;
	return TRUE;	
}
/*****************************************************************************************                    									       	
º¯ÊýÃû³Æ:非同步擦除
º¯ÊýÃèÊö:Òì²½²ÁÖ¸¶¨µØÖ·
ÊäÈë²ÎÊý:                                  
Êä³ö²ÎÊý:                                                        
º¯Êý·µ»Ø: 
******************************************************************************************/
BOOL SPI_FlashEraseAsync(uint32_t uAddr, uint16_t wlen)
{
	//unsigned char cnt=0;     
	
	if(g_tSpiDevice.tState.eStage != eFLASH_STATE_IDLE)
	{
		Debug(eDBUG_LEVEL_ERROR,"[%d]Flash_earse:busy,return\r\n", GetTicks());
		return FALSE;
	}
	
	g_tSpiDevice.wTxLen = wlen;
	g_tSpiDevice.uTxDstAddr = uAddr;
	g_tSpiDevice.wTxOffset = 0;
	g_tSpiDevice.tState.bEraseSectorReq = TRUE;
	return TRUE;	
}
//註冊完成通知

void SPI_WriteAsyncNotifyCallbackRegister(void *pfn)
{
	g_tSpiDevice.pWriteAsyncNotifyCallback = (void (*)())pfn;
}
void SPI_EraseChipAsyncNotifyCallbackRegister(void *pfn)
{
	g_tSpiDevice.pEraseChipAsyncNotifyCallback = (void (*)())pfn;
}



//ÅÐ¶ÏSPI FLASH Ã¦
static BOOL SPI_FlashBusyCheck(void)
{
	if((SPI_Flash_Read_SR()&0x01)==0x01)
	{
		return TRUE;
	} 
	else 
	{
		return FALSE;
	}
}
//Ð´Ò»Ò³
static BOOL __SPI_FlashWritePage(uint32_t uWriteAddr, uint8_t *pData, uint16_t wWriteLen)
{
	uint8_t  cnt;
	uint16_t index;
	SPI_FLASH_Write_Enable();                  //SET WEL           
	while((SPI_Flash_Read_SR()&0x2)!=0x2) 
	{
		cnt ++;
		if(cnt >200)
			return FALSE;   /*·µ»ØÐ´Ê§°Ü*/
	} 
	SPI_CS_LOW();                            
	SPI_Flash_ReadWrite_Byte(PAGE_PRG);      
	SPI_Flash_ReadWrite_Byte((unsigned char)((uWriteAddr)>>16));   
	SPI_Flash_ReadWrite_Byte((unsigned char)((uWriteAddr)>>8));  
	SPI_Flash_ReadWrite_Byte((unsigned char)uWriteAddr); 
	for(index=0; index < wWriteLen; index++)
	{
		SPI_Flash_ReadWrite_Byte(*(pData+index)); 
	}
	SPI_CS_HIGH();
	return TRUE;
}
//Òì²½Ð´´¦Àí×ÓÈÎÎñ
static int32_t __SPI_FlashWrite(void)
{
	uint16_t wWriteRemainNum = g_tSpiDevice.wTxLen - g_tSpiDevice.wTxOffset;
	uint8_t *pData = g_tSpiDevice.pTxBuffer + g_tSpiDevice.wTxOffset;
	uint32_t uWriteAddr = g_tSpiDevice.uTxDstAddr + g_tSpiDevice.wTxOffset;
	uint16_t wPageRemain = PAGE_SIZE - (uWriteAddr % PAGE_SIZE);

	//ÅÐ¶ÏÐ´Íê³É
	if(wWriteRemainNum == 0)
	{
		//Ð´Íê³É
		g_tSpiDevice.tState.bTxCompleted = TRUE;
		//g_tSpiDevice.tState.bRxBusy = FALSE;
		g_tSpiDevice.tState.bTxReq = FALSE;
		g_tSpiDevice.tState.eStage = eFLASH_STATE_IDLE; //Ð´Íê³É ×ª¿ÕÏÐ
		if(g_tSpiDevice.pWriteAsyncNotifyCallback)
		{
			//TODO Òì²½Í¨Öª»Øµ÷ ¹©µ÷ÓÃÕßÊµÏÖ
			g_tSpiDevice.pWriteAsyncNotifyCallback();
		}
		return eSUCCESS;
	}		

	
	//Ð¡ÓÚÒ»Ò³Ê£Óà¿ÉÐ´×Ö½Ú
	if(wWriteRemainNum <= wPageRemain)
	{
		__SPI_FlashWritePage(uWriteAddr, pData, wWriteRemainNum);
		g_tSpiDevice.wTxOffset += wWriteRemainNum;
		//Ð´ÍêÊ£Óà
	}
	else 
	{
		__SPI_FlashWritePage(uWriteAddr, pData, wPageRemain);
		g_tSpiDevice.wTxOffset += wPageRemain;
		//Ð´Ò»ÕûÒ³£¬
	}
	//Òì²½¶ÁÃ¦
	g_tSpiDevice.tState.eStage = eFLASH_STATE_BUSY;
	return eSUCCESS;
}
//Òì²½¶ÁÃ¦×ÓÈÎÎñ
static void __SPI_FlashBusy(void)
{
	//¶ÁÃ¦ ·Ç×èÈû
	if(SPI_FlashBusyCheck())
	{
		return ;
	}
	//SPIÉÏ´Î²Ù×÷ÒÑÍê³É
	//TX process
	if(g_tSpiDevice.tState.bTxReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_WRITE;
	}
	//RX process
	// TODO ²Á³ýÒÑÍê³É
	if(g_tSpiDevice.tState.bEraseChipReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_ERASE_CHIP;
	}
	if(g_tSpiDevice.tState.bEraseSectorReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_ERASE;
	}
}
//Òì²½²Á³ý×ÓÈÎÎñ ÕûÆ¬
static int32_t __SPI_FlashEraseChip(void)
{
	uint8_t cnt = 0;
	SPI_FLASH_Write_Enable();                  //SET WEL
	if(g_tSpiDevice.tState.bEraseSuccess == TRUE)
	{
		g_tSpiDevice.tState.bEraseSuccess = FALSE;
		g_tSpiDevice.tState.bEraseChipReq = FALSE;
		g_tSpiDevice.tState.eStage = eFLASH_STATE_IDLE;//Ð´Íê³É ×ª¿ÕÏÐ
		if(g_tSpiDevice.pEraseChipAsyncNotifyCallback)
		{
			////TODO Òì²½Í¨Öª»Øµ÷ ¹©µ÷ÓÃÕßÊµÏÖ
			g_tSpiDevice.pEraseChipAsyncNotifyCallback();
		}
		return TRUE;
	}
	while((SPI_Flash_Read_SR()&0x2)!=0x2) 
	{
		cnt ++;
		if(cnt >200)
			return FALSE;
	}
	SPI_CS_LOW();                             
	SPI_Flash_ReadWrite_Byte(CHIP_ERASE);        
	SPI_CS_HIGH();                                         
	//SPI_Flash_Wait_Busy(); 
	g_tSpiDevice.tState.eStage = eFLASH_STATE_BUSY;//Òì²½¶ÁÃ¦
	return TRUE;
}
//Òì²½²Á³ý×ÓÈÎÎñ 
static int32_t __SPI_FlashErase(void)
{
	uint8_t cnt = 0;	
	//uint32_t uSectorIdxFirst = g_tSpiDevice.uTxDstAddr/SECTOR_SIZE;
	uint32_t uSectorIdxTail = (g_tSpiDevice.uTxDstAddr+g_tSpiDevice.wTxLen)/SECTOR_SIZE;
	uint32_t uCurrentSectorIdx = (g_tSpiDevice.uTxDstAddr + g_tSpiDevice.wTxOffset)/SECTOR_SIZE;
	
	if(uCurrentSectorIdx > uSectorIdxTail)
	{
		g_tSpiDevice.tState.bEraseSectorReq = FALSE;
		g_tSpiDevice.tState.bEraseSuccess = TRUE;
		g_tSpiDevice.tState.eStage = eFLASH_STATE_IDLE;//Ð´Íê³É ×ª¿ÕÏÐ
		if(g_tSpiDevice.pEraseChipAsyncNotifyCallback)
		{
			////TODO Òì²½Í¨Öª»Øµ÷ ¹©µ÷ÓÃÕßÊµÏÖ
			g_tSpiDevice.pEraseChipAsyncNotifyCallback();
		}
		return TRUE;
	}
	SPI_FLASH_Write_Enable();                  //SET WEL
	while((SPI_Flash_Read_SR()&0x2)!=0x2) 
	{
		cnt ++;
		if(cnt >200)
			return FALSE;
	}
	SPI_CS_LOW();                            
	SPI_Flash_ReadWrite_Byte(SECTOR_ERASE);      
	SPI_Flash_ReadWrite_Byte((unsigned char)((uCurrentSectorIdx*SECTOR_SIZE)>>16));   
	SPI_Flash_ReadWrite_Byte((unsigned char)((uCurrentSectorIdx*SECTOR_SIZE)>>8));  
	SPI_Flash_ReadWrite_Byte((unsigned char)(uCurrentSectorIdx*SECTOR_SIZE)); 
	SPI_CS_HIGH(); 
	g_tSpiDevice.wTxOffset += SECTOR_SIZE;
	//SPI_Flash_Wait_Busy(); 
	g_tSpiDevice.tState.eStage = eFLASH_STATE_BUSY;//Òì²½¶ÁÃ¦
	return TRUE;
}
//¿ÕÏÐ´¦Àí×ÓÈÎÎñ
static void __SPI_FlashIdle(void)
{
	//Æô¶¯¸÷ÏîÈÎÎñ
	if(g_tSpiDevice.tState.bTxReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_WRITE;
	} 
	else if(g_tSpiDevice.tState.bRxReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_READ;
	} 
	else if(g_tSpiDevice.tState.bEraseChipReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_ERASE_CHIP;
	}
	else if(g_tSpiDevice.tState.bEraseSectorReq == TRUE)
	{
		g_tSpiDevice.tState.eStage = eFLASH_STATE_ERASE;
	}
}
//SPIÒì²½²Ù×÷´¦Àí×ÜÈÎÎñ
void SPI_FlashAsyncProcTask(void)
{
	switch(g_tSpiDevice.tState.eStage)
	{
		case eFLASH_STATE_IDLE:
			__SPI_FlashIdle();
			break;
		case eFLASH_STATE_WRITE:
			__SPI_FlashWrite();
			break;
		case eFLASH_STATE_READ:
			//TODO
			break;
		case eFLASH_STATE_BUSY:
			__SPI_FlashBusy();
			break;
		case eFLASH_STATE_ERASE_CHIP:
			__SPI_FlashEraseChip();
			break;
		case eFLASH_STATE_ERASE:
			__SPI_FlashErase();
			break;
		default:
			break;
	}
	
}

SpiFlash同步/非同步讀寫微控制器裸機例項

微控制器裸機開發中會經常遇到外設速度過慢，長時間讀忙等待，但CPU又不能長時間阻塞的問題。這種問題可以通過實現一個狀態機來非同步處理。非同步狀態機程式碼結構示例： enum { eIDLE = 0, eSTART, eWAIT, eSUCCESS }; st

boost asio非同步讀寫網路聊天程式客戶端例項詳解

linux下aio非同步讀寫詳解與例項

1.為什麼會有非同步I/O aio非同步讀寫是在linux核心2.6之後才正式納入其標準。之所以會增加此模組，是因為眾所周知我們計算機CPU的執行速度遠大於I/O讀寫的執行速度，如果我們用傳統的阻塞式或非阻塞式來操作I/O的話，那麼我們在同一個程式中(不用多執

線程同步之讀寫鎖（鎖操作的補充）

允許資源加鎖函數申請 tex bject def 讀取輕量級的讀寫鎖（Slim Reader-Writer locks）：讀寫鎖實際是一種特殊的自旋鎖，它把對共享資源的訪問者劃分成讀者和寫者，讀者只對共享資源進行讀訪問，寫者則需要對共享資源進行寫操作。這種鎖相對於

MySQL主從同步與讀寫分離

修改配置 monit 相關流量修改配置文件 l數據庫 cli 授權 san MySQL主從同步MySQL AB復制1.對指定庫的異地同步。2.MySQL主-->從復制架構的實現。3.MySQL服務器的只讀控制。主從：單向復制時，建議將從庫設置為只讀。主從復制

Linux—Centos7.4之搭建Mysql數據庫主從同步、讀寫分離

搭建Mysql主從同步、讀寫分離MySQL主從同步與讀寫分離目錄第一部分實驗環境第二部分配置主從同步第三部分配置讀寫分離第四部分測試驗證第一部分實驗環境實驗拓撲圖：服務器五臺：1）客戶端服務器一臺：IP地址：192.168.80.10（client）需安裝軟件：mysql-bo

主從同步、讀寫分離、mysql性能調優(軟優化)

tab ren 主庫 its 使用命令 mysql lee 運行 lte 配置mysql主從同步1 主從同步的作用：讓slave身份的數據庫服務器自動同步 master身份的數據庫服務器上的數據。一、主數據庫服務器的配置192.168.4.121 用戶授權mysql&g

【純幹貨】Amoeba實現MySQL主從同步與讀寫分離

exec strong arc all abstract a star status utf prop 【純幹貨】Amoeba實現MySQL主從同步與讀寫分離一、簡介 amoeba簡介 Amoeba(變形蟲)項目,該開源框架於2008年開始發布一款 Amoeba f

主從庫同步與讀寫分離（百度雲教學視訊分享）

目錄一、理論解析二、教學視訊一、理論解析第一步，Master 及主伺服器將對資料的操作記錄到二進位制日誌當中（Binary log）當中。在每個事務更新資料完成之前，Master 在日誌裡記錄這些改變，MySql 將日誌序列的寫入二進位制當中，在事

17.執行緒同步：讀寫鎖rwlock

1.讀寫鎖讀鎖：共享寫鎖：獨佔 1.多個執行緒可以對同一個共享資源加[讀鎖] 2.但是隻要有一個[寫鎖]到來，後面申請的鎖全部會阻塞 3.寫鎖優先：防止[寫操作]一直等待下去當已經加了讀鎖，此時再來了寫鎖請求，之後又來了讀鎖請求====>後面到來的讀鎖請求不能請求成功，只

用API實現串列埠非同步讀寫

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

swoole之非同步讀寫

// 非同步讀取檔案內容 swoole_async_readfile(__DIR__."/1.txt", function($filename, $content) { echo "$filename: $content"; }); //非同步寫入檔案 $file_co

Java併發程式設計鎖的分類-以及讀寫鎖的例項

1.可重入鎖： 1)概念：鎖具備可重入性，則稱為可重入鎖；可重入性表明了鎖的分配機制，是基於執行緒分配的，而不是基於方法呼叫分配的； &n

Linux 學習筆記—執行緒同步之讀寫鎖、自旋鎖、屏障

3.2.1 讀寫鎖讀寫鎖和互斥體類似，不過讀寫鎖有更高的並行性，互斥體要麼是鎖住狀態，要麼是不加鎖狀態，而且一次只有一個執行緒可以對其加鎖。而讀寫鎖可以有3個狀態，讀模式下鎖住狀態，寫模式下鎖住狀態，不加鎖狀態。一次只有一個執行緒可以佔有寫模式的讀寫鎖，但是多

Redis主從同步，讀寫分離設定

本文介紹使用Redis的主從同步功能(master, slave)，使程式實現讀寫分離，避免io瓶頸，提高資料讀寫效率。 Redis支援一個master伺服器對多個slave伺服器同步，同步使用釋出/訂閱機制。 1個master對多個slave，還可以進行分

mariadb的主從同步和讀寫分離

資料庫的優化設計對以後web專案能否承擔高併發所帶來的巨大負擔是個非常好的解決方案。主從同步和讀寫分離就是個常用的方法，主資料庫用來寫入資料，從資料庫用來查詢，分擔了主資料庫的一大部分工作，這樣做的好處是當主伺服器崩了之後，還是在從伺服器上獲取到資料，起到

boost asio非同步讀寫網路聊天室【官方示例】

mysql主從同步及讀寫分離

mysql主從同步作用：可以對指定的資料庫進行異地同步可以實現主從複製架構可以對指定伺服器的只讀控制同步原理 master slave 啟用兩個執行緒

Python多執行緒同步---檔案讀寫控制

1、實現檔案讀寫的檔案ltz_schedule_times.py #! /usr/bin/env python #coding=utf-8 import os def ReadTimes():

主從同步與讀寫分離

一、基本概念通過主從複製的方式來同步資料，再通過讀寫分離來提升資料庫的併發負載能力 1. 主從同步： 1）主從同步使得資料可以從一個數據庫伺服器複製到其他伺服器上，在複製資料時，一個伺服器充當主伺服器（master），其餘的伺服器充當從伺服器（slave） 2）因為複製是

SpiFlash同步/非同步讀寫微控制器裸機例項

相關推薦