/********************************************************************
* Function: void main(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: Main program entry point.
*
* Note: None
*******************************************************************/
MAIN_RETURN main(void)
{
SYSTEM_Initialize(SYSTEM_STATE_USB_START);
USBDeviceInit();
USBDeviceAttach();
setup();
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
//Application specific tasks
APP_DeviceCDCBasicDemoTasks();
}//end while
}//end main
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
MAIN_RETURN main(void) {
gpio_init();
timer_init();
SYSTEM_Initialize(SYSTEM_STATE_USB_START);
USBDeviceInit();
USBDeviceAttach();
while (1) {
SYSTEM_Tasks();
#if defined(USB_POLLING)
USBDeviceTasks();
#endif
//APP_DeviceCDCBasicDemoTasks();
serial_update();
}
}
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
