int UARTprintf(const char * ch, ... ){
char8 lineStr[PRINTF_BUFFER_SIZE];
va_list ap;
va_start(ap,ch);
vsnprintf(lineStr,PRINTF_BUFFER_SIZE,ch,ap);
va_end(ap);
while(USBUART_CDCIsReady()==0);
USBUART_PutString(lineStr);
return 0;
}
/*******************************************************************************
* 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);
}
void UARTputc(const char ch){
while(USBUART_CDCIsReady()==0);
USBUART_PutChar(ch);
}
int main()
{
CyGlobalIntEnable; /* Enable global interrupts. */
//PWM_1_Start();
PWM_1_Start();
USBUART_Start(0,USBUART_5V_OPERATION);
while(!USBUART_bGetConfiguration()){}
USBUART_CDC_Init();
int count = 0;
uint8 buff[64];
buff[0] = 0;
int up_b = 0;
int left_b = 0;
int down_b = 0;
int right_b = 0;
int PWM_count = 0;
int judge_count = 0;
while(1)//main loop
{
if(0 != USBUART_GetConfiguration())
{
if(0 != USBUART_DataIsReady())
{
count = USBUART_GetAll(buff);
if( count != 0){
while(0 == USBUART_CDCIsReady()){}
PWM_1_Start();
PWM_2_Start();
PWM_3_Start();
PWM_4_Start();
USBUART_PutData(buff,count);
CyDelay(500);
USBUART_PutCRLF();
switch(buff[0]){
case 48:
up_b = 1;
break;
case 49:
up_b = 0;
break;
case 50:
left_b = 1;
break;
case 51:
left_b = 0;
break;
case 52:
right_b = 1;
break;
case 53:
right_b = 0;
break;
case 54:
down_b = 1;
break;
case 55:
down_b = 0;
break;
default:
break;
}
judge_count = up_b + left_b + down_b +right_b;
if(judge_count == 0){
PWM_count = 0;
}
if(judge_count == 1){//押されているボタンの数が1つの場合
if(PWM_count <=100){
PWM_count++;
int i = 0;
for(i=0;i<=100;i++){}
}else{}
if(up_b == 1){//上ボタン
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(1);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(1);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(1);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(1);
}
if(left_b == 1)
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(0);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(1);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(1);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(0);
}
if(right_b == 1)
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(1);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(0);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(0);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(1);
}
if(down_b == 1)
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(0);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(0);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(0);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(0);
}
}else if(judge_count == 2){//2個の場合
if(PWM_count <=100){
PWM_count++;
int i = 0;
for(i=0;i<=100;i++){}
}else{}
if(up_b == 1&& left_b == 1){
PWM_1_WriteCompare(0);
PWM_1_direction_Write(0);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(1);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(1);
PWM_4_WriteCompare(0);
PWM_4_direction_Write(0);
}else if(up_b == 1&& right_b == 1){
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(1);
PWM_2_WriteCompare(0);
PWM_2_direction_Write(0);
PWM_3_WriteCompare(0);
PWM_3_direction_Write(0);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(1);
}else if(down_b == 1&& right_b==1){
PWM_1_WriteCompare(0);
PWM_1_direction_Write(0);
PWM_2_WriteCompare(PWM_count);
PWM_2_direction_Write(0);
PWM_3_WriteCompare(PWM_count);
PWM_3_direction_Write(0);
PWM_4_WriteCompare(0);
PWM_4_direction_Write(0);
}else if(down_b == 1&& left_b == 1){
PWM_1_WriteCompare(PWM_count);
PWM_1_direction_Write(0);
PWM_2_WriteCompare(0);
PWM_2_direction_Write(0);
PWM_3_WriteCompare(0);
PWM_3_direction_Write(0);
PWM_4_WriteCompare(PWM_count);
PWM_4_direction_Write(0);
}
}else{}
//if(USBUART_IsLineChanged() == USBUART_LINE_CODING_CHANGED || USBUART_IsLineChanged() == USBUART_LINE_CONTROL_CHANGED)
//{
USBUART_PutCRLF();
//CyDelay(100);
//}
if(64 == count){
while(0 == USBUART_CDCIsReady()){}
//sent zero packet
USBUART_PutData(NULL,0);
}
//LED_Write(0);
}
}
