int main()
{
/* Short-circuit EN and VDD to start bootloader */
EN_Write(0);
if(EN_Read() != 0u) {
Bootloader_SET_RUN_TYPE(Bootloader_START_BTLDR);
} else {
Bootloader_SET_RUN_TYPE(Bootloader_START_APP);
}
Bootloader_Start();
}
int main()
{
uint8 counter = 0;
/* Enable global interrupts*/
CyGlobalIntEnable;
/* Check if the switch is pressed during power up */
if(Boot_P0_7_Read() == 0)
{
for(counter = 0; counter <= SWITCH_PRESS_TIMEOUT; counter++)
{
/* Delay for 1ms */
//CyDelay(1);
CyDelay(2);
/* If the switch is released before specified time, do not enter the
* bootloader */
if(Boot_P0_7_Read() != 0)
break;
}
if(counter > SWITCH_PRESS_TIMEOUT)
{
/* If the switch was pressed for more than 100 millisecond counter
* value will be 100. If so, set the flash run type as bootloader to
* wait for a bootload operation */
Bootloader_SET_RUN_TYPE (Bootloader_START_BTLDR);
}
}
/*Indicate that you have entered the bootloader mode.*/
PWM_Start();
/* Start the Bootloader */
Bootloader_Start();
/* The “Bootloader_Start()” API will either wait for a bootload operation or
* will launch the application depending on whether or not the API
* "Bootloader_SET_RUN_TYPE(Bootloader_START_BTLDR)" was called because of the
* switch being pressed during power up */
for(;;)
{
}
}
int main()
{
CyGlobalIntEnable;
Bootloader_SET_RUN_TYPE(Bootloader_SCHEDULE_BTLDB);
USBUART_FunctionAttach();
enableUSBCDC();
UART_FunctionAttach();
initTimebase();
setup();
for(;;)
{
loop();
}
}
/*******************************************************************************
* Function Name: Bootloader_HostLink
********************************************************************************
*
* Summary:
* Causes the bootloader to attempt to read data being transmitted by the
* host application. If data is sent from the host, this establishes the
* communication interface to process all requests.
*
* Parameters:
* timeOut:
* The amount of time to listen for data before giving up. Timeout is
* measured in 10s of ms. Use 0 for an infinite wait.
*
* Return:
* None
*
*******************************************************************************/
static void Bootloader_HostLink(uint32 timeout)
{
uint16 CYDATA numberRead;
cystatus CYDATA readStat;
uint16 bytesToRead;
uint16 bytesToWrite;
uint32 counterVal;
static const uint8 deviceID[7] = {'A','V','R','B', 'O', 'O', 'T'};
static const uint8 swID[2] = {'1', '0'};
static const uint8 hwID[2] = {'1', '0'};
uint32 currentAddress = 0;
uint8 packetBuffer[Bootloader_SIZEOF_COMMAND_BUFFER];
/* Initialize communications channel. */
CyBtldrCommStart();
counterVal = 0;
do
{
do
{
readStat = CyBtldrCommRead(packetBuffer,
Bootloader_SIZEOF_COMMAND_BUFFER,
&numberRead,
10);
counterVal = Reset_Timer_ReadCounter() * -1;
#ifdef USE_UART
char dbstring[24];
sprintf(dbstring,"%ld\r", counterVal);
UART_PutString(dbstring);
CyDelay(50);
#endif
if (counterVal >= timeout)
{
Bootloader_SET_RUN_TYPE(Bootloader_SCHEDULE_BTLDB);
CySoftwareReset();
}
} while ( readStat != CYRET_SUCCESS );
Reset_Timer_Stop();
Reset_Timer_WriteCounter(0);
Reset_Timer_Start();
switch(packetBuffer[0])
{
/*************************************************************************
* Set read/write address
*************************************************************************/
case 'A':
currentAddress = packetBuffer[1] << 9;
currentAddress |= packetBuffer[2] << 1;
packetBuffer[0] = '\r';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Set read/write address
*************************************************************************/
case 'H':
currentAddress = packetBuffer[1] << 17;
currentAddress |= packetBuffer[2] << 9;
currentAddress |= packetBuffer[3] << 1;
packetBuffer[0] = '\r';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Erase chip (unimplemented)
*************************************************************************/
case 'e':
break;
/*************************************************************************
* Enter/Leave bootloader mode - UNUSED
*************************************************************************/
case 'P':
case 'L':
packetBuffer[0] = '\r';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Exit bootloader
*************************************************************************/
case 'E':
/* Normally, the CyBootloader checks the validity of the app here. We will
* assume that the app is valid b/c it was checked as it was being
* uploaded. */
Bootloader_SET_RUN_TYPE(Bootloader_SCHEDULE_BTLDB);
packetBuffer[0] = '\r';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
while (USBUART_CDCIsReady() == 0)
{ /* wait for USB to finish sending response to the exit command */ }
CySoftwareReset();
/* Will never get here */
break;
/*************************************************************************
* Block read
*************************************************************************/
case 'g':
bytesToRead = packetBuffer[1] << 8;
bytesToRead |= packetBuffer[2];
int16 idx;
for(idx = 0u; idx < bytesToRead; idx++)
{
packetBuffer[idx] = Bootloader_GET_CODE_BYTE(currentAddress + idx);
}
CyBtldrCommWrite(packetBuffer, bytesToRead, NULL, 0);
break;
/*************************************************************************
* Block load
*************************************************************************/
case 'B':
bytesToWrite = packetBuffer[1]<<8 | packetBuffer[2];
packetBuffer[0] = BlockLoad(packetBuffer[3], bytesToWrite, \
packetBuffer + 4, currentAddress);
if ((packetBuffer[0] == '\r') && packetBuffer[3] == 'F')
{
currentAddress += bytesToWrite;
}
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Report device ID
*************************************************************************/
case 'S':
CyBtldrCommWrite((uint8*)deviceID, 8, NULL, 0);
break;
/*************************************************************************
* Report firmware revision
*************************************************************************/
case 'V':
CyBtldrCommWrite((uint8*)swID, 2, NULL, 0);
break;
/*************************************************************************
* Report programmer type ('S' for "Serial")
*************************************************************************/
case 'p':
packetBuffer[0] = 'S';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Report autoincrement address support ('Y' for "Yes")
*************************************************************************/
case 'a':
packetBuffer[0] = 'Y';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Report block write support ('Y' for "Yes", then two bytes of block size
* written MSB first.
*************************************************************************/
case 'b':
packetBuffer[0] = 'Y';
packetBuffer[1] = 0x01;
packetBuffer[2] = 0x00;
CyBtldrCommWrite(packetBuffer, 3, NULL, 0);
break;
/*************************************************************************
* Report hardware device version
*************************************************************************/
case 'v':
CyBtldrCommWrite((uint8*)hwID, 2, NULL, 0);
break;
/*************************************************************************
* Report (bogus) part ID, followed by list terminator 0x00.
*************************************************************************/
case 't':
packetBuffer[0] = 0x44;
packetBuffer[1] = 0;
CyBtldrCommWrite(packetBuffer, 2, NULL, 0);
break;
/*************************************************************************
* Report device signature (this is that of the Atmega32u4)
*************************************************************************/
case 's':
packetBuffer[0] = 0x87;
packetBuffer[1] = 0x95;
packetBuffer[2] = 0x1e;
CyBtldrCommWrite(packetBuffer, 3, NULL, 0);
break;
/*************************************************************************
* Unimplemented fuse AVR fuse register read/write
*************************************************************************/
case 'N':
case 'Q':
case 'F':
case 'r':
packetBuffer[0] = 0x00;
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Unused but implemented in AVRDUDE, so some response needed.
*************************************************************************/
case 'T':
case 'x':
case 'y':
packetBuffer[0] = '\r';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
/*************************************************************************
* Unsupported command
*************************************************************************/
default:
packetBuffer[0] = '?';
CyBtldrCommWrite(packetBuffer, 1, NULL, 0);
break;
}
} while (1);
}
