jfmartel/ChaletLora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bootloader dev

Browse Source
This commit is contained in:
jfmartel 2021-07-05 21:17:33 -04:00
parent e28b725a8b
commit dd3e8a4a29
14 changed files with 8366 additions and 7688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

346
ChaletLora.X/Source/BootloaderInterface.c
View File

@ -6,15 +6,37 @@
#include "BoardCfg.h"
#include "timer.h"
#include "WiFiCtrl.h"
#include "SPI_Flash.h"
#include "FlashMapping.h"
#include "NetworkProtocol.h"
char BootloaderBuffer[200];
#define BOOTLOADER_FLASH_ERASE_POLL_TIMEOUT 25//100 //ms
#define BOOTLOADER_FLASH_ERASE_MAX_POLL_COUNT 40//10 //One sector should not take more than 1s to erase...
#define BOOTLOADER_FLASH_WRITE_POLL_TIMEOUT 25//100 //ms
#define BOOTLOADER_FLASH_WRITE_MAX_POLL_COUNT 40//10 //One sector should not take more than 1s to erase...
char BootloaderBuffer[300];
int BootloaderInterfaceState;
int BootloaderFlashErased;
int ReadyToReceiveData;
int DataChunkWritten;
int CurDataChunkIndex;
int FirmwareUploaded;
int CurDataChunkSize;
int BooloaderFlashEraseState;
int BootloaderFlashErased;
unsigned int BootloaderCurFlashEraseAddress;
int BooloaderFlashErasePollCount;
int BootloaderFlashWriteState;
unsigned int BootloaderCurFlashWriteAddress;
int BootloaderFlashWritePollCount;
int BootloaderFirmwareChunkWriteCount;
char* BootloaderFlashWriteDataPtr;
int BootloaderInterfaceInit()
{
@ -123,7 +145,7 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
break;
}
}
break;
}
case BOOTLOADER_ACTIVE_STATE:
@ -140,18 +162,25 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
{
case BOOTLOADER_SM_ERASE_FLASH_CMD:
{
//TODO: Start flash erase process
BootloaderProtocolSendACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_REQUEST);
ResetBootloaderFlashEraseStateMachine(); //Setup the state machine
BootloaderProtocolSendACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_RESPONSE);
BootloaderInterfaceState = BOOTLOADER_ERASE_FLASH_STATE;
printf("Bootloader Interface going into Erase Flash state\n");
break;
}
case BOOTLOADER_SM_INIT_UPLOAD_CMD:
{
BootloaderProtocolSendInitUploadResponse();
BootloaderInterfaceState = BOOTLOADER_RECEIVING_FIRMWARE_STATE;
printf("Bootloader Interface going into Firmware RX state\n");
ReadyToReceiveData = 1; //TODO: Manage this flag in flash SM
if(BootloaderFlashErased == 0)
{
BootloaderProtocolSendInitUploadResponse(BOOTLOADEDR_INIT_TRANSFER_ERROR_FLASH_NOT_ERASED);
}
else
{
BootloaderProtocolSendInitUploadResponse(BOOTLOADEDR_INIT_TRANSFER_OK);
BootloaderInterfaceState = BOOTLOADER_RECEIVING_FIRMWARE_STATE;
printf("Bootloader Interface going into Firmware RX state\n");
}
break;
}
case BOOTLOADER_SM_ABORT_CMD:
@ -161,6 +190,20 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
BootloaderResetStateMachine();
break;
}
case BOOTLOADER_SM_EXECUTE_UPGRAGE_CMD:
{
if(FirmwareUploaded == 1)
{
//TODO: Do that!
BootloaderProtocolSendACK(BOOTLOADER_EXECUTE_UPGRADE_RESPONSE);
printf("Bootloader will now upgrade and reboot!!\n");
}
else
{
BootloaderProtocolSendNACK(BOOTLOADER_EXECUTE_UPGRADE_RESPONSE);
printf("Bootloader upgrade request denied: Firmware not uploaded\n");
}
}
}
default:
{
@ -182,11 +225,38 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
{
case BOOTLOADER_TICK_EVENT:
{
//TODO: Check flash erase operation.
BootloaderFlashErased = 1;
printf("Flash erase finished. Bootloader Interface going into Active state\n");
BootloaderProtocolSendACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_RESULT_RESPONSE); //TODO: send result instead
BootloaderInterfaceState = BOOTLOADER_ACTIVE_STATE;
int res = BootloaderFlashEraseStateMachine(BOOTLOADER_FLASH_ERASE_SM_TICK_EVENT);
switch(res)
{
case BOOTLOADER_FLASH_ERASE_RUNNING_RES:
{
break;
}
case BOOTLOADER_FLASH_ERASE_FINISHED_RES:
{
printf("Flash erase finished. Bootloader Interface going into Active state\n");
BootloaderProtocolSendACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_RESULT_RESPONSE); //TODO: send result instead
BootloaderInterfaceState = BOOTLOADER_ACTIVE_STATE;
BootloaderFlashErased = 1;
break;
}
case BOOTLOADER_FLASH_ERASE_ERROR_RES:
{
printf("Flash erase error. Bootloader Interface going into Active state\n");
BootloaderProtocolSendNACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_RESULT_RESPONSE); //TODO: send result instead
BootloaderInterfaceState = BOOTLOADER_ACTIVE_STATE;
break;
}
case BOOTLOADER_FLASH_ERASE_ABORT_RES:
{
printf("Flash erase abort. Bootloader Interface going into Active state\n");
BootloaderProtocolSendNACK(BOOTLOADER_ERASE_BOOTLOADER_FLASH_RESULT_RESPONSE); //TODO: send result instead
BootloaderInterfaceState = BOOTLOADER_ACTIVE_STATE;
break;
}
}
break;
}
case BOOTLOADER_NEW_CMD_EVENT:
@ -197,7 +267,8 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
{
//TODO: stop erasing and reset SM.
//TODO invalidate data in Flash
printf("Aborting upload, going into STANDBY mode\n");
BootloaderFlashEraseStateMachine(BOOTLOADER_FLASH_ERASE_SM_ABORT_EVENT);
printf("Aborting Flash erase, going into STANDBY mode\n");
BootloaderResetStateMachine();
break;
}
@ -218,20 +289,33 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
{
case BOOTLOADER_TICK_EVENT:
{
//TODO: Manage flash writing process
if(ReadyToReceiveData == 1) //TODO: replace this with flash SM result
int res = BootloaderFlashWriteStateMachine(BOOTLOADER_FLASH_WRITE_SM_NEW_BUFFER_EVENT);
switch(res)
{
ReadyToReceiveData = 0;
printf("Bootloader Interface ready to receive data\n");
BootloaderProtocolSendACK(BOOTLOADER_READY_FOR_DATA_RESPONSE);
case BOOTLOADER_FLASH_WRITING_RES:
{
break;
}
case BOOTLOADER_FLASH_WRITE_FINISHED_RES:
{
BootloaderProtocolSendDataChunkResult(BOOTLOADER_CHUNK_TRANSFER_SUCCESS,CurDataChunkIndex);
printf("Bootloader Chunk %d successfuly written to flash\n",CurDataChunkIndex);
CurDataChunkIndex++;
break;
}
case BOOTLOADER_FLASH_WRITE_ERROR_RES:
{
BootloaderProtocolSendDataChunkResult(BOOTLOADER_CHUNK_TRANSFER_ERROR_FLASH_ERROR,CurDataChunkIndex);
BootloaderResetStateMachine();
printf("Bootloader Flash write error. Aborting and going into STANDBY state\n");
break;
}
case BOOTLOADER_FLASH_WRITE_ABORT_RES:
{
break;
}
}
if(DataChunkWritten == 1)
{
DataChunkWritten = 0;
BootloaderProtocolSendDataChunkResult(BOOTLOADER_CHUNK_TRANSFER_SUCCESS,CurDataChunkIndex);
CurDataChunkIndex++;
}
break;
}
case BOOTLOADER_NEW_CMD_EVENT:
@ -247,6 +331,8 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
//Extract index from buffer
int DataChunkIndex = 0;
int DataChunkSize = 0;
DataChunkSize = 0;
DataChunkIndex = BootloaderBuffer[0];
DataChunkIndex <<= 8;
DataChunkIndex += BootloaderBuffer[1];
@ -263,21 +349,25 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
DataChunkSize <<= 8;
DataChunkSize += BootloaderBuffer[7];
BootloaderFlashWriteDataPtr = &BootloaderBuffer[8];
//Check CRC
//if(CurDataChunkIndex != DataChunkIndex)
if(0)
if(CurDataChunkIndex != DataChunkIndex)
{
//Error... abort.
BootloaderProtocolSendDataChunkResult(BOOTLOADER_CHUNK_TRANSFER_ERROR_INVALID_CHUNK_INDEX,CurDataChunkIndex);
printf("Bootloader Interface ABORTING UPLOAD. Received invalid chunk index. Rx: [%d] - Expected: [%d]\n", DataChunkIndex,CurDataChunkIndex);
BootloaderResetStateMachine();
ResetBootloaderFlashWriteStateMachine();
}
else
{
CurDataChunkSize = DataChunkSize;
BootloaderFlashWriteStateMachine(BOOTLOADER_FLASH_WRITE_SM_NEW_BUFFER_EVENT);
}
DataChunkWritten = 1; //For debug only.
break;
}
@ -296,7 +386,8 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
case BOOTLOADER_SM_ABORT_CMD:
{
//TODO invalidate data in Flash
printf("Aborting upload, going into STANDBY mode\n");
printf("Bootloader aborting firmware download. Going back to STANDBY state\n");
BootloaderFlashWriteStateMachine(BOOTLOADER_FLASH_WRITE_SM_ABORT_EVENT);
BootloaderResetStateMachine();
break;
}
@ -354,11 +445,16 @@ void BootloaderIterfaceStateMachine(int Event, int Param)
void BootloaderResetStateMachine()
{
BootloaderInterfaceState = BOOTLOADER_STANDBY_STATE;
BootloaderFlashErased = 0;
ReadyToReceiveData = 0;
DataChunkWritten = 0;
CurDataChunkIndex = 0;
FirmwareUploaded = 0;
CurDataChunkIndex = 0;
FirmwareUploaded = 0;
CurDataChunkSize = 0;
ResetBootloaderFlashEraseStateMachine();
ResetBootloaderFlashWriteStateMachine();
}
void BootloaderActivateBootloader()
@ -370,4 +466,178 @@ void BootloaderDeactivateBootloader()
{
CloseBootloaderServer();
BootloaderIterfaceStateMachine(BOOTLOADER_SM_ABORT_CMD,0);
}
int BootloaderFlashEraseStateMachine(int event)
{
if(event == BOOTLOADER_FLASH_ERASE_SM_ABORT_EVENT)
{
ResetBootloaderFlashEraseStateMachine();
return BOOTLOADER_FLASH_ERASE_ABORT_RES;
}
switch(BooloaderFlashEraseState)
{
case BOOTLOADER_FLASH_ERASE_SECTOR_STATE:
{
if(SPIFlashErase64KSector(BootloaderCurFlashEraseAddress,0) == RET_ERROR)
{
printf("Bootloader Interface Erasing sector %0x%x\n", BootloaderCurFlashEraseAddress);
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_ERROR_STATE;
return BOOTLOADER_FLASH_ERASE_ERROR_RES;
}
BooloaderFlashErasePollCount = 0;
TimerStart(BOOTLOADER_FLASH_POLL_TIMER,BOOTLOADER_FLASH_ERASE_POLL_TIMEOUT);
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_WAIT_FOR_SECTOR_DONE;
break;
}
case BOOTLOADER_FLASH_ERASE_WAIT_FOR_SECTOR_DONE:
{
if(IsTimerExpired(BOOTLOADER_FLASH_POLL_TIMER) == 1)
{
if(SPIFlashCheckBusy() == 0) //sector erased
{
if(BootloaderCurFlashEraseAddress == FLASH_BTLDR_FIRMWARE_LAST_64K_SECTOR_ADD)
{
//Whole bootloader partition is erased.
printf("Bootloader Interface: Last sector 0x%x erased after %d polls\n",BootloaderCurFlashEraseAddress,BooloaderFlashErasePollCount);
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_FINISHED_STATE;
return BOOTLOADER_FLASH_ERASE_FINISHED_RES;
break;
}
else
{
printf("Bootloader Interface sector 0x%x erased after %d polls\n",BootloaderCurFlashEraseAddress,BooloaderFlashErasePollCount);
BootloaderCurFlashEraseAddress += SPI_FLASH_64K_SECTOR_SIZE;
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_SECTOR_STATE;
}
}
else
{
if(BooloaderFlashErasePollCount >= BOOTLOADER_FLASH_ERASE_MAX_POLL_COUNT)
{
printf("Bootloader Interface Flash erase error. Max poll count reached : %d!!!\n",BooloaderFlashErasePollCount);
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_ERROR_STATE;
return BOOTLOADER_FLASH_ERASE_ERROR_RES;
}
else
{
TimerStart(BOOTLOADER_FLASH_POLL_TIMER,BOOTLOADER_FLASH_ERASE_POLL_TIMEOUT);
BooloaderFlashErasePollCount++;
}
}
}
break;
}
case BOOTLOADER_FLASH_ERASE_CHECKBACK_STATE:
{
break;
}
case BOOTLOADER_FLASH_ERASE_FINISHED_STATE:
{
return BOOTLOADER_FLASH_ERASE_FINISHED_RES;
break;
}
case BOOTLOADER_FLASH_ERASE_ERROR_STATE:
{
return BOOTLOADER_FLASH_ERASE_ERROR_RES;
break;
}
}
return BOOTLOADER_FLASH_ERASE_RUNNING_RES;
}
int ResetBootloaderFlashEraseStateMachine()
{
BooloaderFlashEraseState = BOOTLOADER_FLASH_ERASE_SECTOR_STATE;
BootloaderCurFlashEraseAddress = FLASH_BTLDR_FIRMWARE_START_ADDRESS;
BooloaderFlashErasePollCount = 0;
BootloaderFlashErased = 0;
}
int BootloaderFlashWriteStateMachine(int event)
{
switch(BootloaderFlashWriteState)
{
case BOOTLOADER_FLASH_WRITE_STANDBY_STATE:
{
if(event == BOOTLOADER_FLASH_WRITE_SM_NEW_BUFFER_EVENT)
{
BootloaderFlashWriteState = BOOTLOADER_FLASH_WRITE_BUFFER_STATE;
BootloaderFirmwareChunkWriteCount = 0;
}
}
case BOOTLOADER_FLASH_WRITE_BUFFER_STATE:
{
if(BootloaderFlashWriteDataPtr == 0)
{
ResetBootloaderFlashWriteStateMachine();
return BOOTLOADER_FLASH_WRITE_ERROR_RES;
}
while(BootloaderFirmwareChunkWriteCount <= CurDataChunkSize)
{
if(SPIFlashWriteByte(BootloaderCurFlashWriteAddress,*BootloaderFlashWriteDataPtr++,0) == RET_ERROR)
{
printf("Bootloader flash error. Aborting and going back to STANDBY\n");
BootloaderFlashWriteState = BOOTLOADER_FLASH_WRITE_ERROR_STATE;
return BOOTLOADER_FLASH_WRITE_ERROR_RES;
}
int cnt = 0;
while(1)
{
if(SPIFlashCheckBusy() == 0)
{
break;
}
if(cnt++ > 200)
{
printf("Bootloader flash write timeout error. Aborting and going back to STANDBY\n");
BootloaderFlashWriteState = BOOTLOADER_FLASH_WRITE_ERROR_STATE;
return BOOTLOADER_FLASH_WRITE_ERROR_RES;
}
}
BootloaderFirmwareChunkWriteCount++;
}
BootloaderFlashWriteState = BOOTLOADER_FLASH_WRITE_STANDBY_STATE;
return BOOTLOADER_FLASH_WRITE_FINISHED_RES;
break;
}
case BOOTLOADER_FLASH_WRITE_WAIT_FOR_BYTE_DONE:
{
break;
}
case BOOTLOADER_FLASH_WRITE_CHECKBACK_STATE:
{
break;
}
case BOOTLOADER_FLASH_WRITE_FINISHED_STATE:
{
return BOOTLOADER_FLASH_WRITE_FINISHED_RES;
break;
}
case BOOTLOADER_FLASH_WRITE_ERROR_STATE:
{
return BOOTLOADER_FLASH_WRITE_ERROR_RES;
break;
}
}
}
int ResetBootloaderFlashWriteStateMachine()
{
BootloaderFlashWriteState = BOOTLOADER_FLASH_WRITE_BUFFER_STATE;
BootloaderCurFlashWriteAddress = FLASH_BTLDR_FIRMWARE_START_ADDRESS;
BootloaderFlashWritePollCount = 0;
BootloaderFirmwareChunkWriteCount = 0;
BootloaderFlashWriteDataPtr = 0;
BootloaderFirmwareChunkWriteCount = 0;
}

68
ChaletLora.X/Source/BootloaderInterface.h
View File

@ -29,6 +29,67 @@ enum eBootloaderStateMachineEvents
BOOTLOADER_MAX_EVENT
};
enum eBootloaderFlashEraseStates
{
BOOTLOADER_FLASH_ERASE_SECTOR_STATE,
BOOTLOADER_FLASH_ERASE_WAIT_FOR_SECTOR_DONE,
BOOTLOADER_FLASH_ERASE_CHECKBACK_STATE,
BOOTLOADER_FLASH_ERASE_FINISHED_STATE,
BOOTLOADER_FLASH_ERASE_ERROR_STATE,
BOOTLOADER_FLASH_ERASE_MAX_STATE
};
enum eBootloaderFlashEraseResults
{
BOOTLOADER_FLASH_ERASE_RUNNING_RES,
BOOTLOADER_FLASH_ERASE_FINISHED_RES,
BOOTLOADER_FLASH_ERASE_ERROR_RES,
BOOTLOADER_FLASH_ERASE_ABORT_RES,
BOOTLOADER_FLASH_ERASE_MAX_RES
};
enum eBootloaderFlahsEraseSMEvents
{
BOOTLOADER_FLASH_ERASE_SM_TICK_EVENT,
BOOTLOADER_FLASH_ERASE_SM_ABORT_EVENT,
BOOTLOADER_FLASH_ERASE_SM_MAX_EVENT
};
enum eBootloaderFlashWriteStates
{
BOOTLOADER_FLASH_WRITE_STANDBY_STATE,
BOOTLOADER_FLASH_WRITE_BUFFER_STATE,
BOOTLOADER_FLASH_WRITE_WAIT_FOR_BYTE_DONE,
BOOTLOADER_FLASH_WRITE_CHECKBACK_STATE,
BOOTLOADER_FLASH_WRITE_FINISHED_STATE,
BOOTLOADER_FLASH_WRITE_ERROR_STATE,
BOOTLOADER_FLASH_WRITE_MAX_STATE
};
enum eBootloaderFlashWriteResults
{
BOOTLOADER_FLASH_WRITING_RES,
BOOTLOADER_FLASH_WRITE_FINISHED_RES,
BOOTLOADER_FLASH_WRITE_ERROR_RES,
BOOTLOADER_FLASH_WRITE_ABORT_RES,
BOOTLOADER_FLASH_WRITE_MAX_RES
};
enum eBootloaderFlahsWriteSMEvents
{
BOOTLOADER_FLASH_WRITE_SM_TICK_EVENT,
BOOTLOADER_FLASH_WRITE_SM_NEW_BUFFER_EVENT,
BOOTLOADER_FLASH_WRITE_SM_ABORT_EVENT,
BOOTLOADER_FLASH_WRITE_SM_MAX_EVENT
};
enum eBootloaderStateMachineCmds
{
BOOTLOADER_SM_ACTIVATE_CMD,
@ -42,7 +103,7 @@ enum eBootloaderStateMachineCmds
};
extern char BootloaderBuffer[200];
extern char BootloaderBuffer[300];
int BootloaderInterfaceInit();
void BootloaderExecuteCmd(char Cmd);
@ -56,6 +117,11 @@ void BootloaderResetStateMachine();
void BootloaderActivateBootloader();
void BootloaderDeactivateBootloader();
int BootloaderFlashEraseStateMachine(int event);
int ResetBootloaderFlashEraseStateMachine();
int BootloaderFlashWriteStateMachine(int event);
int ResetBootloaderFlashWriteStateMachine();

361
ChaletLora.X/Source/BootloaderProtocol.c
View File

@ -43,184 +43,184 @@ void BootloaderProtocolStateMachine(unsigned char Data)
{
switch(BootloaderState)
{
case Initialization: //Reset all pointers and data...
{
BootloaderDataSize = 0;
BootloaderBufPtr = 0;
BootloaderCommand = 0;
BootloaderCRC = 0;
BootloaderState = RxHeader1;
break;
}
case RxHeader1: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xDE
if(Data == BOOTLOADER_FRAME_HEADER_1)
case Initialization: //Reset all pointers and data...
{
BootloaderState = RxHeader2;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
case RxHeader2: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xAD
if(Data == BOOTLOADER_FRAME_HEADER_2)
{
BootloaderState = RxHeader3;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
case RxHeader3: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xBE
if(Data == BOOTLOADER_FRAME_HEADER_3)
{
BootloaderState = RxHeader4;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
case RxHeader4: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xEF
if(BootloaderHeader != BOOTLOADER_FRAME_HEADER)
{
//TODO, send NACK?
BootloaderProtocolResetStateMachine();
BootloaderDataSize = 0;
BootloaderBufPtr = 0;
BootloaderCommand = 0;
BootloaderCRC = 0;
BootloaderState = RxHeader1;
break;
}
else
case RxHeader1: //Wait for data header...
{
BootloaderState = RxCmd;
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xDE
if(Data == BOOTLOADER_FRAME_HEADER_1)
{
BootloaderState = RxHeader2;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
break;
}
case RxCmd:
{
BootloaderCommand = Data;
BootloaderState = RxPayloadSize1;
break;
}
case RxPayloadSize1:
{
BootloaderDataSize = Data;
BootloaderState = RxPayloadSize2;
break;
}
case RxPayloadSize2:
{
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
BootloaderState = RxPayloadSize3;
break;
}
case RxPayloadSize3:
{
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
BootloaderState = RxPayloadSize4;
break;
}
case RxPayloadSize4:
{
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
if(BootloaderDataSize > MAX_BOOTLOADER_PAYLOAD_SIZE)
case RxHeader2: //Wait for data header...
{
//TODO, send NACK?
BootloaderProtocolResetStateMachine();
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xAD
if(Data == BOOTLOADER_FRAME_HEADER_2)
{
BootloaderState = RxHeader3;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
case RxHeader3: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xBE
if(Data == BOOTLOADER_FRAME_HEADER_3)
{
BootloaderState = RxHeader4;
}
else
{
BootloaderProtocolResetStateMachine();
}
break;
}
case RxHeader4: //Wait for data header...
{
BootloaderHeader <<= 8;
BootloaderHeader += Data; //0xEF
if(BootloaderHeader != BOOTLOADER_FRAME_HEADER)
{
//TODO, send NACK?
BootloaderProtocolResetStateMachine();
break;
}
else
{
BootloaderState = RxCmd;
}
break;
}
case RxCmd:
{
BootloaderCommand = Data;
BootloaderState = RxPayloadSize1;
break;
}
if(BootloaderDataSize == 0)
case RxPayloadSize1:
{
BootloaderState = RxCRC1;
BootloaderDataSize = Data;
BootloaderState = RxPayloadSize2;
break;
}
else
case RxPayloadSize2:
{
BootloaderState = RxPayload;
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
BootloaderState = RxPayloadSize3;
break;
}
break;
}
case RxPayload: //Data size
{
*BootloaderRxPtr = Data;
BootloaderRxPtr++;
BootloaderDataCtr++;
if(BootloaderDataCtr == BootloaderDataSize)
case RxPayloadSize3:
{
BootloaderState = RxCRC1;
break;
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
BootloaderState = RxPayloadSize4;
break;
}
break;
}
case RxCRC1: //Data size
{
BootloaderCRC = Data;
BootloaderState = RxCRC2;
break;
}
case RxCRC2: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC3;
break;
}
case RxCRC3: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC4;
break;
}
case RxCRC4: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC3;
//TODO: Compute and Compare CRC.
if(BootloaderCRC != 0xBAADCAFE)
case RxPayloadSize4:
{
BootloaderDataSize <<= 8;
BootloaderDataSize += Data;
if(BootloaderDataSize > MAX_BOOTLOADER_PAYLOAD_SIZE)
{
//TODO, send NACK?
BootloaderProtocolResetStateMachine();
break;
}
if(BootloaderDataSize == 0)
{
BootloaderState = RxCRC1;
}
else
{
BootloaderState = RxPayload;
}
break;
}
case RxPayload: //Data size
{
*BootloaderRxPtr = Data;
BootloaderRxPtr++;
BootloaderDataCtr++;
if(BootloaderDataCtr == BootloaderDataSize)
{
BootloaderState = RxCRC1;
break;
}
break;
}
case RxCRC1: //Data size
{
BootloaderCRC = Data;
BootloaderState = RxCRC2;
break;
}
case RxCRC2: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC3;
break;
}
case RxCRC3: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC4;
break;
}
case RxCRC4: //Data size
{
BootloaderCRC <<= 8;
BootloaderCRC += Data;
BootloaderState = RxCRC3;
//TODO: Compute and Compare CRC.
if(BootloaderCRC != 0xBAADCAFE)
{
BootloaderProtocolResetStateMachine();
}
BootloaderExecuteCmd(BootloaderCommand);
BootloaderProtocolResetStateMachine();
break;
}
default:
{
BootloaderProtocolResetStateMachine();
}
BootloaderExecuteCmd(BootloaderCommand);
BootloaderProtocolResetStateMachine();
break;
}
default:
{
BootloaderProtocolResetStateMachine();
break;
}
break;
}
}
}
@ -300,24 +300,33 @@ void BootloaderProtocolSendNACK(unsigned char Cmd)
BootloaderProtocolSendFrame(Cmd,1);
}
void BootloaderProtocolSendInitUploadResponse()
void BootloaderProtocolSendInitUploadResponse(char result)
{
int MaxSize = MAX_BOOTLOADER_PAYLOAD_SIZE;
char* DataPtr = BootloaderProtocolGetDataBufferPtr();
*DataPtr++ = (char)BOOTLOADER_ACK;
char nibble = (char)((MaxSize >> 24) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)((MaxSize >> 16) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)((MaxSize >> 8) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)(MaxSize &0x000000FF);
*DataPtr++ = nibble;
*DataPtr++ = result;
if(result == 1)
{
char nibble = (char)((MaxSize >> 24) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)((MaxSize >> 16) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)((MaxSize >> 8) &0x000000FF);
*DataPtr++ = nibble;
nibble = (char)(MaxSize &0x000000FF);
*DataPtr++ = nibble;
}
else
{
*DataPtr++ = 0;
*DataPtr++ = 0;
*DataPtr++ = 0;
*DataPtr++ = 0;
}
BootloaderProtocolSendFrame(BOOTLOADER_INIT_UPLOAD_RESPONSE,5);
}

12
ChaletLora.X/Source/BootloaderProtocol.h
View File

@ -51,10 +51,20 @@ enum eBootloaderProtocolDataTransferError
BOOTLOADER_CHUNK_TRANSFER_ERROR_RESEND = 2,
BOOTLOADER_CHUNK_TRANSFER_ERROR_FLASH_FAILURE = 3,
BOOTLOADER_CHUNK_TRANSFER_ERROR_INVALID_CHUNK_INDEX = 4,
BOOTLOADER_CHUNK_TRANSFER_ERROR_FLASH_ERROR = 5,
BOOTLOADER_CHUNK_TRANSFER_MAX_ERROR
};
enum eBootloaderProtocolInitTransferError
{
BOOTLOADEDR_INIT_TRANSFER_ERROR = 0,
BOOTLOADEDR_INIT_TRANSFER_OK = 1,
BOOTLOADEDR_INIT_TRANSFER_ERROR_FLASH_NOT_ERASED,
BOOTLOADEDR_INIT_TRANSFER_MAX_ERROR
};
//enum DEVICES_IDS
//{
// ID_MASTER, //Master Controller
@ -86,7 +96,7 @@ unsigned char *BootloaderProtocolGetDataBufferPtr();
void BootloaderProtocolSendHeartbeat();
void BootloaderProtocolSendACK(unsigned char Cmd);
void BootloaderProtocolSendNACK(unsigned char Cmd);
void BootloaderProtocolSendInitUploadResponse();
void BootloaderProtocolSendInitUploadResponse(char result);
void BootloaderProtocolSendDataChunkResult(char ErrorCode, int ChunkValue);

2
ChaletLora.X/Source/FlashMapping.h
View File

@ -19,7 +19,7 @@
#define FLASH_END_ADDRESS 180000
#define FLASH_BTLDR_FIRMWARE_START_ADDRESS 0x180000
#define FLASH_BTLDR_FIRMWARE_LAST_SECTOR_ADD 0x180000
#define FLASH_BTLDR_FIRMWARE_LAST_64K_SECTOR_ADD 0x1F0000

90
ChaletLora.X/Source/SPI_Flash.c
View File

@ -104,22 +104,22 @@ int SPIFlashCheckChipID()
int SPIFlashReadBuffer(unsigned char *Buf, int Size, int StartAddress)
{
if(StartAddress + Size > SPI_FLASH_MAX_ADDRESS)
if(StartAddress + Size - 1 > SPI_FLASH_MAX_ADDRESS)
{
return RET_ERROR;
}
FLASH_SS_PIN = 0;
SPITransaction(SPI_FLASH_HI_SPEED_READ,mSPIFlashBaudrate);
SPITransaction(((StartAddress & 0xFF0000) >> 16),mSPIFlashBaudrate);
SPITransaction(((StartAddress & 0x00FF00) >> 8),mSPIFlashBaudrate);
SPITransaction((StartAddress & 0x0000FF),mSPIFlashBaudrate);
SPITransaction((0x00),mSPIFlashBaudrate); //Chip requires a dummy read in high speed
SPITransaction(((StartAddress & 0xFF0000) >> 16),mSPIFlashHighSpeedBaudrate);
SPITransaction(((StartAddress & 0x00FF00) >> 8),mSPIFlashHighSpeedBaudrate);
SPITransaction((StartAddress & 0x0000FF),mSPIFlashHighSpeedBaudrate);
SPITransaction((0x00),mSPIFlashHighSpeedBaudrate); //Chip requires a dummy read in high speed
int i;
for(i = 0; i < Size; i++)
{
*Buf++ = SPITransaction(0xDE,mSPIFlashBaudrate);
*Buf++ = SPITransaction(0xDE,mSPIFlashHighSpeedBaudrate);
}
FLASH_SS_PIN = 1;
@ -138,18 +138,50 @@ int SPIFlashEraseSector(int SectorAddress)
FLASH_SS_PIN = 0;
SPITransaction(SPI_FLASH_4KB_SECOTR_ERASE,mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0xFF0000) >> 16),mSPIFlashBaudrate);
SPITransaction(((SectorAddress & 0x00FF00) >> 8),mSPIFlashBaudrate);
SPITransaction((SectorAddress & 0x0000FF),mSPIFlashBaudrate);
SPITransaction(((SectorAddress & 0xFF0000) >> 16),mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0x00FF00) >> 8),mSPIFlashHighSpeedBaudrate);
SPITransaction((SectorAddress & 0x0000FF),mSPIFlashHighSpeedBaudrate);
FLASH_SS_PIN = 1;
SectorAddress++;
while( SPIFlashCheckBusy() == true); SPIFlashWriteEnable();
while( SPIFlashCheckBusy() == true);
//SPIFlashWriteEnable();
return RET_OK;
}
int SPIFlashErase64KSector(int SectorAddress, int Blocking)
{
if(SectorAddress % SPI_FLASH_64K_SECTOR_SIZE != 0) //Sectors are aligned on 0x1000
{
return RET_ERROR;
}
if((SectorAddress + SPI_FLASH_64K_SECTOR_SIZE - 1) > SPI_FLASH_MAX_ADDRESS)
{
return RET_ERROR;
}
SPIFlashWriteEnable();
FLASH_SS_PIN = 0;
SPITransaction(SPI_FLASH_64KB_BLOCK_ERASE,mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0xFF0000) >> 16),mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0x00FF00) >> 8),mSPIFlashHighSpeedBaudrate);
SPITransaction((SectorAddress & 0x0000FF),mSPIFlashHighSpeedBaudrate);
FLASH_SS_PIN = 1;
if(Blocking != 0)
{
while( SPIFlashCheckBusy() == true);
// SPIFlashWriteEnable();
}
return RET_OK;
}
int SPIFlashWriteSectorWorkingBuffer(int SectorAddress, int Erase)
{
if(SectorAddress % SPI_FLASH_SECTOR_SIZE != 0) //Sectors are aligned on 0x1000
@ -170,10 +202,10 @@ int SPIFlashWriteSectorWorkingBuffer(int SectorAddress, int Erase)
FLASH_SS_PIN = 0;
SPITransaction(SPI_FLASH_BYTE_PROGRAM,mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0xFF0000) >> 16),mSPIFlashBaudrate);
SPITransaction(((SectorAddress & 0x00FF00) >> 8),mSPIFlashBaudrate);
SPITransaction((SectorAddress & 0x0000FF),mSPIFlashBaudrate);
SPITransaction(*DataPtr++,mSPIFlashBaudrate);
SPITransaction(((SectorAddress & 0xFF0000) >> 16),mSPIFlashHighSpeedBaudrate);
SPITransaction(((SectorAddress & 0x00FF00) >> 8),mSPIFlashHighSpeedBaudrate);
SPITransaction((SectorAddress & 0x0000FF),mSPIFlashHighSpeedBaudrate);
SPITransaction(*DataPtr++,mSPIFlashHighSpeedBaudrate);
FLASH_SS_PIN = 1;
SectorAddress++;
@ -181,8 +213,34 @@ int SPIFlashWriteSectorWorkingBuffer(int SectorAddress, int Erase)
while( SPIFlashCheckBusy() == true);
}
return RET_OK;
return RET_OK;
}
int SPIFlashWriteByte(unsigned int ByteAddress, char byte, int blocking)
{
if(ByteAddress > SPI_FLASH_MAX_ADDRESS)
{
return RET_ERROR;
}
SPIFlashWriteEnable();
FLASH_SS_PIN = 0;
SPITransaction(SPI_FLASH_BYTE_PROGRAM,mSPIFlashHighSpeedBaudrate);
SPITransaction(((ByteAddress & 0xFF0000) >> 16),mSPIFlashHighSpeedBaudrate);
SPITransaction(((ByteAddress & 0x00FF00) >> 8),mSPIFlashHighSpeedBaudrate);
SPITransaction((ByteAddress & 0x0000FF),mSPIFlashHighSpeedBaudrate);
SPITransaction(byte,mSPIFlashHighSpeedBaudrate);
FLASH_SS_PIN = 1;
if(blocking)
{
while( SPIFlashCheckBusy() == true);
}
return RET_OK;
}

4
ChaletLora.X/Source/SPI_Flash.h
View File

@ -26,6 +26,7 @@
#define SPI_FLASH_CHIP_ID 0x41
#define SPI_FLASH_MAX_ADDRESS 0x1FFFFF
#define SPI_FLASH_SECTOR_SIZE 0x1000
#define SPI_FLASH_64K_SECTOR_SIZE 0x10000
#define SPI_NB_SECTORS 0x1FF //511 sectors = SPI_FLASH_MAX_ADDRESS / SPI_FLASH_SECTOR_SIZE
@ -37,7 +38,10 @@ int SPIFlashReadBuffer(unsigned char *Buf, int Size, int StartAddress);
int SPIFlashCheckBusy();
int SPIFlashWriteEnable();
int SPIFlashEraseSector(int SectorAddress);
int SPIFlashErase64KSector(int SectorAddress, int Blocking);
int SPIFlashWriteSectorWorkingBuffer(int SectorAddress, int Erase);
int SPIFlashWriteBuffer(unsigned char *Buf, int Size, int StartAddress);
int SPIFlashWriteByte(unsigned int ByteAddress, char byte, int blocking);
#endif /* SPI_FLASH_H */

1
ChaletLora.X/Source/timer.h
View File

@ -48,6 +48,7 @@ typedef enum
WIFI_TICK_TIMER,
SYSLOG_TX_TIMER,
TEMP_SENSOR_REFRESH_TIMER,
BOOTLOADER_FLASH_POLL_TIMER,
TIMER_MAX_ID
}eTimerID;

BIN
ChaletLora.X/dist/ChaletDuinoV2_775F512H_/debug/ChaletLora.X.debug.elf vendored
View File

Binary file not shown.

2484
ChaletLora.X/dist/ChaletDuinoV2_775F512H_/debug/ChaletLora.X.debug.map vendored
View File

File diff suppressed because it is too large Load Diff

BIN
ChaletLora.X/dist/ChaletDuinoV2_775F512H_/production/ChaletLora.X.production.elf vendored
View File

Binary file not shown.

10408
ChaletLora.X/dist/ChaletDuinoV2_775F512H_/production/ChaletLora.X.production.hex vendored
View File

File diff suppressed because it is too large Load Diff

2274
ChaletLora.X/dist/ChaletDuinoV2_775F512H_/production/ChaletLora.X.production.map vendored
View File

File diff suppressed because it is too large Load Diff

4
ChaletLora.X/nbproject/private/private.xml
View File

@ -2,6 +2,8 @@
<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
<editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="0"/>
<open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
<group/>
<group>
<file>file:/D:/Main/PicDev/Projets/ChaletLora/ChaletLora.X/Source/BootloaderProtocol.c</file>
</group>
</open-files>
</project-private>