/*********************************************************************
* Function: void APP_HostMSDDataLoggerTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized via
* the APP_HostMSDDataLoggerInitialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_HostMSDDataLoggerTasks()
{
if(FILEIO_MediaDetect(&gUSBDrive, &deviceAddress) == false)
{
//The device has been removed. Now we should wait for a new
// device to be attached.
demoState = WAITING_FOR_ATTACH;
}
switch( demoState)
{
case WAITING_FOR_ATTACH:
break;
case MOUNTING_DRIVE:
{
// Attempt to mount the drive described by gUSBDrive as drive 'A'
// The deviceAddress parameter describes the USB address of the device; it is initialized by the application in the
// USB_ApplicationEventHandler function when a new device is detected.
if( FILEIO_DriveMount ('A', &gUSBDrive, &deviceAddress) == FILEIO_ERROR_NONE)
{
demoState = OPENING_FILE;
}
break;
}
case OPENING_FILE:
// Opening a file with the FILEIO_OPEN_WRITE option allows us to write to the file.
// Opening a file with the FILEIO_OPEN_CREATE file will create the file if it does not already exist.
// Opening a file with the FILEIO_OPEN_TRUNCATE file will truncate it to a 0-length file if it already exists.
if(FILEIO_Open(&myFile, "LOG.CSV", FILEIO_OPEN_WRITE | FILEIO_OPEN_CREATE | FILEIO_OPEN_TRUNCATE) == FILEIO_RESULT_SUCCESS)
{
//Opening the file failed. Since we can't write to the
// device, abort the write attempt and wait for the device
// to be removed.
demoState = WRITING_TO_FILE;
blinkCount = 0;
sampleRequested = false;
TIMER_RequestTick(&APP_HostMSDDataLoggerTickHandler, 50);
LED_On(LED_USB_HOST_MSD_DATA_LOGGER);
ADC_ChannelEnable(ADC_USB_HOST_MSD_DATA_SOURCE);
break;
}
break;
case WRITING_TO_FILE:
if(sampleRequested == true)
{
uint16_t adcResult;
int charCount;
sampleRequested = false;
adcResult = ADC_Read10bit(ADC_USB_HOST_MSD_DATA_SOURCE);
charCount = sprintf(printBuffer, "%d\r\n", adcResult);
//Write some data to the new file.
FILEIO_Write(printBuffer, 1, charCount, &myFile);
}
if(BUTTON_IsPressed(BUTTON_USB_HOST_MSD_DATA_LOGGER) == true)
{
demoState = CLOSING_FILE;
}
break;
case CLOSING_FILE:
//Always make sure to close the file so that the data gets
// written to the drive.
FILEIO_Close(&myFile);
TIMER_CancelTick(&APP_HostMSDDataLoggerTickHandler);
demoState = UNMOUNT_DRIVE;
break;
case UNMOUNT_DRIVE:
// Unmount the drive since it is no longer in use.
FILEIO_DriveUnmount ('A');
//Now that we are done writing, we can do nothing until the
// drive is removed.
demoState = WAITING_FOR_DETACH;
break;
case WAITING_FOR_DETACH:
LED_Off(LED_USB_HOST_MSD_DATA_LOGGER);
break;
default:
break;
}
}
/*********************************************************************
* Function: void APP_HostHIDKeyboardTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized via
* the APP_HostHIDKeyboardInitialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_HostHIDKeyboardTasks()
{
uint8_t error;
uint8_t count;
if(!USBHostHID_ApiDeviceDetect())
{
if(keyboard.state != WAITING_FOR_DEVICE)
{
keyboard.state = DEVICE_NOT_CONNECTED;
keyboard.inUse = false;
if(keyboard.keys.buffer != NULL)
{
free(keyboard.keys.buffer);
keyboard.keys.buffer = NULL;
}
}
}
switch(keyboard.state)
{
case DEVICE_NOT_CONNECTED:
PRINT_ClearScreen();
PRINT_String("Attach keyboard\r\n", 17);
keyboard.state = WAITING_FOR_DEVICE;
LED_Off(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);
break;
case WAITING_FOR_DEVICE:
if(USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */
{
PRINT_ClearScreen();
SYSTEM_Initialize(SYSTEM_STATE_USB_HOST_HID_KEYBOARD);
LED_On(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);
keyboard.state = DEVICE_CONNECTED;
TIMER_RequestTick(&APP_HostHIDTimerHandler, 10);
}
break;
case DEVICE_CONNECTED:
break;
case GET_INPUT_REPORT:
if(USBHostHID_ApiGetReport( keyboard.keys.id,
keyboard.keys.normal.parsed.details.interfaceNum,
keyboard.keys.size,
keyboard.keys.buffer
)
)
{
/* Host may be busy/error -- keep trying */
}
else
{
keyboard.state = INPUT_REPORT_PENDING;
}
break;
case INPUT_REPORT_PENDING:
if(USBHostHID_ApiTransferIsComplete(&error, &count))
{
if(error || (count == 0))
{
keyboard.state = DEVICE_CONNECTED;
}
else
{
keyboard.state = DEVICE_CONNECTED;
App_ProcessInputReport();
if(keyboard.leds.updated == true)
{
keyboard.state = SEND_OUTPUT_REPORT;
}
}
}
break;
case SEND_OUTPUT_REPORT: /* Will be done while implementing Keyboard */
if(USBHostHID_ApiSendReport( keyboard.leds.parsed.details.reportID,
keyboard.leds.parsed.details.interfaceNum,
keyboard.leds.parsed.details.reportLength,
(uint8_t*)&keyboard.leds.report
)
)
{
/* Host may be busy/error -- keep trying */
}
else
{
keyboard.state = OUTPUT_REPORT_PENDING;
}
break;
case OUTPUT_REPORT_PENDING:
if(USBHostHID_ApiTransferIsComplete(&error, &count))
{
keyboard.leds.updated = false;
keyboard.state = DEVICE_CONNECTED;
}
break;
case ERROR_REPORTED:
break;
default:
break;
}
}
/*********************************************************************
* Function: void APP_HostHIDKeyboardTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized via
* the APP_HostHIDKeyboardInitialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_HostHIDKeyboardTasks() {
uint8_t error;
uint8_t count;
if (!USBHostHID_ApiDeviceDetect()) {
if (pickit.state != WAITING_FOR_DEVICE) {
pickit.state = DEVICE_NOT_CONNECTED;
#ifdef DEBUG_MODE
UART2PrintString("APP: PICkit Disconnected!\n");
#endif
pickit.inUse = false;
if (pickit.buffer != NULL) {
free(pickit.buffer);
pickit.buffer = NULL;
}
}
}
switch (pickit.state) {
case DEVICE_NOT_CONNECTED:
//PRINT_ClearScreen();
#ifdef DEBUG_MODE
UART2PrintString("APP: Attach PICkit\n");
#endif
pickit.state = WAITING_FOR_DEVICE;
IEC0bits.U1RXIE=0;
LED_Off(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);
break;
case WAITING_FOR_DEVICE:
if (USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */ {
//PRINT_ClearScreen();
SYSTEM_Initialize(SYSTEM_STATE_USB_HOST_HID_KEYBOARD);
LED_On(LED_USB_HOST_HID_KEYBOARD_DEVICE_READY);
pickit.state = DEVICE_CONNECTED;
//timwuu 2015.12.31 change control right from timer3 to uart
TIMER_RequestTick(&APP_HostHIDTimerHandler, 2); //2ms
}
break;
case DEVICE_CONNECTED:
break;
case GET_INPUT_REPORT:
if (USBHostHID_ApiGetReport(pickit.details.reportID,
pickit.details.interfaceNum,
pickit.size,
pickit.buffer
)
) {
/* Host may be busy/error -- keep trying */
#ifdef DEBUG_MODE
UART2PrintString("GET_INPUT_REPORT:BUSY\n");
#endif
} else {
#ifdef DEBUG_MODE
UART2PrintString("GET_INPUT_REPORT:OK\n");
#endif
pickit.state = INPUT_REPORT_PENDING;
}
break;
case INPUT_REPORT_PENDING:
if (USBHostHID_ApiTransferIsComplete(&error, &count)) {
if (error || (count == 0)) {
#ifdef DEBUG_MODE
if(error) UART2PrintString("INPUT_REPORT_PENDING:ERROR\n");
if(count==0) UART2PrintString("INPUT_REPORT_PENDING:ZERO\n");
#endif
pickit.state = DEVICE_CONNECTED;
} else {
#ifdef DEBUG_MODE
UART2PrintString("INPUT_REPORT_PENDING:OK\n");
#endif
UART2PutHex(pickit.buffer[61]);
UART2PutHex(pickit.buffer[60]);
UART2PutChar(':');
pickit.state = DEVICE_CONNECTED;
App_ProcessInputReport();
}
}
break;
case SEND_OUTPUT_REPORT:
//App_PrepareOutputReport();
if (USBHostHID_ApiSendReport(pickit.details.reportID,
pickit.details.interfaceNum,
pickit.size,
(uint8_t *)cmdBuffer)) {
//pickit.buffer)) {
/* Host may be busy/error -- keep trying */
#ifdef DEBUG_MODE
UART2PrintString("SEND_OUTPUT_REPORT:BUSY\n");
#endif
} else {
#ifdef DEBUG_MODE
UART2PrintString("SEND_OUTPUT_REPORT:OK\n");
#endif
UB_SetCmdBufferStateEmpty();
pickit.state = OUTPUT_REPORT_PENDING;
}
break;
case OUTPUT_REPORT_PENDING:
//timijk 2016.01.13 Issue
if (USBHostHID_ApiTransferIsComplete(&error, &count)) {
#ifdef DEBUG_MODE
UART2PrintString("OUTPUT_REPORT_PENDING\n");
#endif
//?timwuu 2016.01.02 signal the device is ready for the next command
// if(error) {
// UART2PutChar('*');
// UART2PutHex(error);
// LATBbits.LATB15 =1;
// pickit.state = SEND_OUTPUT_REPORT; //resent the data
// }
// else
// {
U1TXREG = 0x00; //LENGTH ZERO DATA
pickit.state = DEVICE_CONNECTED;
// }
}
break;
case ERROR_REPORTED:
break;
default:
break;
}
}
/*********************************************************************
* Function: void APP_HostHIDMouseTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized via
* the APP_HostHIDMouseInitialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_HostHIDMouseTasks()
{
uint8_t error;
uint8_t count;
if(!USBHostHID_ApiDeviceDetect())
{
if(mouse.state != WAITING_FOR_DEVICE)
{
mouse.state = DEVICE_NOT_CONNECTED;
mouse.inUse = false;
if(mouse.buffer != NULL)
{
free(mouse.buffer);
mouse.buffer = NULL;
}
}
}
switch(mouse.state)
{
case DEVICE_NOT_CONNECTED:
PRINT_ClearScreen();
PRINT_String("Attach mouse\r\n", 17);
mouse.state = WAITING_FOR_DEVICE;
break;
case WAITING_FOR_DEVICE:
if(USBHostHID_ApiDeviceDetect()) /* True if report descriptor is parsed with no error */
{
SYSTEM_Initialize(SYSTEM_STATE_USB_HOST_HID_MOUSE);
PRINT_ClearScreen();
PRINT_String("L:0 R:0\r\nX:0x00 Y:0x00\r\n", 24);
mouse.state = DEVICE_CONNECTED;
TIMER_RequestTick(&APP_HostHIDTimerHandler, 10);
}
break;
case DEVICE_CONNECTED:
break;
case GET_INPUT_REPORT:
if(USBHostHID_ApiGetReport( mouse.deflection.parsed.details.reportID,
mouse.deflection.parsed.details.interfaceNum,
mouse.deflection.parsed.details.reportLength,
mouse.buffer
)
)
{
/* Host may be busy/error -- keep trying */
}
else
{
mouse.state = INPUT_REPORT_PENDING;
}
break;
case INPUT_REPORT_PENDING:
if(USBHostHID_ApiTransferIsComplete(&error, &count))
{
if(error || (count != mouse.deflection.parsed.details.reportLength))
{
mouse.state = DEVICE_CONNECTED;
}
else
{
mouse.state = DEVICE_CONNECTED;
App_ProcessInputReport();
}
}
break;
case ERROR_REPORTED:
break;
default:
break;
}
}
