/* This call only retrieves data that is already waiting in the USB buffer -- that is, data that has
* already been received by the MCU. It assumes a previous, open receive operation (began by a direct
* call to USBxxx_receiveData()) is NOT underway on this interface; and no receive operation remains
* open after this call returns. It doesn't check for kUSBxxx_busNotAvailable, because it doesn't
* matter if it's not. size is the maximum that is allowed to be received before exiting; i.e., it
* is the size allotted to dataBuf. Returns the number of bytes received. */
uint16_t hidReceiveDataInBuffer (uint8_t* dataBuf, uint16_t size, uint8_t intfNum)
{
uint16_t bytesInBuf;
uint16_t rxCount = 0;
uint8_t* currentPos = dataBuf;
while (bytesInBuf = USBHID_bytesInUSBBuffer(intfNum)){
if ((uint16_t)(currentPos - dataBuf + bytesInBuf) <= size){
rxCount = bytesInBuf;
USBHID_receiveData(currentPos,rxCount,intfNum);
currentPos += rxCount;
} else {
rxCount = size - (currentPos - dataBuf);
USBHID_receiveData(currentPos,rxCount,intfNum);
currentPos += rxCount;
return (currentPos - dataBuf);
}
}
return (currentPos - dataBuf);
}
/* This call only retrieves data that is already waiting in the USB buffer -- that is, data that has
* already been received by the MCU. It assumes a previous, open receive operation (began by a direct
* call to USBxxx_receiveData()) is NOT underway on this interface; and no receive operation remains
* open after this call returns. It doesn't check for kUSBxxx_busNotAvailable, because it doesn't
* matter if it's not. size is the maximum that is allowed to be received before exiting; i.e., it
* is the size allotted to dataBuf. Returns the number of bytes received. */
WORD hidReceiveDataInBuffer (BYTE* dataBuf, WORD size, BYTE intfNum)
{
WORD bytesInBuf;
WORD rxCount = 0;
BYTE* currentPos = dataBuf;
while (bytesInBuf = USBHID_bytesInUSBBuffer(intfNum)){
if ((WORD)(currentPos - dataBuf + bytesInBuf) <= size){
rxCount = bytesInBuf;
USBHID_receiveData(currentPos,rxCount,intfNum);
currentPos += rxCount;
} else {
rxCount = size - (currentPos - dataBuf);
USBHID_receiveData(currentPos,rxCount,intfNum);
currentPos += rxCount;
return (currentPos - dataBuf);
}
}
return (currentPos - dataBuf);
}
/*----------------------------------------------------------------------------+
| Main Routine |
+----------------------------------------------------------------------------*/
VOID main(VOID)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
Init_StartUp();
USB_init();
USB_setEnabledEvents(kUSB_VbusOnEvent + kUSB_VbusOffEvent + kUSB_UsbSuspendEvent + kUSB_UsbResumeEvent + kUSB_receiveCompletedEvent + kUSB_UsbResetEvent);
// Check if we're already physically attached to USB, and if so, connect to it
// This is the same function that gets called automatically when VBUS gets attached.
if (USB_connectionInfo() & kUSB_vbusPresent)
USB_handleVbusOnEvent();
while(1)
{
switch(USB_connectionState())
{
case ST_USB_DISCONNECTED:
__bis_SR_register(LPM3_bits + GIE); // Enter LPM3 w/interrupt
break;
case ST_USB_CONNECTED_NO_ENUM:
break;
case ST_ENUM_ACTIVE:
if(!bCommandBeingProcessed) // If no command is being processed, then make sure there's a rcv operation
{ // open to receive the start of the "packet"
if(!(USBHID_intfStatus(0,&x,&y) & kUSBHID_waitingForReceive)) // Only open it if we haven't already done so
if(USBHID_receiveData(buffer,1,0) == kUSBHID_busNotAvailable) // Start a receive operation for a single byte -- the "size" byte of the "packet"
{
USBHID_abortReceive(&x,0); // Abort receive
break; // If bus is no longer available, escape out of the loop
}
}
__bis_SR_register(LPM0_bits + GIE); // Wait in LPM0 until a receive operation has completed
if(bDataReceiveCompleted_event)
{
bDataReceiveCompleted_event = FALSE;
if(!bCommandBeingProcessed) // This means that the incoming byte is the start of the "packet" -- the "size" byte
{
if ((buffer[0]>=0x31) && (buffer[0]<= 0x39))
{
size = buffer[0]-0x30; // It's in ASCII, so convert it to a number
if(USBHID_receiveData(buffer,size,0) == kUSBHID_busNotAvailable) // And then open a rcv operation for that size
{
USBHID_abortReceive(&x,0); // Abort receive
break; // If bus is no longer available, escape out of the loop
}
bCommandBeingProcessed = TRUE; // Now we're waiting for the "data" part of the "packet"
}
else
{
strcpy(outString,"\r\nEnter a valid number between 1 and 9\r\n\r\n"); // Prepare the outgoing string
if(hidSendDataInBackground((BYTE*)outString,strlen(outString),0,0)) // Send the response over USB
{
USBHID_abortSend(&x,0); // Operation may still be open; cancel it
break; // If the send fails, escape the main loop
}
bCommandBeingProcessed = FALSE; // Now we're back to waiting for the "size" byte
}
}
else // This means that the incoming data is the "data" part of the "packet"
{
strcpy(outString,"\r\nI received your packet with size of "); // Prepare the outgoing string
c[0] = (char)(size+0x30); // Convert the size back to ASCII
c[1] = 0; // Convert the size back to ASCII
outString[64] = 0;
strcat(outString,c);
strcat(outString," bytes.\r\n\r\n");
if(hidSendDataInBackground((BYTE*)outString,strlen(outString),0,0)) // Send the response over USB
{
USBHID_abortSend(&x,0); // Operation may still be open; cancel it
break; // If the send fails, escape the main loop
}
bCommandBeingProcessed = FALSE; // Now we're back to waiting for the "size" byte
}
}
break;
case ST_ENUM_SUSPENDED:
__bis_SR_register(LPM3_bits + GIE); // Enter LPM3 w/interrupt
break;
case ST_ENUM_IN_PROGRESS:
break;
case ST_NOENUM_SUSPENDED:
__bis_SR_register(LPM3_bits + GIE);
break;
case ST_ERROR:
_NOP();
break;
default:;
}
} // while(1)
} //main()