void try_receive_data(void)
{
byte i;
byte *ptr;
if (uart0_flags.data_received)
{
ptr = uart0_get_data_begin();
for (i=0; i<9; i++)
{
TB_bufIn[i] = *ptr;
ptr++;
}
uart0_get_data_end();
uart0_flags.data_received = FALSE;
if (TB_Read() == 0)
{
switch (TB_Decode())
{
case ENTER_BOOTLOADER:
BootStatus = 1;
TB_SendAck(TB_ERR_OK, ENTER_BOOTLOADER);
break;
case READ_LOCK_BITS:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_LOCK_BITS));
break;
case CHIP_ERASE_FLASH:
ChipErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_FLASH);
break;
case CHIP_ERASE_EEPROM:
EepromErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_EEPROM);
break;
case CHIP_ERASE_ALL:
ChipErase();
EepromErase();
TB_SendAck(TB_ERR_OK, CHIP_ERASE_ALL);
break;
case WRITE_LOCK_BITS:
TB_SendAck(TB_ERR_NOTEVALUABLE, WRITE_LOCK_BITS);
break;
case READ_LOW_FUSE:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
break;
case READ_HIGH_FUSE:
TB_SendAck(TB_ERR_OK, boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
break;
case READ_EXTENDED_FUSE:
TB_SendAck(TB_ERR_NOTEVALUABLE, boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
break;
case READ_SIGNATURE:
Signature = 0x1E9502;
TB_SendAck(TB_ERR_OK, Signature);
break;
case READ_SOFTWARE_VERSION:
TB_SendAck(TB_ERR_OK, SOFTWARE_IDENTIFIER);
break;
case READ_BOOTLOADER_VERSION:
TB_SendAck(TB_ERR_OK, BOOTLOADER_VERSION);
break;
case VERIFY_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
VerifyFlash(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case WRITE_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
Aktualni = (Address & ADDRESS_MASK_MSB);
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
if (Aktualni == Predchozi)
{
FillBufferData(Address);
EndComFlash = 1;
TB_SendAck(TB_ERR_OK, WRITE_FLASH);
}
else
{
if (EndComFlash)
{
WriteFlashPages(Predchozi, BufferFlash);
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, Address);
Predchozi = Address;
}
else
{
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, WRITE_FLASH);
Predchozi = Address;
}
}
NowFlash = 1;
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case WRITE_EEPROM:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
Aktualni = (Address & ADDRESS_MASK_MSB);
if (Address < (START_EEPROM_ADDRESS - 4))
{
if (Aktualni == Predchozi)
{
FillBufferData(Address);
EndComEeprom = 1;
TB_SendAck(TB_ERR_OK, WRITE_EEPROM);
}
else
{
if (EndComEeprom)
{
WriteEepromPages(Predchozi, BufferFlash);
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, Address);
Predchozi = Address;
}
else
{
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
FillBufferData(Address);
TB_SendAck(TB_ERR_OK, WRITE_EEPROM);
}
}
NowEeprom = 1;
}
else
{
TB_SendAck(TB_ERR_VALUE, Address);
}
break;
case END_WRITE_ALL:
if (NowFlash)
{
WriteFlashPages(Predchozi, BufferFlash);
EndComFlash=0;
TB_SendAck(TB_ERR_OK, END_WRITE_ALL);
}
else if(NowEeprom)
{
WriteEepromPages(Predchozi, BufferFlash);
EndComEeprom = 0;
TB_SendAck(TB_ERR_OK, END_WRITE_ALL);
}
else
{
TB_SendAck(TB_ERR_VALUE, 0);
}
memset(BufferFlash, 0xFF, SPM_PAGESIZE);
Predchozi = 0;
Aktualni = 0;
break;
case READ_FLASH:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_BOOT_ADDRESS_BYTES - 4))
{
ReadFlashPages(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, 0);
}
break;
case READ_EEPROM:
Address = TB_bufIn[TB_BUF_TYPE] << 8;
Address |= TB_bufIn[TB_BUF_MOTOR];
if (Address < (START_EEPROM_ADDRESS - 4))
{
ReadEepromPages(Address);
}
else
{
TB_SendAck(TB_ERR_VALUE, READ_EEPROM);
}
break;
case CMD_SPM_PAGE_SIZE:
TB_SendAck(TB_ERR_OK, SPM_PAGESIZE);
break;
case CMD_ALL_PAGE_SIZE:
TB_SendAck(TB_ERR_OK, PAGE_SIZE);
break;
case EXIT_BOOTLOADER:
TB_SendAck(TB_ERR_OK, EXIT_BOOTLOADER);
jumpaddress();
break;
}
}
}
}
/*****************************************************************************
* BOOL BinaryHandlePacket(void)
*****************************************************************************/
BOOL BinaryHandlePacket(void)
{
BYTE *packet;
BYTE *payload;
COMM_PKT_HDR *hdr;
BYTE ack_nack;
BOOL result = FALSE;
if(COMM_PKT_RxPacketAvailable() == FALSE)
return result;
packet = COMM_PKT_GetRxPacket();
if(COMM_PKT_IsPacketValid(packet) == FALSE)
return result;
hdr = (COMM_PKT_HDR *)packet;
payload = packet + sizeof(COMM_PKT_HDR);
ack_nack = COMM_PKT_ACK;
switch(hdr->cmd)
{
case COMM_PKT_ECHO:
break;
case COMM_PKT_MAX_PAYLOAD_SIZE:
*((WORD *)payload) = COMM_PKT_RX_MAX_SIZE;
hdr->length = 2;
break;
case COMM_PKT_MEMORY_ERASE:
ChipErase();
break;
case COMM_PKT_MEMORY_WRITE:
{
COMM_PKT_MEMORY_PAYLOAD *memPayload = (COMM_PKT_MEMORY_PAYLOAD *)payload;
if(!WriteMemory(memPayload->addr, (BYTE *)&memPayload->data, hdr->length - 4))
ack_nack = COMM_PKT_NACK;
hdr->length = 4;
}
break;
case COMM_PKT_MEMORY_READ:
{
COMM_PKT_MEMORY_PAYLOAD *memPayload = (COMM_PKT_MEMORY_PAYLOAD *)payload;
hdr->length = *((WORD *)(payload + 4));
ReadArray(memPayload->addr, (BYTE *)&memPayload->data, hdr->length);
hdr->length += 4;
}
break;
case COMM_PKT_MEMORY_VERIFY:
{
COMM_PKT_VERIFY_PAYLOAD *verifyPayload = (COMM_PKT_VERIFY_PAYLOAD *)payload;
*((DWORD *)payload) = CalculateCheckSum(verifyPayload->addr, payload, verifyPayload->range);
hdr->length = 4;
}
break;
case COMM_PKT_MEMORY_DONE:
result = TRUE;
break;
default:
ack_nack = COMM_PKT_NACK;
break;
}
COMM_PKT_SendReply( FLASH_PROGRAMMER_COMMUNICATION_MEDIUM,
hdr->cmd,
ack_nack,
payload,
hdr->length);
return result;
}
/************************************************************************
Function: WORD GOLDrawCallback()
Overview: This function must be implemented by user. GOLDraw() function
calls it each time when GOL objects drawing is completed. User
drawing should be done here. GOL will not change color, line
type and clipping region settings while this function
returns zero.
Input: none
Output: If the function returns non-zero the draw control will be passed
to GOL. GOLDraw() can proceed and re-draw objects that needs
to be redrawn.
************************************************************************/
WORD GOLDrawCallback(void)
{
BOOL status;
// update the time and date variables
UpdateTime(0);
switch(screenState)
{
case CREATE_HOME:
CreateHomeScreen();
TransparentColorDisable();
screenState = DISPLAY_HOME;
break;
case CREATE_WATCHTV:
CreateWatchTVScreen();
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
screenState = DISPLAY_WATCHTV;
break;
case CREATE_RF_SETTINGS:
CreateRFSettingsScreen();
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
screenState = DISPLAY_RF_SETTINGS;
break;
case CREATE_TIME_SETTINGS:
CreateTimeSettingsScreen();
processingTick = RF4CE_TickGet();
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
screenState = DISPLAY_TIME_SETTINGS;
break;
case CREATE_PLAYDISC:
CreatePlayDiscScreen();
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
screenState = DISPLAY_PLAYDISC;
break;
case CREATE_FAVORITES:
CreateFavoritesScreen();
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
screenState = DISPLAY_FAVORITES;
break;
case CREATE_INTERNET:
// enable the transparent color feature
TransparentColorEnable(TRANSPARENT_COLOR);
CreateInternetScreen();
screenState = DISPLAY_INTERNET;
break;
case RF_PAIRING_MODE:
// if RF4CEControllerPairing() is successful it will also
// set the active device to the newly paired device
status = RF4CEControllerPairing();
processingTick = RF4CE_TickGet();
// show results of the pairing first
CreatePairingResults(status);
DelayMs(1500);
UpdatePairTableLEDStatus();
// Due to primitive objects in the screen of RF Settings, a complete
// redraw of the screen is required. If all are Widgets then it is possible
// to just call GOLRedrawRec(0, 0, GetMaxX(), GetMaxY());
// and set state to
// screenState = DISPLAY_RF_SETTINGS;
screenState = CREATE_RF_SETTINGS;
break;
case CREATE_PROGRAM_FLASH:
CreateProgramExternalFlash();
screenState = DISPLAY_PROGRAM_FLASH_MENU;
break;
case DISPLAY_PROGRAM_FLASH_ACTUAL:
// perform a external flash memory erase and a system reset
// after reset, the check on validity of the external flash
// will be launched and this will cause the programming
// mode to be called. Hex data for the external flash
// should then be sent to the board.
PowerSaveBacklightOff();
ChipErase();
Reset();
break;
case CREATE_MANAGE_PAIR_TABLE_MODE:
CreateManagePairTableMode();
screenState = DISPLAY_MANAGE_PAIR_TABLE_MODE;
break;
case DISPLAY_TIME_SETTINGS:
TimeSettingsDrawCallback();
break;
case DISPLAY_HOME:
case DISPLAY_WATCHTV:
case DISPLAY_RF_SETTINGS:
case DISPLAY_PLAYDISC:
case DISPLAY_FAVORITES:
case DISPLAY_INTERNET:
case DISPLAY_PROGRAM_FLASH_MENU:
case DISPLAY_MANAGE_PAIR_TABLE_MODE:
default:
break;
}
return (1);
}
