/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
{
USB_Disable();
printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
" -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
for(;;);
}
/* This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t corenum, const uint8_t ErrorCode)
{
USB_Disable(corenum, USB_MODE_Host);
DEBUGOUT(("Host Mode Error\r\n"
" -- Error port %d\r\n"
" -- Error Code %d\r\n" ), corenum, ErrorCode);
/* Wait forever */
for (;; ) {}
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardwareKeyboard(void)
{
//bsp_init();
Serial_Init(9600, false);
//LEDs_Init();
USB_Disable();
USB_CurrentMode = USB_MODE_Host;
USB_Init();
/* Create a stdio stream for the serial port for stdin and stdout */
Serial_CreateStream(NULL);
}
void jumpToBootloader(void)
{
// If USB is used, detach from the bus and reset it
USB_Disable();
// Disable all interrupts
cli();
// Wait two seconds for the USB detachment to register on the host
Delay_MS(2000);
// Set the bootloader key to the magic value and force a reset
Boot_Key = MAGIC_BOOT_KEY;
wdt_enable(WDTO_250MS);
for (;;);
}
void watchdog_reset(uint8_t where)
{
USB_Disable();
cli();
if (where == WDR_BOOTLOADER)
boot_key = BOOT_KEY_MAGIC;
else if (where == WDR_TESTMODE)
boot_key = TEST_MODE_MAGIC;
_delay_ms(2000);
wdt_enable(WDTO_30MS);
while (1);
}
const void * USBHID_Cmds(enum ProtoCmds cmd)
{
switch(cmd) {
case PROTOCMD_INIT: initialize(); return 0;
case PROTOCMD_DEINIT: USB_Disable(); return 0;
case PROTOCMD_CHECK_AUTOBIND: return (void *)1L;
case PROTOCMD_BIND: initialize(); return 0;
case PROTOCMD_NUMCHAN: return (void *)((unsigned long)USBHID_MAX_CHANNELS);
case PROTOCMD_DEFAULT_NUMCHAN: return (void *)6L;
case PROTOCMD_TELEMETRYSTATE: return (void *)(long)-1;
default: break;
}
return 0;
}
unsigned usb_cb(u32 button, unsigned flags, void *data)
{
(void)button;
(void)data;
if(flags == BUTTON_RELEASE) {
_draw_page(1);
GUI_RefreshScreen();
USB_Enable(0, 1);
wait_release();
wait_press();
wait_release();
USB_Disable();
_draw_page(0);
}
return 1;
}
void PTP_Disable(void)
{
PTP_CloseSession();
USB_USBTask();
USB_Detach();
USB_Disable();
#ifdef PTP_DEBUG
puts_P(PSTR("Camera Disabled.\r\n"));
#endif
configured = 0;
PTP_Ready = 0;
PTP_Connected = 0;
PTP_Bytes_Remaining = 0;
PTP_Run_Task = 1;
USB_HostState = 0;
return;
}
/* Task to Write Data in USBPendrive. */
void enterusbisp(void)
{
/* Configure LED stats direction. */
LEDPORT->FIODIR |= (1 << LEDPORTPIN);
/* Configure the NVIC Preemption Priority Bits */
NVIC_SetPriorityGrouping(1);
USB_CurrentMode = USB_MODE_Host;
USB_Disable();
USB_Init();
PRINTDBG("\nInit USB Bootloader Read.");
if(USB_ReadWriteFile() == true)
{
LEDPORT->FIOPIN |= (1 << LEDPORTPIN); /* LED's OFF. */
}
while (1);
}
static void setup_usb(void)
{
// Leonardo needs. Without this USB device is not recognized.
USB_Disable();
USB_Init();
// for Console_Task
USB_Device_EnableSOFEvents();
print_set_sendchar(sendchar);
/* wait for USB startup & debug output */
uint8_t timeout = 255; // timeout when USB is not available
while (timeout-- &&USB_DeviceState != DEVICE_STATE_Configured) {
wait_ms(4);
#if defined(INTERRUPT_CONTROL_ENDPOINT)
;
#else
USB_USBTask();
#endif
}
print("USB configured.\n");
}
void PROTO_Stubs(int idx)
{
if (! idx)
return;
CLOCK_StartTimer();
spi_disable();
spi_set_bidirectional_receive_only_mode();
spi_read();
spi_set_unidirectional_mode();
TELEMETRY_SetUpdated();
TELEMETRY_SetType();
UART_Stop();
rcc_peripheral_disable_clock();
_usleep();
MCU_SerialNumber();
USB_Disable();
PROTO_CS_HI();
PROTO_CS_LO();
MUSIC_Beep();
rand32();
}
void hardware_bootloader(void)
{
typedef void (*AppPtr_t)(void) __attribute__ ((noreturn));
AppPtr_t BootStartPtr = (AppPtr_t) 0xF000;
// If USB is used, detach from the bus
USB_Detach();
USB_Disable();
lcd.off();
clock.disable();
// Disable all interrupts
cli();
wdt_disable();
BootStartPtr();
for(;;);
}
static void SetupHardware(void)
{
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
// Leonardo needs. Without this USB device is not recognized.
USB_Disable();
USB_Init();
// for Console_Task
USB_Device_EnableSOFEvents();
print_set_sendchar(sendchar_func);
// SUART PD0:output, PD1:input
DDRD |= (1<<0);
PORTD |= (1<<0);
DDRD &= ~(1<<1);
PORTD |= (1<<1);
}
/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
* enumerated by the host and is now ready to be used by the application.
*/
void EVENT_USB_Host_DeviceEnumerationComplete(void)
{
puts_P(PSTR("Getting Config Data.\r\n"));
uint8_t ErrorCode;
/* Get and process the configuration descriptor data */
if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
{
if (ErrorCode == ControlError)
puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
else
puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
/* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
/* HID class request to set the mouse protocol to the Boot Protocol */
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
.bRequest = HID_REQ_SetProtocol,
.wValue = 0,
.wIndex = 0,
.wLength = 0,
};
/* Select the control pipe for the request transfer */
Pipe_SelectPipe(PIPE_CONTROLPIPE);
/* Send the request, display error and wait for device detach if request fails */
if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Control Error (Set Protocol).\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Host_SetDeviceConfiguration(0);
return;
}
puts_P(PSTR("Mouse Enumerated.\r\n"));
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
{
USB_Disable();
printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
" -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
for(;;);
}
/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
{
USB_Disable();
for(;;);
}
/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
* enumerated by the host and is now ready to be used by the application.
*/
void EVENT_USB_Host_DeviceEnumerationComplete(void)
{
puts_P(PSTR("Getting Config Data.\r\n"));
uint8_t ErrorCode;
/* Get and process the configuration descriptor data */
if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
{
if (ErrorCode == ControlError)
puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
else
puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
/* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
if ((ErrorCode = USB_Host_SetInterfaceAltSetting(StreamingInterfaceIndex,
StreamingInterfaceAltSetting)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Could not set alternative streaming interface setting.\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Host_SetDeviceConfiguration(0);
return;
}
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT),
.bRequest = AUDIO_REQ_SetCurrent,
.wValue = (AUDIO_EPCONTROL_SamplingFreq << 8),
.wIndex = StreamingEndpointAddress,
.wLength = sizeof(USB_Audio_SampleFreq_t),
};
USB_Audio_SampleFreq_t SampleRate = AUDIO_SAMPLE_FREQ(48000);
/* Select the control pipe for the request transfer */
Pipe_SelectPipe(PIPE_CONTROLPIPE);
/* Set the sample rate on the streaming interface endpoint */
if ((ErrorCode = USB_Host_SendControlRequest(&SampleRate)) != HOST_SENDCONTROL_Successful)
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
USB_Host_SetDeviceConfiguration(0);
return;
}
/* Sample reload timer initialization */
TIMSK0 = (1 << OCIE0A);
OCR0A = ((F_CPU / 8 / 48000) - 1);
TCCR0A = (1 << WGM01); // CTC mode
TCCR0B = (1 << CS01); // Fcpu/8 speed
puts_P(PSTR("Speaker Enumerated.\r\n"));
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
{
USB_Disable();
printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
" -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
for(;;);
}
/** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
* enumerated by the host and is now ready to be used by the application.
*/
void EVENT_USB_Host_DeviceEnumerationComplete(void)
{
puts_P(PSTR("Getting Config Data.\r\n"));
uint8_t ErrorCode;
/* Get and process the configuration descriptor data */
if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
{
if (ErrorCode == ControlError)
puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
else
puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
/* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 9600,
.CharFormat = CDC_LINEENCODING_OneStopBit,
.ParityType = CDC_PARITY_None,
.DataBits = 8 };
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
.bRequest = CDC_REQ_SetLineEncoding,
.wValue = 0,
.wIndex = 0,
.wLength = sizeof(LineEncoding),
};
/* Set the Line Encoding of the CDC interface within the device, so that it is ready to accept data */
Pipe_SelectPipe(PIPE_CONTROLPIPE);
if (USB_Host_SendControlRequest(&LineEncoding) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Control Error (Set Line Encoding).\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
return;
}
puts_P(PSTR("CDC Device Enumerated.\r\n"));
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
/** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
{
USB_Disable();
printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
" -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
for(;;);
}
/** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
* enumerating an attached USB device.
*/
void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
const uint8_t SubErrorCode)
{
printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
" -- Error Code %d\r\n"
" -- Sub Error Code %d\r\n"
" -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
void print_char(char c) {
USB_Disable();
serial_send(c);
USB_Init();
}
int main(void)
{
typedef void (*AppPtr_t) (void);
AppPtr_t Bootloader = (AppPtr_t) BOOTLOADER_START_ADDR;
const uint8_t count = eeprom_read_byte(BOOTLOADER_COUNT_ADDR);
DDRB |= (1 << 6) | (1 << 5); // pull audio pins down
if (count == 3)
{
eeprom_write_byte(BOOTLOADER_COUNT_ADDR, 0);
Bootloader();
}
SetupHardware();
eeprom_write_byte(BOOTLOADER_COUNT_ADDR, count + 1);
delay_ms(500);
eeprom_write_byte(BOOTLOADER_COUNT_ADDR, 0);
if (USB_VBUS_GetStatus())
{
if (!Main_mmcInitialized)
{
USB_Disable();
}
uart_init(12);
for (;;)
{
CHARGE_STATUS_PORT |= CHARGE_STATUS_MASK ;
if (Main_mmcInitialized)
{
USBInterfaceTask();
USB_USBTask();
}
if (CHARGE_STATUS_PIN & CHARGE_STATUS_MASK)
{
Main_activeLED = LEDS_GREEN;
}
else
{
Main_activeLED = LEDS_RED;
}
LEDs_ChangeLEDs(LEDS_ALL_LEDS, Main_activeLED);
}
}
else
{
USB_Disable();
if (Main_mmcInitialized)
{
Main_activeLED = LEDS_GREEN;
}
else
{
Main_activeLED = LEDS_RED;
}
LEDs_ChangeLEDs(LEDS_ALL_LEDS, Main_activeLED);
Power_Hold();
Signature_Write();
Config_Read();
Power_Release();
Timer_Init();
UBX_Init();
for (;;)
{
UBX_Task();
Tone_Task();
}
}
}
