int main() {
log_init();
// If bootloader mode not requested, go immediately to app.
if (!ShouldEnterBootloader()) {
OscCalibrateCached();
log_printf("Running app...");
__asm__("goto __APP_RESET");
}
// We need to enter bootloader mode, wait for the boot pin to be released.
while (!led_read());
// Now we can start!
led_init();
#ifdef SIGNAL_AFTER_BAD_RESET
if (RCON & 0b1100001001000000) {
SignalRcon();
}
#endif
log_printf("Hello from Bootloader!!!");
if (IsPin1Grounded()) {
log_printf("Erasing config.");
EraseConfig();
}
OscCalibrateCached();
Blink(5);
USBInitialize();
while (1) {
// Wait for connection
while (!(USBGetDeviceState() == CONFIGURED_STATE
&& CDCIsDtePresent())) USBTasks();
log_printf("Connected!");
BootProtocolInit();
while (USBGetDeviceState() == CONFIGURED_STATE && CDCIsDtePresent()) {
static char in_buf[64];
USBTasks();
BYTE size = getsUSBUSART(in_buf, sizeof(in_buf));
if (!BootProtocolProcess(in_buf, size)) {
log_printf("Protocol error. Will detach / re-attach.");
USBSoftDetach();
__delay_ms(2000);
USBDeviceAttach();
break;
}
BootProtocolTasks();
}
log_printf("Disconnected!");
}
return 0;
}
void ProcessIO( void )
{
if ( ( USBGetDeviceState() < CONFIGURED_STATE ) || USBIsDeviceSuspended() )
return;
ServiceRequests();
}
/*********************************************************************
* Function: void SYSTEM_Tasks(void)
*
* Overview: Runs system level tasks that keep the system running
*
* PreCondition: System has been initalized with SYSTEM_Initialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void SYSTEM_Tasks(void)
{
switch(softStartStatus)
{
case SOFT_START_POWER_OFF:
break;
case SOFT_START_POWER_START:
if(USBGetDeviceState() != CONFIGURED_STATE)
{
break;
}
AppPowerEnable();
softStartStatus = SOFT_START_POWER_ENABLED;
break;
case SOFT_START_POWER_ENABLED:
if(AppPowerReady() == true)
{
softStartStatus = SOFT_START_POWER_READY;
LED_Enable(LED_USB_DEVICE_STATE);
}
break;
case SOFT_START_POWER_READY:
break;
}
}
void usb_tty_task(void *pvParameters){
unsigned long tempo = 0;
stack_uso_usb = uxTaskGetStackHighWaterMark( NULL );
sinal_inicializado++;
while(1){
if ((TickGet() - tempo) >= (TICK_SECOND / 64)) {
tempo = TickGet();
usb_tty_status();
}
#if defined(USB_INTERRUPT)
if (USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE)){
USBDeviceAttach();
}
#endif
usb_tty_loop();
stack_uso_usb = uxTaskGetStackHighWaterMark( NULL );
}
}
int main(void) {
InitializeSystem();
initADCDMA();
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE))
{
USBDeviceAttach();
}
#endif
#if defined(USB_POLLING)
// Check bus status and service USB interrupts.
USBDeviceTasks();
#endif
while(1)
{
if (!ADC_DATA_READY)
continue;
ADC_DATA_READY = 0;
RunFFT();
putrsUSBUSART((char*)&fftOut[0].real);
ProcessIO();
}
return (EXIT_SUCCESS);
}
// *--------------------------------------------------------------------------------*
int main(){
mJTAGPortEnable(0); // JTAG des-habilitado
SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.-
AD1PCFG = 0xFFFF;
LED1_OUTPUT();
LED2_OUTPUT();
SW1_INPUT();
SW2_INPUT();
buttonCount = 0;
buttonPressed = FALSE;
stringPrinted = TRUE;
USBDeviceInit();
while(1){
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE)){
USBDeviceAttach();
}
#endif
#if defined(USB_POLLING)
// Check bus status and service USB interrupts.
USBDeviceTasks();
#endif
ProcessIO();
}
}
void main(void) {
InitializeSystem();
while (1) {
// Comprueba el terminal que indica la conexión USB al inicio o al reset
if (PORTBbits.RB4 == 1) {
// Si no se ha activado el USB, lo activa
if ((USBGetDeviceState() == DETACHED_STATE)) {
USBDeviceAttach();
} else {
// Si ya se ha activado, realiza las tareas USB
// USB Tasks
blinkUSBStatus();
processUSBData();
}
} else {
// Si no está conectado el terminal USB, entra en modo de bajo consumo
USBDeviceDetach();
LATCbits.LATC0 = 0;
OSCCONbits.IDLEN = 0;
Sleep();
Nop();
}
}//end while
}//end main
/*********************************************************************
* Function: void SYSTEM_Tasks(void)
*
* Overview: Runs system level tasks that keep the system running
*
* PreCondition: System has been initalized with SYSTEM_Initialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void SYSTEM_Tasks(void)
{
switch(softStartStatus)
{
case SOFT_START_POWER_OFF:
break;
case SOFT_START_POWER_START:
if(USBGetDeviceState() != CONFIGURED_STATE)
{
break;
}
AppPowerEnable();
softStartStatus = SOFT_START_POWER_ENABLED;
break;
case SOFT_START_POWER_ENABLED:
if(AppPowerReady() == true)
{
softStartStatus = SOFT_START_POWER_READY;
LED_Enable(LED_USB_DEVICE_STATE);
LED_Enable(LED_USB_DEVICE_HID_CUSTOM);
ADC_SetConfiguration(ADC_CONFIGURATION_DEFAULT);
ADC_Enable(ADC_CHANNEL_POTENTIOMETER);
}
break;
case SOFT_START_POWER_READY:
break;
}
}
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
/**
* update LED status
*/
void BlinkUSBStatus(void) {
#define BLINK_COUNT (0xffff/16)
static UINT16 led_count = 0xffff;
static USB_DEVICE_STATE lastState = DETACHED_STATE;
static BOOL blinkConfiguredSequence = FALSE;
led_count++;
if (USBSuspendControl == 1) {
LED_Off();
} else {
if (USBGetDeviceState() < CONFIGURED_STATE) {
if (blinkConfiguredSequence) {
blinkConfiguredSequence = FALSE;
}
if (lastState == CONFIGURED_STATE) {
ReceiverOff();
}
if (led_count == 0) {
LED_On();
} else if (led_count == BLINK_COUNT) {
LED_Off();
}
} else {
if (lastState != CONFIGURED_STATE) {
QueueInit();
ReceiverOn();
LED_On();
blinkConfiguredSequence = TRUE;
led_count = 0;
} else if (blinkConfiguredSequence && led_count == 0) {
blinkConfiguredSequence = FALSE;
LED_Off();
}
}
}
lastState = USBGetDeviceState();
}
static void CDCTasks() {
DWORD size;
if (channel_state > CHANNEL_DETACHED
&& USBGetDeviceState() == DETACHED_STATE) {
// handle detach
if (channel_state >= CHANNEL_OPEN) {
callback(NULL, 1, callback_arg);
}
channel_state = CHANNEL_DETACHED;
} else if (channel_state > CHANNEL_WAIT_DTE
&& !CDCIsDtePresent()) {
// handle close
if (channel_state >= CHANNEL_OPEN) {
callback(NULL, 0, callback_arg);
}
channel_state = CHANNEL_WAIT_DTE;
}
switch (channel_state) {
case CHANNEL_DETACHED:
if (USBGetDeviceState() == CONFIGURED_STATE) {
channel_state = CHANNEL_WAIT_DTE;
}
break;
case CHANNEL_WAIT_DTE:
if (CDCIsDtePresent()) {
channel_state = CHANNEL_WAIT_OPEN;
}
break;
case CHANNEL_WAIT_OPEN:
break;
case CHANNEL_OPEN:
size = getsUSBUSART(rx_buf, rx_buf_size);
if (size) {
callback(rx_buf, size, callback_arg);
}
break;
}
}
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++;
}
// Calibrate the oscillar according to the SOF clock coming from a USB host.
// This function will first block until a USB connection has been established.
// Then it will wait for 32 SOF's for the tuning process (will hang if they do
// not arrive!). Then, if will disconnect from the USB bus and wait 2 seconds.
// Upon exit, the _TUN register will hold the correct value.
static void OscCalibrate() {
int i;
led_init();
USBInitialize();
// Start timer2/3 as 32-bit, system clock (16MHz).
T2CON = 0x0008;
PR2 = PR3 = 0xFFFF;
T2CON = 0x8008;
// Wait for a USB connection. Blink meanwhile.
int led_counter = 0;
while (USBGetDeviceState() != POWERED_STATE) {
USBTasks();
if ((led_counter++ & 0x3FFF) == 0) led_toggle();
}
led_off();
log_printf("Connected to host. Starting calibration.");
// Start from 0 (redundant, but better be explicit).
_TUN = 0;
for (i = 0; i < 32; ++i) {
uint32_t duration;
// Repeat for sanity: if for some reason the SOF is too long or too short,
// ignore it.
do {
duration = MeasureSOF();
} while (duration < 15000 || duration > 17000);
if (duration < 16000 && _TUN != 31) {
// We're running too slow.
_TUN++;
} else if (duration > 16000 && _TUN != 32) {
// We're running too fast.
_TUN--;
}
}
log_printf("Duration: %lu, TUN=%d", MeasureSOF(), _TUN);
// Undo side-effects.
T2CON = 0x0000;
// Detach, wait.
USBShutdown();
__delay_ms(2000);
}
int main(void)
#endif
{
InitializeSystem();
while(1) {
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE)) {
USBDeviceAttach();
}
#endif
#if defined(USB_POLLING)
USBDeviceTasks();
#endif
ProcessIO();
}
}
/******************************************************************************
* Function: void BlinkUSBStatus(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: BlinkUSBStatus turns on and off LEDs corresponding to
* the USB device state.
*
* Note: mLED macros can be found in HardwareProfile.h
* usb_device_state is declared in usbmmap.c and is modified
* in usb_device.c, usbctrltrf.c, and usb9.c
*****************************************************************************/
void BlinkUSBStatus(void)
{
#ifdef ENABLE_USB_LED_BLINK_STATUS
static unsigned int led_count = 0;
led_count--;
if(led_count == 0)
{
led_count = 0x4E00; //Value determines blink interval
if(USBGetDeviceState() < CONFIGURED_STATE)
{
mLED1 = 1; //Turn on the LED continuously
}
else
{
mLED1 = !mLED1; //Toggle the LED state
}
}
#endif //#ifdef ENABLE_USB_LED_BLINK_STATUS
}//end BlinkUSBStatus
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();
}
}
int main(void)
#endif
{
unsigned int i=0;
InitializeSystem();
for(i=0;i<SAMPLE_SIZE;i++)ADC_sample[i]=0;
while(1)
{
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE))
{
USBDeviceAttach();
}
#endif
// Application-specific tasks.
// Application related code may be added here, or in the ProcessIO() function.
//ReadADC();
ProcessIO();
}//end while
}//end main
/*********************************************************************
* Function: void SYSTEM_Tasks(void)
*
* Overview: Runs system level tasks that keep the system running
*
* PreCondition: System has been initalized with SYSTEM_Initialize()
*
* Input: None
*
* Output: None
*
********************************************************************/
void SYSTEM_Tasks(void)
{
switch(softStartStatus)
{
case SOFT_START_POWER_OFF:
break;
case SOFT_START_POWER_START:
if(USBGetDeviceState() != CONFIGURED_STATE)
{
break;
}
softStartStatus = SOFT_START_POWER_ENABLED;
break;
case SOFT_START_POWER_ENABLED:
break;
case SOFT_START_POWER_READY:
break;
}
}
int main(void)
#endif
{
InitializeSystem();
while(1)
{
#if defined(USB_INTERRUPT)
if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE))
{
USBDeviceAttach();
}
#endif
#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
// frequently (such as once about every 100 microseconds) at any
// time that a SETUP packet might reasonably be expected to
// be sent by the host to your device. In most cases, the
// USBDeviceTasks() function does not take very long to
// execute (~50 instruction cycles) before it returns.
#endif
// Application-specific tasks.
// Application related code may be added here, or in the ProcessIO() function.
ProcessIO();
}//end while
}//end main
int CDCIsAvailable() {
return USBGetDeviceState() != DETACHED_STATE;
}
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
/*********************************************************************
* 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;
}
}
}
}
}
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);
// }
}
}
bool is_usb_available(void) {
return !(USBGetDeviceState() < CONFIGURED_STATE || USBIsDeviceSuspended() == true);
}
/********************************************************************
* Function: UsbTasks()
*
* Precondition:
*
* Input: None.
*
* Output: None.
*
* Side Effects: None.
*
* Overview: This function transmits frames and received frames to and from USB.
*
*
* Note: None.
********************************************************************/
void UsbTasks(void)
{
UINT TxLen;
UINT8 *TxPtr;
volatile test;
#if defined(USB_POLLING)
//This function must be called everytime. This is a stack function.
USBDeviceTasks();
#endif
if(USBGetDeviceState() == CONFIGURED_STATE)
{
// Check if bootloader has something to send out to PC.
TxLen = FRAMEWORK_GetTransmitFrame(UsbTxData);
// Initialize the transmit pointer.
TxPtr = &UsbTxData[0];
while(TxLen)
{
while(UsbTxBusy()); // Wait for USB transmit completion.
// Send the packet (USB endpoint size is always 64 bytes)
USBTxOnePacket(HID_EP, TxPtr, MaxUsbPacketSize);
if(TxLen > MaxUsbPacketSize)
{
// Send pending bytes in next loop.
TxLen -= MaxUsbPacketSize;
// Point to next 64bytes.
TxPtr += MaxUsbPacketSize;
// Probably a wait is needed here, otherwise PC app may miss frames.
//Wait();
}
else
{
// No more bytes.
TxLen = 0;
}
}
// Following part of the code checks if there is any data from USB.
// If there are any data available, it just pushes the data to the frame work.
// Framework decodes the packet and takes necessary action like erasing/ programming etc.
if(UsbRxDataAvlbl())// Check if we have got any data from USB.
{
// Yes, we got a packet from HID End point.
// Pass the buffer to frame work. Framework decodes the packet and executes the Bootloder specific commands (Erasing/Programming etc).
FRAMEWORK_BuildRxFrame(UsbRxData, MaxUsbPacketSize);
// Re-arm the HID endpoint to receive next packet.(Remember! We have armed the HID endpoint for the first time in function USBCBInitEP())
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)UsbRxData,MaxUsbPacketSize);
}
}// if device configured.
}
USB_DEVICE_STATE ChipKITUSBGetDeviceState(void)
{
return(USBGetDeviceState());
}
// 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;
}
