void ProcessIO( void )
{
if ( ( USBGetDeviceState() < CONFIGURED_STATE ) || USBIsDeviceSuspended() )
return;
ServiceRequests();
}
MAIN_RETURN main(void)
{
SYSTEM_Initialize(SYSTEM_STATE_USB_START);
USBDeviceInit();
USBDeviceAttach();
IPR1 = 0; //All others interrupt sources will be Low priority
IPR2 = 32; //USB interrupt is High priority
RCONbits.IPEN = 1; //Enabling interrupt priority
ADCON1bits.PCFG = 0x0F; //By default all I/O digital
CMCONbits.CM = 7; //Comparators off by default
while(1)
{
SYSTEM_Tasks();
#if defined(USB_POLLING)
// Interrupt or polling method. If using polling, must call
// this function periodically. This function will take care
// of processing and responding to SETUP transactions
// (such as during the enumeration process when you first
// plug in). USB hosts require that USB devices should accept
// and process SETUP packets in a timely fashion. Therefore,
// when using polling, this function should be called
// regularly (such as once every 1.8ms or faster** [see
// inline code comments in usb_device.c for explanation when
// "or faster" applies]) In most cases, the USBDeviceTasks()
// function does not take very long to execute (ex: <100
// instruction cycles) before it returns.
USBDeviceTasks();
#endif
/* If the USB device isn't configured yet, we can't really do anything
* else since we don't have a host to talk to. So jump back to the
* top of the while loop. */
if( USBGetDeviceState() < CONFIGURED_STATE )
{
/* Jump back to the top of the while loop. */
continue;
}
/* If we are currently suspended, then we need to see if we need to
* issue a remote wakeup. In either case, we shouldn't process any
* keyboard commands since we aren't currently communicating to the host
* thus just continue back to the start of the while loop. */
if( USBIsDeviceSuspended() == true )
{
/* Jump back to the top of the while loop. */
continue;
}
//Application specific tasks
APP_DeviceCustomHIDTasks();
}//end while
}//end main
/********************************************************************
* Function: void main(void)
*******************************************************************/
MAIN_RETURN main(void)
{
SYSTEM_Initialize();
USBDeviceInit();
USBDeviceAttach();
while(1)
{
SYSTEM_Tasks();
#if defined(USB_POLLING)
USBDeviceTasks();
#endif
/* If the USB device isn't configured yet, we can't really do anything
* else since we don't have a host to talk to. So jump back to the
* top of the while loop. */
if( USBGetDeviceState() < CONFIGURED_STATE )
{
/* Jump back to the top of the while loop. */
continue;
}
/* If we are currently suspended, then we need to see if we need to
* issue a remote wakeup. In either case, we shouldn't process any
* keyboard commands since we aren't currently communicating to the host
* thus just continue back to the start of the while loop. */
if( USBIsDeviceSuspended() == true )
{
/* Jump back to the top of the while loop. */
continue;
}
// implement nMCLR button
if ( BUTTON_IsPressed(BUTTON_S1)) {
LUNSoftDetach(0); // mark the media as temporarily unavailable
ICSP_nMCLR = SLAVE_RESET;
LED_Off(GREEN_LED); // turn off RED LED to indicate ready for download
LED_On (RED_LED);
DIRECT_Initialize(); // reset the programming state machine
}
else { // simply act as a slave reset
LUNSoftAttach(0); // mark the media as available
if ( !DIRECT_ProgrammingInProgress()) { // do not release during prog.!
ICSP_nMCLR = SLAVE_RUN;
LED_On(GREEN_LED); // turn off RED LED to indicate ready for download
LED_Off(RED_LED);
}
}
//Application specific tasks
APP_DeviceMSDTasks();
APP_DeviceCDCEmulatorTasks();
}//end while
}//end main
void USB_CDC_task(void) {
#if defined(USB_POLLING)
// Interrupt or polling method. If using polling, must call
// this function periodically. This function will take care
// of processing and responding to SETUP transactions
// (such as during the enumeration process when you first
// plug in). USB hosts require that USB devices should accept
// and process SETUP packets in a timely fashion. Therefore,
// when using polling, this function should be called
// regularly (such as once every 1.8ms or faster** [see
// inline code comments in usb_device.c for explanation when
// "or faster" applies]) In most cases, the USBDeviceTasks()
// function does not take very long to execute (ex: <100
// instruction cycles) before it returns.
USBDeviceTasks();
#endif
/* If the USB device isn't configured yet, we can't really do anything
* else since we don't have a host to talk to. So jump back to the
* top of the while loop. */
if (USBGetDeviceState() < CONFIGURED_STATE) {
/* Jump back to the top of the while loop. */
return;
}
/* If we are currently suspended, then we need to see if we need to
* issue a remote wakeup. In either case, we shouldn't process any
* keyboard commands since we aren't currently communicating to the host
* thus just continue back to the start of the while loop. */
if (USBIsDeviceSuspended() == true) {
/* Jump back to the top of the while loop. */
return;
}
// Tx task
uint16_t length = 0;
while (ringbuf_num(&usb_tx)) {
writeBuffer[length++] = ringbuf_pop(&usb_tx);
if (length >= CDC_DATA_IN_EP_SIZE) {
break;
}
}
if (length) {
USB_CDC_send(length);
}
// Rx task
length = USB_CDC_get();
if (length) {
for (uint16_t i = 0; i < length; i++) {
ringbuf_put(&usb_rx, readBuffer[i]);
}
}
}
void APP_LEDUpdateUSBStatus(void)
{
static uint16_t ledCount = 0;
if(USBIsDeviceSuspended() == true)
{
LED_Off(LED_USB_DEVICE_STATE);
return;
}
switch(USBGetDeviceState())
{
case CONFIGURED_STATE:
/* We are configured. Blink fast.
* On for 75ms, off for 75ms, then reset/repeat. */
if(ledCount == 1)
{
LED_On(LED_USB_DEVICE_STATE);
}
else if(ledCount == 75)
{
LED_Off(LED_USB_DEVICE_STATE);
}
else if(ledCount > 150)
{
ledCount = 0;
}
break;
default:
/* We aren't configured yet, but we aren't suspended so let's blink with
* a slow pulse. On for 50ms, then off for 950ms, then reset/repeat. */
if(ledCount == 1)
{
LED_On(LED_USB_DEVICE_STATE);
}
else if(ledCount == 50)
{
LED_Off(LED_USB_DEVICE_STATE);
}
else if(ledCount > 950)
{
ledCount = 0;
}
break;
}
/* Increment the millisecond counter. */
ledCount++;
}
void usb_send(const char *format, ...)
{
//char *usb_msg;
static unsigned char usb_msg[CDC_DATA_OUT_EP_SIZE];
va_list args;
va_start(args,__format);
sprintf(usb_msg,format,args);
if (( USBGetDeviceState() < CONFIGURED_STATE ) || ( USBIsDeviceSuspended() == true ))
{
return;
}
else
{
if (mUSBUSARTIsTxTrfReady())
{
putUSBUSART(usb_msg,strlen(usb_msg));
}
CDCTxService();
}
}
BOOL ChipKITUSBIsDeviceSuspended(void)
{
return(USBIsDeviceSuspended());
}
int main(void)
{
SYSTEM_Initialize(SYSTEM_STATE_USB_START);
LED_Initialize();
APP_KeyboardConfigure();
#ifdef WITH_HOS
HosCheckDFU(BOOT_FLAGS_VALUE & BOOT_WITH_APP);
if (!isUSBMode() || !isBusPowered()) {
HosMainLoop();
}
for (uint16_t i = 0; i < HOS_STARTUP_DELAY; ++i) {
if (HosSleep(HOS_TYPE_DEFAULT)) {
break;
}
__delay_ms(4);
}
#endif
USBDeviceInit();
USBDeviceAttach();
for (;;)
{
#ifdef WITH_HOS
if (!isBusPowered() || !isUSBMode()) {
Reset();
Nop();
Nop();
// NOT REACHED HERE
}
#endif
SYSTEM_Tasks();
#if defined(USB_POLLING)
/* Check bus status and service USB interrupts. Interrupt or polling
* method. If using polling, must call this function periodically.
* This function will take care of processing and responding to SETUP
* transactions (such as during the enumeration process when you first
* plug in). USB hosts require that USB devices should accept and
* process SETUP packets in a timely fashion. Therefore, when using
* polling, this function should be called regularly (such as once every
* 1.8ms or faster** [see inline code comments in usb_device.c for
* explanation when "or faster" applies]) In most cases, the
* USBDeviceTasks() function does not take very long to execute
* (ex: <100 instruction cycles) before it returns. */
USBDeviceTasks();
#endif
APP_LEDUpdateUSBStatus();
/* If the USB device isn't configured yet, we can't really do anything
* else since we don't have a host to talk to. So jump back to the
* top of the while loop. */
if (USBGetDeviceState() < CONFIGURED_STATE)
{
/* Jump back to the top of the while loop. */
continue;
}
/* If we are currently suspended, then we need to see if we need to
* issue a remote wakeup. In either case, we shouldn't process any
* keyboard commands since we aren't currently communicating to the host
* thus just continue back to the start of the while loop. */
if (USBIsDeviceSuspended())
{
//Check if we should assert a remote wakeup request to the USB host,
//when the user presses the pushbutton.
if (BUTTON_IsPressed())
{
USBCBSendResume(); //Does nothing unless we are in USB suspend with remote wakeup armed.
}
/* Jump back to the top of the while loop. */
continue;
}
if (USBIsBusSuspended())
{
/* Jump back to the top of the while loop. */
continue;
}
/* Run the keyboard tasks. */
APP_KeyboardTasks();
}//end while
}//end main
void main() {
InitializeSystem();
red = FALSE;
green = FALSE;
#if defined(USB_INTERRUPT)
USBDeviceAttach();
#endif
while (1){
#if defined(USB_POLLING)
// Check bus status and service USB interrupts.
USBDeviceTasks(); // Interrupt or polling method. If using polling, must call
// this function periodically. This function will take care
// of processing and responding to SETUP transactions
// (such as during the enumeration process when you first
// plug in). USB hosts require that USB devices should accept
// and process SETUP packets in a timely fashion. Therefore,
// when using polling, this function should be called
// regularly (such as once every 1.8ms or faster** [see
// inline code comments in usb_device.c for explanation when
// "or faster" applies]) In most cases, the USBDeviceTasks()
// function does not take very long to execute (ex: <100
// instruction cycles) before it returns.
#endif
Tran_String_UART(init);
lcd_gotoxy(1,2);
lcd_putstr(init);
if((USBGetDeviceState() \< CONFIGURED_STATE) ||(USBIsDeviceSuspended() == TRUE))
{
#if defined USE_UART
Tran_String_UART(error);
#endif
#if defined USE_LCD
lcd_clear();
lcd_gotoxy(3,1);
lcd_putstr(error);
#endif
//Either the device is not configured or we are suspended
// so we don't want to do execute any application code
continue; //go back to the top of the while loop
}
else
#if defined USE_UART
Tran_String_UART(success);
#endif
#if defined USE_LCD
lcd_clear();
lcd_gotoxy(3,1);
lcd_putstr(success);
#endif
// if(!HIDRxHandleBusy(USBOutHandle))
// {
// if (outbuffer[0] == 0) {
// if(!HIDTxHandleBusy(USBInHandle))
// {
// inbuffer[0] = green;
// inbuffer[1] = red;
// USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&inbuffer[0], HID_IN_SIZE);
// }
// }
// if (outbuffer[0] == 1) {
// if (outbuffer[1] == 1) green = TRUE; else green = FALSE;
// if (outbuffer[2] == 1) red = TRUE; else red = FALSE;
// if (green) LATCbits.LATC6 = 1; else LATCbits.LATC6 = 0;
// if (red) LATCbits.LATC7 = 1; else LATCbits.LATC7 = 0;
// }
// if(outbuffer[0]==2){
// LATCbits.LATC6=0;
// LATCbits.L4ATC7=0;
// }
// USBOutHandle = HIDRxPacket(HID_EP, (BYTE*)&outbuffer, HID_OUT_SIZE);
// }
}
}
/*********************************************************************
* Function: void APP_DeviceAudioMIDITasks(void);
*
* Overview: Keeps the Custom HID demo running.
*
* PreCondition: The demo should have been initialized and started via
* the APP_DeviceAudioMIDIInitialize() and APP_DeviceAudioMIDIStart() demos
* respectively.
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_DeviceAudioMIDITasks()
{
/* If the device is not configured yet, or the device is suspended, then
* we don't need to run the demo since we can't send any data.
*/
if( (USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == true))
{
return;
}
if(!USBHandleBusy(USBRxHandle))
{
//We have received a MIDI packet from the host, process it and then
// prepare to receive the next packet
//INSERT MIDI PROCESSING CODE HERE
//Get ready for next packet (this will overwrite the old data)
USBRxHandle = USBRxOnePacket(USB_DEVICE_AUDIO_MIDI_ENDPOINT,(uint8_t*)&ReceivedDataBuffer,64);
}
/* If the user button is pressed... */
if(BUTTON_IsPressed(BUTTON_DEVICE_AUDIO_MIDI) == true)
{
/* and we haven't sent a transmission in the past 100ms... */
if(msCounter == 0)
{
/* and we have sent the NOTE_OFF for the last note... */
if(sentNoteOff == true)
{
/* and we aren't currently trying to transmit data... */
if(!USBHandleBusy(USBTxHandle))
{
//Then reset the 100ms counter
msCounter = 100;
midiData.Val = 0; //must set all unused values to 0 so go ahead
// and set them all to 0
midiData.CableNumber = 0;
midiData.CodeIndexNumber = MIDI_CIN_NOTE_ON;
midiData.DATA_0 = 0x90; //Note on
midiData.DATA_1 = pitch; //pitch
midiData.DATA_2 = 0x7F; //velocity
USBTxHandle = USBTxOnePacket(USB_DEVICE_AUDIO_MIDI_ENDPOINT,(uint8_t*)&midiData,4);
/* we now need to send the NOTE_OFF for this note. */
sentNoteOff = false;
}
}
}
}
else
{
if(msCounter == 0)
{
if(sentNoteOff == false)
{
if(!USBHandleBusy(USBTxHandle))
{
//Debounce counter for 100ms
msCounter = 100;
midiData.Val = 0; //must set all unused values to 0 so go ahead
// and set them all to 0
midiData.CableNumber = 0;
midiData.CodeIndexNumber = MIDI_CIN_NOTE_ON;
midiData.DATA_0 = 0x90; //Note off
midiData.DATA_1 = pitch++; //pitch
midiData.DATA_2 = 0x00; //velocity
if(pitch == 0x49)
{
pitch = 0x3C;
}
USBTxHandle = USBTxOnePacket(USB_DEVICE_AUDIO_MIDI_ENDPOINT,(uint8_t*)&midiData,4);
sentNoteOff = true;
}
}
}
}
}
bool is_usb_available(void) {
return !(USBGetDeviceState() < CONFIGURED_STATE || USBIsDeviceSuspended() == true);
}
// Attached to USB
void RunAttached(void)
{
// Do this first to give the card time to start up
SD_ENABLE(); // Turn on SD card
// Enable peripherals
RtcInterruptOn(0); // Keeps time upto date
LED_SET(LED_WHITE);
CLOCK_PLL(); // PLL clock
// Initialize sensors
// Check if we have an accelerometer
AccelVerifyDeviceId();
// Check if we have a gyro
#ifdef USE_GYRO
GyroVerifyDeviceId();
#endif
#ifdef HAS_PROX
// Check for prox
ProxVerifyDeviceId();
ProxStartup();
#endif
// Initialize sensors
AccelStartup(ACCEL_RANGE_4G|ACCEL_RATE_100);
#ifdef USE_GYRO
GyroStartup();
#endif
AdcInit();
#ifndef NO_DISPLAY
DisplayClear();
Display_print_xy(" <= USB =>",0,2,2);
#endif
status.diskMounted = (status.lockCode == 0x0000) ? 1 : 0;
status.stream = 0;
// MDD_MediaInitialize(); // KL FIX: The SD card is re-inited in the usb framework which causes a lockup in some cases
// Power up module if off
PMD4bits.USB1MD = 0;
USBInitializeSystem(); // Initializes buffer, USB module SFRs and firmware
#ifdef USB_INTERRUPT
USBDeviceAttach();
#endif
while(USB_BUS_SENSE && restart != 1)
{
// Check bus status and service USB interrupts.
#ifndef USB_INTERRUPT
USBDeviceTasks(); // Interrupt or polling method. If using polling, must call
#endif
USBProcessIO();
if ((USBGetDeviceState() >= CONFIGURED_STATE) && (USBIsDeviceSuspended() == FALSE))
{
const char *line = _user_gets();
status.attached = 1;
if (line != NULL)
{
status.stream = 0; // Disable streaming
SettingsCommand(line, SETTINGS_USB);
}
}
else
{
status.attached = -1;
}
TimedTasks();
// Stream accelerometer data
if (status.stream)
{
#define STREAM_RATE 10
#define STREAM_INTERVAL (0x10000UL / STREAM_RATE)
static unsigned long lastSampleTicks = 0;
unsigned long now = RtcTicks();
if (lastSampleTicks == 0) { lastSampleTicks = now; }
if (now - lastSampleTicks > STREAM_INTERVAL)
{
accel_t accelSample;
#ifdef USE_GYRO
gyro_t gyroSample;
#endif
extern unsigned char scratchBuffer[];
char * ptr = (char *)scratchBuffer;
unsigned short len;
lastSampleTicks += STREAM_INTERVAL;
if (now - lastSampleTicks > 2 * STREAM_INTERVAL) { lastSampleTicks = now; } // not keeping up with sample rate
#ifdef HAS_PROX
// Sample sensors
if(ProxSampleReady())
{
ProxReadSample();
ProxStartSample();
}
#endif
AccelSingleSample(&accelSample);
#ifdef USE_GYRO
GyroSingleSample(&gyroSample);
#endif
// Write ascii to scratch buffer
ptr = (char *)scratchBuffer;
ptr += sprintf(ptr, "\f$ACCEL=%d,%d,%d\r\n", accelSample.x, accelSample.y, accelSample.z);
#ifdef USE_GYRO
ptr += sprintf(ptr, "$GYRO=%d,%d,%d\r\n", gyroSample.x, gyroSample.y, gyroSample.z);
#endif
#ifdef HAS_PROX
ptr += sprintf(ptr, "$PROX=%d\r\n", prox.proximity);
ptr += sprintf(ptr, "$LIGHT=%d\r\n", prox.light);
#endif
len = (unsigned short)((void*)ptr - (void*)scratchBuffer);
// Stream over USB
if ((status.stream) && status.attached == 1) { usb_write(scratchBuffer, len); }
}
}
}
#if defined(USB_INTERRUPT)
USBDeviceDetach();
#endif
status.attached = -1;
return;
}
