//------------------------------------------------------------------------------
// Copy flash function to RAM.
//------------------------------------------------------------------------------
void Upgrade(void)
{
unsigned char *flash_start_ptr; // Initialize pointers
unsigned char *flash_end_ptr;
unsigned char *RAM_start_ptr;
if (CheckUpgrade() != 0xff)
return;
//Initialize flash and ram start and end address
flash_start_ptr = (unsigned char *)__segment_begin("FLASHCODE");
flash_end_ptr = (unsigned char *)__segment_end("FLASHCODE");
RAM_start_ptr = (unsigned char *)__segment_begin("RAMCODE");
//calculate function size
unsigned long function_size = (unsigned long)(flash_end_ptr) - (unsigned long)(flash_start_ptr);
// Copy flash function to RAM
printf("Copy From %p to %p size=%ld\n", flash_start_ptr, RAM_start_ptr, function_size);
memcpy(RAM_start_ptr,flash_start_ptr,function_size);
motor_on(0, 0);
printf("Jump to %p\n", FlashFirmware);
// remove the flag of firmware
struct _header h;
SPI_FLASH_BufferRead((void*)&h, FIRMWARE_BASE, sizeof(h));
SPI_FLASH_BufferWrite((void*)&h, FIRMWARE_BASE + h.length + 2 * sizeof(h), sizeof(h));
FlashFirmware();
}
void drv_FlashChipWriteDatas(uint8_t *pData)
{
uint32_t dwOffset;
dwOffset = *pData++;
dwOffset <<= 8;
dwOffset += *pData++;
dwOffset <<= 8;
dwOffset += *pData++;
dwOffset <<= 8;
dwOffset += *pData++;
#if 0
if ((dwOffset & 0x0000FFFF) == 0)
{
SPI_FLASH_SectorErase(dwOffset);
}
#else
if ((dwOffset & 0x00000FFF) == 0) /*4 K擦写*/
{
SPI_FLASH_SectorErase(dwOffset);
}
#endif
SPI_FLASH_BufferWrite(pData, dwOffset, 32);
}
/*
* 函数名：main
* 描述 ：主函数
* 输入 ：无
* 输出 ：无
*/
int main(void)
{
uint8_t k;
/* 配置串口1为：115200 8-N-1 */
USART1_Config();
printf("\r\n 这是一个2M串行flash(W25Q16)实验 \r\n");
/* 2M串行flash W25X16初始化 */
SPI_FLASH_Init();
/* Get SPI Flash Device ID */
DeviceID = SPI_FLASH_ReadDeviceID();
Delay( 200 );
/* Get SPI Flash ID */
FlashID = SPI_FLASH_ReadID();
printf("\r\n FlashID is 0x%X, Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);
/* Check the SPI Flash ID */
if (FlashID == sFLASH_ID) /* #define sFLASH_ID 0xEF3015 */
{
printf("\r\n 检测到华邦串行flash W25Q16 !\r\n");
/* Erase SPI FLASH Sector to write on */
SPI_FLASH_SectorErase(FLASH_SectorToErase);
/* 将发送缓冲区的数据写到flash中 */
SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);
for( k=0; k<6; k++ )
printf("\r\n 写入的数据为：%d \r\n", Tx_Buffer[k]);
/* 将刚刚写入的数据读出来放到接收缓冲区中 */
SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
for( k=0; k<6; k++ )
printf("\r\n 读出的数据为：%d \r\n", Tx_Buffer[k]);
/* 检查写入的数据与读出的数据是否相等 */
TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
if( PASSED == TransferStatus1 )
{
printf("\r\n 2M串行flash(W25Q16)测试成功!\n\r");
}
else
{
printf("\r\n 2M串行flash(W25Q16)测试失败!\n\r");
}
}// if (FlashID == sFLASH_ID)
else
{
printf("\r\n 获取不到 W25Q16 ID!\n\r");
}
SPI_Flash_PowerDown();
while(1);
}
static rt_size_t rt_SpiFlash_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
//SPI_FLASH_ProtectSW (0);
//rt_thread_delay(5);
SPI_FLASH_BufferWrite((uint8_t *)buffer, pos, size);
//SPI_FLASH_ProtectSW (1);
return size;
}
char BSL430_writeMemory(unsigned long startAddr, unsigned int size, char* data)
{
unsigned long i;
char exceptions = SUCCESSFUL_OPERATION;
SPI_FLASH_BufferWrite(data, startAddr, size);
return exceptions;
}
void Task_Record()
{
static uint8 OldMin=0xff;
if((UIShowValue.DateTime.Min%5==0)|(OldMin==0xff))
{
if(OldMin!=UIShowValue.DateTime.Min)if(UIShowValue.RecordCount<0xff)
{
HistoryRecord HR;
BufferCoppy(&UIShowValue.DateTime,&HR.DT,sizeof(UIShowValue.DateTime));
BufferCoppy(&UIShowValue.CH_Value,&HR.CH_Value,sizeof(UIShowValue.CH_Value));
SPI_FLASH_BufferWrite((uint8*)&HR, (uint32)UIShowValue.RecordCount*sizeof(HR)+RECORDADDR, sizeof(HR));
UIShowValue.RecordCount++;
}
OldMin=UIShowValue.DateTime.Min;
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
RCC_Configuration();
SPI1_Flash_GPIO_Configuration();
SPI1_Flash_Configuration();
/* Get Flash ID */
FlashID =SPI_FLASH_ReadID();
if(sFLASH_ID== FlashID )
{
/* Erase SPI FLASH Sector */
SPI_FLASH_SectorErase(FLASH_WriteAddress);
/* Write Buffer_Tx to SPI FLASH */
SPI_FLASH_BufferWrite(Buffer_Tx,FLASH_WriteAddress,BufferSize);
/* Read data from SPI FLASH */
SPI_FLASH_BufferRead (Buffer_Rx,FLASH_ReadAddress,BufferSize);
/* if TransferStatus1 =PASSED, the Flash write and read operation are correct£¬
if TransferStatus1 =FAILED, the Flash write and read operation are failed */
TransferStatus1 = Buffercmp(Buffer_Tx, Buffer_Rx, BufferSize);
/* Erase SPI FLASH Sector */
SPI_FLASH_SectorErase(FLASH_WriteAddress);
/* Read data from SPI FLASH */
SPI_FLASH_BufferRead(Buffer_Rx, FLASH_ReadAddress, BufferSize);
for (Index = 0; Index < BufferSize; Index++)
{
if (Buffer_Rx[Index] != 0xFF)
{
/* if TransferStatus2 =PASSED, the Flash erase and read operation are correct£¬
if TransferStatus2 =FAILED, the Flash erase and read operation are failed */
TransferStatus2 = FAILED;
}
}
}
while (1)
{
}
}
void Geek_CheckUpdate(USART_TypeDef* USARTx)
{
uint8 Length;
Geek_DatStruct *GDS;
uint8 Buf[100];
uint8 UsartCH=USART_GetIndex(USARTx);
Length=USART_ReadDatas(USARTx,USART_TX_Buffer[UsartCH],USART_RX_BUFFER_SIZE,SPASETIME);
Geek_Send(USARTx,0x01,0xaa,Null,Null,Null,0);
if(Export_Message(USART_TX_Buffer[UsartCH],Length))
{
GDS=(Geek_DatStruct *)USART_TX_Buffer[UsartCH];
switch(GDS->Cmd)
{
case GC_Erase:break;
case GC_Stop:break;
case GC_Run:break;
case GC_Write:SPI_FLASH_BufferWrite(GDS->Buf,GDS->Tags1,GDS->Length);
Geek_Send(USARTx,HOSTADDRESS,GC_Success,Null,Null,Null,0);break;
case GC_Read:SPI_FLASH_BufferRead(&Buf[0],GDS->Tags2,GDS->Tags2);
Geek_Send(USARTx,HOSTADDRESS,GC_Data,GDS->Tags2,GDS->Tags2,&Buf[0],GDS->Tags2);break;
}
}
}
void WriteFirmware(void* data, uint32_t offset, int size)
{
SPI_FLASH_BufferWrite(data, offset + FIRMWARE_BASE, size);
}
