int main(void) { uchar i = 1; uchar hidCurrentMode = 255; char remainingData=0; uchar offset=0; HardwareInit(); usbInit(); // Set up descriptor hidMode = HIDM_1P; ReadController(1); SetHIDMode(); for(;;){ /* main event loop */ usbPoll(); if(usbInterruptIsReady()){ /* called after every poll of the interrupt endpoint */ ReadController(i); RemapButtons(&(reportBuffer.b1), &(reportBuffer.b2)); RemapButtons(&(reportBufferWheel.b1), &(reportBufferWheel.b2)); remainingData=reportBufferLength; offset=0; // handle report with more than 8 byte length (for NegCon and future expansion) do { if (remainingData<=8) { usbSetInterrupt(reportBufferAddress+offset, remainingData); remainingData=0; } else { usbSetInterrupt(reportBufferAddress+offset, 8); offset+=8; remainingData-=8; do { usbPoll(); } while (!usbInterruptIsReady()); } } while (remainingData>0); i++; if (i > hidNumReports) i = 1; if (hidCurrentMode != hidMode) { SetHIDMode(); hidCurrentMode = hidMode; } } } return 0; }
void USB_DEVICE::run_usb(){ //! Sets up the rf network _init_rf_network(); _setup_usb_report_params(); /** * Once the state machine gets here, it polls for data from the router * and parses it into the structures. */ for(;;){ //! Poll the USB Line usbPoll(); //! Check to see if a report needs to be sent, using //! the idle rate. if ((TCNT1 > ((4 * (F_CPU / 1024000)) * idle_rate) || TCNT1 > 0x7FFF) && idle_rate != 0) { //! Needs to send _sending_mutex = true; }else{ //! Create a valid random USB Frame _create_usb_report_frame(); } //! Poll the USB Line usbPoll(); //! If we need to send. if(_sending_mutex){ //! Send the report. //! and reset the timer. _send_usb_report_frame(); TCNT1 = 0; } //! Poll the USB line usbPoll(); //! No need to send anymore. _sending_mutex = false; } }
int main( void ) { //=========================================== uchar calibrationValue; calibrationValue = eeprom_read_byte(0); /* calibration value from last time */ if(calibrationValue != 0xff){ OSCCAL = calibrationValue; } //=========================================== usbInit(); wdt_enable(WDTO_1S); /* Даже если Вы не используете сторожевой таймер (watchdog), выключите его здесь. На более новых * микроконтроллерах состояние watchdog (вкл\выкл, период) СОХРАНЯЕТСЯ ЧЕРЕЗ СБРОС! */ //=========================================== usbDeviceDisconnect(); _delay_ms(300); /* 300 ms disconnect */ usbDeviceConnect(); //=========================================== //LED_PORT_DDR |= _BV(LED_BIT); /* делаем ножку, куда подключен LED, выходом */ sbi(LED_PORT_DDR,LED_BIT); /* делаем ножку, куда подключен LED, выходом */ //=========================================== sei(); /* Разрешаем прерывания*/ for(;;){ /* main event loop */ wdt_reset(); usbPoll(); } //=========================================== }
/************************************************************************************** Function Name : main Description : Initialize the USB and start the interrupt Parameters : void Return : int **************************************************************************************/ int main(void) { uchar l_delayCount; wdt_enable(WDTO_1S); odDebugInit(); DBG1(0x00, 0, 0); /* debug output: main starts */ usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ l_delayCount = 0; while(--l_delayCount) { /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); sei(); DBG1(0x01, 0, 0); for(;;) { DBG1(0x02, 0, 0); /*debug output: main loop iterates*/ wdt_reset(); usbPoll(); } return 0; }
int main() { uchar i; DDRB = 1; // LED is on PB0 // set up a 1 second watchdog timer that resets the microcontroller // if 1000 milliseconds pass without a call to wdt_reset() wdt_enable(WDTO_1S); // init v-usb usbInit(); usbDeviceDisconnect(); // enforce re-enumeration for(i = 0; i < 250; i++) { // wait 500 ms wdt_reset(); // keep the watchdog happy _delay_ms(2); } usbDeviceConnect(); sei(); // Enable interrupts after re-enumeration while(1) { wdt_reset(); // keep the watchdog happy usbPoll(); } return 0; }
//Main routine int main(void) { int d; uint16_t v; // cli(); initio(); inittxt(); usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ uint8_t i = 0; while(--i){ /* fake USB disconnect for > 250 ms */ _delay_ms(1); } usbDeviceConnect(); sei(); //Go display stuff while(1) { for (d=0; d<11; d++) { v=getcharat(d); setvfd(d,v); _delay_ms(1); handlepwm(); usbPoll(); } } }
int main(void) { uchar i; wdt_enable(WDTO_1S); /* Если не используется watchdog, отключите эту строчку. Для новых устройств статус watchdog (on/off, period) СОХРАНЯЕТСЯ ПОСЛЕ СБРОСА! */ /* Статус RESET: все ножки портов в режиме ввода без нагрузочных резисторов (pull-up). Это то, что нужно для D+ and D-, таким образом, мы не нуждаемся в дополнительной аппаратной инициализации. */ usbInit(); // см. usbdrv.h и usbdrv.c usbDeviceDisconnect(); /* см. usbdrv.h - запускает реэнумерацию, делаем это, пока отключены прерывания! */ i = 0; while(--i) { /* подделывам USB disconnect на время > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); // см. usbdrv.h LED_PORT_DDR |= _BV(LED_BIT); /* переключаем ножку LED в режим вывода */ sei(); for(;;){ /* главный цикл события */ wdt_reset(); usbPoll(); } return 0; }
const char *requestPin(PinMatrixRequestType type, const char *text) { PinMatrixRequest resp; memset(&resp, 0, sizeof(PinMatrixRequest)); resp.has_type = true; resp.type = type; usbTiny(1); msg_write(MessageType_MessageType_PinMatrixRequest, &resp); pinmatrix_start(text); for (;;) { usbPoll(); if (msg_tiny_id == MessageType_MessageType_PinMatrixAck) { msg_tiny_id = 0xFFFF; PinMatrixAck *pma = (PinMatrixAck *)msg_tiny; pinmatrix_done(pma->pin); // convert via pinmatrix usbTiny(0); return pma->pin; } if (msg_tiny_id == MessageType_MessageType_Cancel || msg_tiny_id == MessageType_MessageType_Initialize) { pinmatrix_done(0); if (msg_tiny_id == MessageType_MessageType_Initialize) { protectAbortedByInitialize = true; } msg_tiny_id = 0xFFFF; usbTiny(0); return 0; } #if DEBUG_LINK if (msg_tiny_id == MessageType_MessageType_DebugLinkGetState) { msg_tiny_id = 0xFFFF; fsm_msgDebugLinkGetState((DebugLinkGetState *)msg_tiny); } #endif } }
int main(void) { led_init(); sht1x_init(); //sser_init(); wdt_enable(WDTO_1S); /* Even if you don't use the watchdog, turn it off here. On newer devices, * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! */ /* RESET status: all port bits are inputs without pull-up. * That's the way we need D+ and D-. Therefore we don't need any * additional hardware initialization. */ odDebugInit(); DBG1(0x00, 0, 0); /* debug output: main starts */ usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ unsigned char i = 0; while(--i){ /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); sei(); DBG1(0x01, 0, 0); /* debug output: main loop starts */ for(;;){ wdt_reset(); usbPoll(); } return 0; /* never reached */ }
int __attribute__((noreturn)) main(void) { bootLoaderInit(); initStatusLed(); if (bootLoaderCondition()) { if (eeprom_read_stay_in_bootloader() != 0) eeprom_clear_stay_in_bootloader(); statusLedOn(); uchar i = 0, j = 0; GICR = (1 << IVCE); /* enable change of interrupt vectors */ GICR = (1 << IVSEL); /* move interrupts to boot flash section */ initForUsbConnectivity(); for (;;) { /* main event loop */ wdt_reset(); usbPoll(); #if BOOTLOADER_CAN_EXIT if (exitMainloop) { if (--i == 0) { if (--j == 0) break; } } #endif } } leaveBootloader(); }
int main() { initLCD(); LCD_goto(1,0); lcd_puts("AVRLCD 4bit mode"); uchar i; DDRB = 1; // PB0 as output wdt_enable(WDTO_1S); // enable 1s watchdog timer usbInit(); usbDeviceDisconnect(); // enforce re-enumeration for(i = 0; i<250; i++) { // wait 500 ms wdt_reset(); // keep the watchdog happy _delay_ms(2); } usbDeviceConnect(); sei(); // Enable interrupts after re-enumeration while(1) { wdt_reset(); // keep the watchdog happy usbPoll(); } return 0; }
int main( void ) { usbInit(); sei(); init_joy(); for ( ;; ) { usbPoll(); // Don't bother reading joy if previous changes haven't gone out yet. // Forces delay after changes which serves to debounce controller as well. if ( usbInterruptIsReady() ) { read_joy(); // Don't send update unless joystick changed if ( memcmp( report_out, report, sizeof report ) ) { memcpy( report_out, report, sizeof report ); usbSetInterrupt( report_out, sizeof report_out ); toggle_led(); } } } return 0; }
void __attribute__((noreturn)) main( void ) { cli(); initLeds(); wdt_enable( WDTO_1S ); // USB initialization. usbInit(); usbDeviceDisconnect(); // enforce re-enumeration, do this while interrupts are disabled! unsigned char b = 150; while ( b-- ) { _delay_ms( 1 ); wdt_reset(); } cpuIoInit(); usbDeviceConnect(); sei(); for ( ;; ) { // main event loop usbPoll(); wdt_reset(); cpuIoPoll(); //_delay_ms( 10 ); } }
bool vusb_poll(void) { usbPoll(); bool ret_val = false; // take care of the idle rate if (vusb_idle_rate && (TIFR0 & _BV(TOV0))) // timer overflow? { TIFR0 = _BV(TOV0); if (vusb_idle_rate != 0) { if (vusb_idle_counter > 4) { vusb_idle_counter -= 5; // 22 ms in units of 4 ms } else { vusb_idle_counter = vusb_idle_rate; ret_val = true; } } } return ret_val; }
void sendPS3Data(dataForController data) { /* The data being transferred is in the following format: byte0 - 8 buttons ( bit0...bit7 = [blue][green][red][yellow][orange][star power][is higher frets][unused] byte1 - 5 buttons, 3bits padding bit0...bit7 = [select][start][??][??],[ps3 button],[pad][pad][pad] byte2 - hat switch 0000 N, 0001 N/E, 0010 E, 0011 SE, 0100 S, 0101 SW, 0110 W, 0111, NW, 1000, nothing pressed byte3 - x axis (unused) byte4 - y axis (unused) byte5 - z axis (Whammy Bar) byte6 - rzaxis (Choose solo style) */ //set the buttons to all at default positions reportBuffer[0] = 0b00000000; reportBuffer[1] = 0b00000000; reportBuffer[2] = 0b00001000; reportBuffer[3] = 0b10000000; reportBuffer[4] = 0b10000000; reportBuffer[5] = 0b10000000; reportBuffer[6] = 0b00000000; // Since 'colorOn' is 1 when a fret is pressed, we shift it to the proper place and | it to set the // corresponding button bit to one, which corresponds to a button press. reportBuffer[0] |= (data.orangeOn << ORANGE_BIT); reportBuffer[0] |= (data.blueOn << BLUE_BIT); reportBuffer[0] |= (data.yellowOn << YELLOW_BIT); reportBuffer[0] |= (data.redOn << RED_BIT); reportBuffer[0] |= (data.greenOn << GREEN_BIT); // On the PS3, the strumming shows up as a hat switch, so we have to use conditionals for this.. if (data.upOn) reportBuffer[2] = 0b00000000; if (data.downOn) reportBuffer[2] = 0b00000100; // Now set the whammy bar data reportBuffer[5] = data.numberOfStringsPressed; //Finally, Start, Star Power, and the Home button (not working yet) reportBuffer[1] |= (data.plusOn << PLUS_BIT); reportBuffer[0] |= (data.minusOn << MINUS_BIT); reportBuffer[1] |= (data.homeOn << HOME_BIT); //Then we finish off some USB stuff. wdt_reset(); //Reset the watchdog timer usbPoll(); //USB poll - must be called at least once per 10ms // Now, regardless of mode, we have to send the data to the // USB controlling library from the buffer we've been building if(usbInterruptIsReady()) { /* called after every poll of the interrupt endpoint */ usbSetInterrupt((void *)&reportBuffer, sizeof(reportBuffer)); } }
int main(void) { uchar i; wdt_enable(WDTO_1S); wdt_disable(); usbInit(); usbDeviceDisconnect(); i = 0; while(--i){ wdt_reset(); _delay_ms(1); } _delay_ms(250); usbDeviceConnect(); sei(); for(;;){ //wdt_reset(); usbPoll(); } return 0; }
static void wait_usb_interrupt( void ) { #if AUTO_OSCCAL // don't wait for interrupt until calibrated if ( osc_not_calibrated ) goto handled; #endif // Clear any stale pending interrupt, then wait for interrupt flag USB_INTR_PENDING = 1<<USB_INTR_PENDING_BIT; while ( !(USB_INTR_PENDING & (1<<USB_INTR_PENDING_BIT)) ) wdt_reset(); for ( ;; ) { // Vector interrupt manually USB_INTR_PENDING = 1<<USB_INTR_PENDING_BIT; USB_INTR_VECTOR(); // Wait a little while longer in case another one comes uchar n = 250; // about 90us timeout do { if ( !--n ) goto handled; } while ( !(USB_INTR_PENDING & (1<<USB_INTR_PENDING_BIT)) ); } handled: usbPoll(); }
int main() { fabscan_setup(); uchar i; // wdt_enable(WDTO_1S); // enable 1s watchdog timer usbInit(); usbDeviceDisconnect(); // enforce re-enumeration for(i = 0; i<250; i++) { // wait 500 ms // wdt_reset(); // keep the watchdog happy _delay_ms(2); } usbDeviceConnect(); sei(); // Enable interrupts after re-enumeration while(1) { // wdt_reset(); // keep the watchdog happy usbPoll(); if(fab_work_flag) // if there is new data for fabscan → let it work { fab_work_flag=0; fabscan_work(1,incomingByte); } } return 0; }
int __attribute__((noreturn)) main(void) { uchar i; wdt_enable(WDTO_1S); /* Even if you don't use the watchdog, turn it off here. On newer devices, * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! */ /* RESET status: all port bits are inputs without pull-up. * That's the way we need D+ and D-. Therefore we don't need any * additional hardware initialization. */ odDebugInit(); usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ i = 0; while(--i){ /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); sei(); DDRB |= _BV(PB0); for(;;){ /* main event loop */ wdt_reset(); usbPoll(); if (eeprom_read_byte(10) == 1) { PORTB |= _BV(PB0); } else { PORTB &= ~_BV(PB0); } } }
int main(void) { wdt_enable(WDTO_1S); initPodControls(); /* Even if you don't use the watchdog, turn it off here. On newer devices, * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! */ /* RESET status: all port bits are inputs without pull-up. * That's the way we need D+ and D-. Therefore we don't need any * additional hardware initialization. */ usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ uchar i = 0; while(--i){ /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); sei(); for(;;){ /* main event loop */ wdt_reset(); usbPoll(); if(usbInterruptIsReady()){ /* called after every poll of the interrupt endpoint */ usbSetInterrupt((void *)&reportBuffer, sizeof(reportBuffer)); } else { updateSensorData(); updateLEDState(); } } }
int main(void) { wdt_enable(WDTO_1S); // watchdog status is preserved on reset hardwareInit(); usbInit(); usbDeviceDisconnect(); // fake USB disconnect for > 250 ms for( uint8_t i=255; i>0; i-- ) { wdt_reset(); _delay_ms(1); } usbDeviceConnect(); sei(); for(;;) { // main event loop wdt_reset(); usbPoll(); } return 0; }
int main(void) { extern uchar usbNewDeviceAddr; uint8_t i; //Reconnect USB usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ i = 0; while(--i) _delay_ms(2); usbDeviceConnect(); usbInit(); sei(); leds[LED_RED].frequency = LED_ON; LED_init(); for (i=0; i<3; i++) TIMER_delay(250); leds[LED_RED].frequency = LED_OFF; leds[LED_GREEN].frequency = 1; while(1) { if (TIMER_timeout == 0) { if(usbNewDeviceAddr) leds[LED_BLUE].frequency = LED_ON; PORTD ^= (1<<PD7); TIMER_start(1); usbPoll(); LED_poll(); } } }
int main(void) { wdt_enable(WDTO_1S); odDebugInit(); hardwareInit(); usbInit(); intr3Status = 0; sendEmptyFrame = 0; sei(); for(;;){ /* main event loop */ wdt_reset(); usbPoll(); uartPoll(); #if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* We need to report rx and tx carrier after open attempt */ if(intr3Status != 0 && usbInterruptIsReady3()){ static uchar serialStateNotification[10] = {0xa1, 0x20, 0, 0, 0, 0, 2, 0, 3, 0}; if(intr3Status == 2){ usbSetInterrupt3(serialStateNotification, 8); }else{ usbSetInterrupt3(serialStateNotification+8, 2); } intr3Status--; } #endif } return 0; }
int __attribute__((noreturn)) main(void) { /* initialize hardware */ bootLoaderInit(); odDebugInit(); DBG1(0x00, 0, 0); /* jump to application if jumper is set */ if(bootLoaderCondition()) { uchar i = 0, j = 0; #ifndef TEST_MODE GICR = (1 << IVCE); /* enable change of interrupt vectors */ GICR = (1 << IVSEL); /* move interrupts to boot flash section */ #endif initForUsbConnectivity(); do { /* main event loop */ wdt_reset(); usbPoll(); #if BOOTLOADER_CAN_EXIT if(exitMainloop) { #if F_CPU == 12800000 break; /* memory is tight at 12.8 MHz, save exit delay below */ #endif if(--i == 0) { if(--j == 0) break; } } #endif } while(bootLoaderCondition()); } leaveBootloader(); }
int main(void) { uchar i; wdt_enable(WDTO_1S); /* Even if you don't use the watchdog, turn it off here. On newer devices, * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! */ DBG1(0x00, 0, 0); /* debug output: main starts */ /* RESET status: all port bits are inputs without pull-up. * That's the way we need D+ and D-. Therefore we don't need any * additional hardware initialization. */ odDebugInit(); usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ i = 0; while(--i){ /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); LED_PORT_DDR |= _BV(LED_BIT); /* make the LED bit an output */ sei(); DBG1(0x01, 0, 0); /* debug output: main loop starts */ for(;;){ /* main event loop */ DBG1(0x02, 0, 0); /* debug output: main loop iterates */ wdt_reset(); usbPoll(); } return 0; }
// main int main(void) { wdt_enable(WDTO_1S); hardwareInit(); usbInit(); sei(); unsigned int adcValue,replymask,replyshift,replybyte; while(1) { uchar i = 0; wdt_reset(); usbPoll(); PORTD ^= (1 << 6); //jump to bootloader if jumper is HIGH if(bit_is_clear(PIND, 5)) { startBootloader(); } for(i = 0; i < ADC_CHANNELS; i++) { //adcValue = adc_read(ADC_PRESCALER_32, ADC_VREF_AVCC, i); adcValue = i; usb_reply[i] = adcValue >> 2; replybyte = 16 + (i / 4); replyshift = ((i % 4) * 2); replymask = (3 << replyshift); usb_reply[replybyte] = (usb_reply[replybyte] & ~replymask) | (replymask & (adcValue << replyshift)); _delay_us(ADCDELAY); } usb_reply[20] = PINC; } return 0; }
int main(void) { wdt_reset(); wdt_enable(WDTO_120MS); usbInit(); usbDeviceDisconnect(); uint8_t t; for (t=255; t; t--) { _delay_ms(1); wdt_reset(); } usbDeviceConnect(); sei(); gpib_init(); for (;;) { usbPoll(); wdt_reset(); } }
int main(void) { uchar i, j; /* no pullups on USB and ISP pins */ //PORTD = 0; //PORTB = 0; /* all outputs except PD2 = INT0 */ /// LB - different pins on STK500 board //DDRD = ~(1 << 2); // make JTAG pins inputs with pullups SET_JTAG_PULLUPS(); /* output SE0 for USB reset */ /// LB - different pins on STK500 board //DDRB = ~0; j = 0; /* USB Reset by device only required on Watchdog Reset */ while (--j) { i = 0; /* delay >10ms for USB reset */ while (--i) ; } /* all USB and ISP pins inputs */ //DDRB = 0; /// LB - LED pins are different from usbasp to sp duo - conflict: SP duo uses these for JTAG /* all inputs except PC0, PC1 */ //DDRC = 0x03; //PORTC = 0xfe; SET_LED_OUTPUT(); LED_OFF(); /* init timer */ clockInit(); #ifdef UART_DEBUG // init debug uart setupUART(); TransmitString("\r\n\n***\r\nstarting up\r\n"); #endif // USB Re-Enumeration usbDeviceDisconnect(); while(--i){ // fake USB disconnect for > 250 ms wdt_reset(); // if watchdog is active, reset it _delay_ms(1); // library call -- has limited range } usbDeviceConnect(); /* main event loop */ usbInit(); sei(); for (;;) { usbPoll(); } return 0; }
int main() { uchar i; DDRB |= 1; // PB0 as output DDRB |= (1<<1); // PB1 as output wdt_enable(WDTO_1S); // enable 1s watchdog timer usbInit(); usbDeviceDisconnect(); // enforce re-enumeration for(i = 0; i<250; i++) // wait 500 ms { wdt_reset(); // keep the watchdog happy _delay_ms(2); } usbDeviceConnect(); sei(); // Enable interrupts after re-enumeration PORTB |= (1<<1); // PB1 on while(1) { wdt_reset(); // keep the watchdog happy usbPoll(); } return 0; }
void AVRISP_poll(void) { extern uchar usbNewDeviceAddr; usbPoll(); if ((STK500_rxLen)) { STK500_processmessage(); STK500_rxLen = 0; } if(usbNewDeviceAddr) leds[LED_BLUE].frequency = LED_ON; if ((STK500_txLen) && (usbInterruptIsReady())) { RSP_Pkg_Len = STK500_txLen - STK500_txLen_tmp; if(RSP_Pkg_Len > USB_EP_SIZE) RSP_Pkg_Len = USB_EP_SIZE; usbSetInterrupt((uchar*)STK500_Buffer + STK500_txLen_tmp,RSP_Pkg_Len); STK500_txLen_tmp += RSP_Pkg_Len; if(RSP_Pkg_Len < USB_EP_SIZE) { STK500_txLen = 0; STK500_txLen_tmp = 0; } } }