void uart_reply(u8* data, u8 cnt)
{
u8 i, chksum;
memset(replyData, 0, OUT_BUFFER_MAX_CNT);
chksum = 0;
replyData[0] = uartCmd;
replyData[1] = cnt;
if(cnt)
{
memcpy(replyData + 2, data, cnt);
for(i = 0; i < cnt + 2; i++)
{
chksum ^= replyData[i];
}
replyData[i] = chksum;
for(i = 0; i < cnt + 3; i++)
{
UART2PutChar(replyData[i]);
}
}
else
{
replyData[2] = uartCmd;
UART2PutChar(replyData[0]);
UART2PutChar(replyData[1]);
UART2PutChar(replyData[2]);
}
}
/******************************************************************************
* Function: void putcUSART(char c)
*
* PreCondition: None
*
* Input: char c - character to print to the UART
*
* Output: None
*
* Side Effects: None
*
* Overview: Print the input character to the UART
*
* Note:
*
*****************************************************************************/
void putcUSART(char c)
{
#if defined(__18CXX)
TXREG = c;
#else
UART2PutChar(c);
#endif
}
void uart_resend(void)
{
u8 i = 0;
for(i = 0; i < replyData[1] + 3; i++)
{
UART2PutChar(replyData[i]);
}
}
int write(int handle, void *buffer, unsigned int len) {
if (handle == 1 || handle == 2) {
const char *p = buffer;
int i;
for (i = 0; i < len; ++i) {
UART2PutChar(*p++);
}
return len;
} else {
return -1;
}
}
write(int handle, void *buffer, unsigned int len) {
int i;
char temp;
volatile UxMODEBITS *umode = &U1MODEbits;
volatile UxSTABITS *ustatus = &U1STAbits;
volatile unsigned int *txreg = &U1TXREG;
volatile unsigned int *brg = &U1BRG;
switch (handle)
{
case 0:
case 1:
case 2:
if ((__C30_UART != 1) && (&U2BRG)) {
umode = &U2MODEbits;
ustatus = &U2STAbits;
txreg = &U2TXREG;
brg = &U2BRG;
}
if ((umode->UARTEN) == 0)
{
*brg = 0;
umode->UARTEN = 1;
}
if ((ustatus->UTXEN) == 0)
{
ustatus->UTXEN = 1;
}
for (i = len; i; --i)
{
while ((ustatus->TRMT) ==0);
//*txreg = *(char*)buffer++;
temp = *(char*)buffer++;
UART2PutChar(temp);
}
break;
default: {
/*SIMIO simio;
register PSIMIO psimio asm("w0") = &simio;
simio.method = SIM_WRITE;
simio.u.write.handle = handle;
simio.u.write.buffer = buffer;
simio.u.write.len = len;
//dowrite(psimio);
len = simio.u.write.len;*/
break;
}
}
return(len);
}
/****************************************************************************
Function:
BOOL USB_HID_DataCollectionHandler(void)
Description:
This function is invoked by HID client , purpose is to collect the
details extracted from the report descriptor. HID client will store
information extracted from the report descriptor in data structures.
Application needs to create object for each report type it needs to
extract.
For ex: HID_DATA_DETAILS pickit.keys.modifier.details;
HID_DATA_DETAILS is defined in file usb_host_hid_appl_interface.h
Each member of the structure must be initialized inside this function.
Application interface layer provides functions :
USBHostHID_ApiFindBit()
USBHostHID_ApiFindValue()
These functions can be used to fill in the details as shown in the demo
code.
Precondition:
None
Parameters:
None
Return Values:
true - If the report details are collected successfully.
false - If the application does not find the the supported format.
Remarks:
This Function name should be entered in the USB configuration tool
in the field "Parsed Data Collection handler".
If the application does not define this function , then HID cient
assumes that Application is aware of report format of the attached
device.
***************************************************************************/
bool APP_HostHIDKeyboardReportParser(void) {
uint8_t NumOfReportItem = 0;
uint8_t i;
USB_HID_ITEM_LIST* pitemListPtrs;
USB_HID_DEVICE_RPT_INFO* pDeviceRptinfo;
HID_REPORTITEM *reportItem;
HID_USAGEITEM *hidUsageItem;
//uint8_t usageIndex;
// uint8_t reportIndex;
// uint8_t usageItem;
/* The pickit is already in use. */
if (pickit.inUse == true) {
//PRINT_String( "-In Use-\r\n",10);
return false;
}
pDeviceRptinfo = USBHostHID_GetCurrentReportInfo(); // Get current Report Info pointer
pitemListPtrs = USBHostHID_GetItemListPointers(); // Get pointer to list of item pointers
/* Find Report Item Index for Modifier Keys */
/* Once report Item is located , extract information from data structures provided by the parser */
NumOfReportItem = pDeviceRptinfo->reportItems;
#ifdef DEBUG_MODE
UART2PrintString("APP: NumOfReportItem:");
UART2PutHex(NumOfReportItem);
UART2PutChar('\n');
USBHID_ReportDecriptor_Dump();
#endif
reportItem = &pitemListPtrs->reportItemList[0];
pickit.details.reportLength = 64; // (pitemListPtrs->reportList[reportIndex].inputBits + 7) / 8;
pickit.details.reportID = (uint8_t) reportItem->globals.reportID;
pickit.details.bitOffset = (uint8_t) reportItem->startBit;
pickit.details.bitLength = (uint8_t) reportItem->globals.reportsize;
pickit.details.count = (uint8_t) reportItem->globals.reportCount;
pickit.details.interfaceNum = USBHostHID_ApiGetCurrentInterfaceNum();
pickit.size = 64;
pickit.buffer = (uint8_t*) malloc(pickit.size);
pickit.inUse = true;
return (pickit.inUse);
}
void FileCallback(ADB_FILE_HANDLE f, const void* data, UINT32 data_len) {
if (data) {
UINT32 i;
UART2PrintString("***** Got file data *******\r\n");
for (i = 0; i < data_len; ++i) {
UART2PutHex(((const BYTE*) data)[i]);
UART2PutChar(' ');
}
} else {
if (data_len == 0) {
UART2PrintString("***** EOF *******\r\n");
} else {
UART2PrintString("***** Error *******\r\n");
}
state = STATE_DONE;
}
}
void log_print_buf(const void* buf, int size) {
const BYTE* byte_buf = (const BYTE*) buf;
int s = size;
while (size-- > 0) {
UART2PutHex(*byte_buf++);
UART2PutChar(' ');
}
UART2PutChar('\r');
UART2PutChar('\n');
byte_buf -= s;
while (s-- > 0) {
UART2PutChar(*byte_buf++);
}
UART2PutChar('\r');
UART2PutChar('\n');
}
/******************************************************************************
* Function: void putcUSART(char c)
*
* PreCondition: None
*
* Input: char c - character to print to the UART
*
* Output: None
*
* Side Effects: None
*
* Overview: Print the input character to the UART
*
* Note:
*
*****************************************************************************/
void putcUSART(char c)
{
UART2PutChar(c);
// led_blink();
}
void uart_process_cmd(void)
{
if(uartState == UART_CAL) // calculate checksum
{
u8 i, checksum;
checksum = uartByteCnt;
if(uartByteCnt)
{
for(i = 0; i < uartByteCnt; i++)
{
checksum ^= uartData[i];
}
}
checksum ^= uartCmd;
if(uartCheckSum != checksum)
{
uartState = UART_CHK_ERROR;
}
else
{
uartState = UART_EXE;
}
}
else if(uartState == UART_EXE)
{
(*uart_command[(uartCmd - FIRST_CMD_VALUE)])();
uartState = UART_IDLE;
}
else if(uartState == UART_CMD_TIMEOUT)
{
if(timeout_done())
{
u8 tmp;
UART2PutChar(NTAG_CMD_ERROR);
tmp = U2RXREG;
IFS1bits.U2RXIF = 0;
IEC1bits.U2RXIE = 1;
uartState = UART_IDLE;
}
}
else if(uartState == UART_CNT_TIMEOUT)
{
if(timeout_done())
{
u8 tmp;
UART2PutChar(NTAG_CNT_ERROR);
tmp = U2RXREG;
IFS1bits.U2RXIF = 0;
IEC1bits.U2RXIE = 1;
uartState = UART_IDLE;
}
}
else if(uartState == UART_CMD_ERROR)
{
UART2PutChar(NTAG_CMD_ERROR);
uartState = UART_IDLE;
}
else if(uartState == UART_CNT_ERROR)
{
UART2PutChar(NTAG_CNT_ERROR);
uartState = UART_IDLE;
}
else if(uartState == UART_CHK_ERROR)
{
UART2PutChar(NTAG_CHK_ERROR);
uartState = UART_IDLE;
}
else if(uartState == UART_RESEND)
{
uart_resend();
uartState = UART_IDLE;
}
else if(uartState != UART_IDLE)
{
if(timeout_done())
{
UART2PutChar(NTAG_TIMEOUT_ERROR);
uartState = UART_IDLE;
}
}
}
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
// Handle specific events.
switch ( (INT)event )
{
case EVENT_GENERIC_ATTACH:
if (size == sizeof(GENERIC_DEVICE_ID))
{
deviceAddress = ((GENERIC_DEVICE_ID *)data)->deviceAddress;
DemoState = DEMO_STATE_GET_DEV_VERSION;
UART2PrintString( "Generic demo device attached - event, deviceAddress=" );
UART2PutDec( deviceAddress );
UART2PrintString( "\r\n" );
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
for (i=1; i<((GENERIC_DEVICE_ID *)data)->serialNumberLength; i++)
{
UART2PutChar( ((GENERIC_DEVICE_ID *)data)->serialNumber[i] );
}
#endif
UART2PrintString( "\r\n" );
return TRUE;
}
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
DemoState = DEMO_INITIALIZE;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX_DONE: // The main state machine will poll the driver.
case EVENT_GENERIC_RX_DONE:
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
return TRUE;
break;
default:
break;
}
return FALSE;
} // USB_ApplicationEventHandler
/*********************************************************************
* 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;
}
}
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
#ifdef DEBUG_MODE
int data_num;
#endif
// Handle specific events.
switch (event)
{
case EVENT_GENERIC_ATTACH:
if (size == sizeof(GENERIC_DEVICE_ID))
{
deviceAddress = ((GENERIC_DEVICE_ID *)data)->deviceAddress;
UART2PrintString( "Generic demo device attached - event, deviceAddress=" );
UART2PutDec( deviceAddress );
UART2PrintString( "\r\n" );
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
for (i=1; i<((GENERIC_DEVICE_ID *)data)->serialNumberLength; i++)
{
UART2PutChar( ((GENERIC_DEVICE_ID *)data)->serialNumber[i] );
}
#endif
UART2PrintString( "\r\n" );
btClientData.Initialized = TRUE;
btClientData.State = BT_INITIALIZE;
return TRUE;
}
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX2_DONE: // The main state machine will poll the driver.
// UART2PrintString( "TX2_DONE\r\n" );
return TRUE;
case EVENT_GENERIC_RX2_DONE:
if(*(DWORD*)data != 0)
{
#ifdef DEBUG_MODE
UART2PrintString( "HCI:R2: " );
for(data_num=0;data_num<*(DWORD*)data;data_num++)
{UART2PutHex(buf2[data_num]);UART2PutChar(' ');}
UART2PrintString( "\r\n" );
#endif
phybusif_input_acl(cb,buf2,*(DWORD*)data);
}
btClientData.State = BT_STATE_IDLE;
return TRUE;
case EVENT_GENERIC_RX1_DONE:
if(*(DWORD*)data != 0)
{
#ifdef DEBUG_MODE
UART2PrintString( "HCI:R1: " );
for(data_num=0;data_num<*(DWORD*)data;data_num++)
{UART2PutHex(buf1[data_num]);UART2PutChar(' ');}
UART2PrintString( "\r\n" );
#endif
phybusif_input_event(cb,buf1,*(DWORD*)data);
}
btClientData.State = BT_STATE_IDLE;
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
return TRUE;
break;
default:
break;
}
return FALSE;
} // USB_ApplicationEventHandler
