int main() { // SET single LED port DDRC |= _BV(LED_PIN); PORTC ^= _BV(LED_PIN); // 1s pull up of LED Strip pins */ apa102_DDRREG &= ~_BV(apa102_data); apa102_DDRREG &= ~_BV(apa102_clk); apa102_PORTREG |= _BV(apa102_data); apa102_PORTREG |= _BV(apa102_clk); _delay_ms(900); // Disable pull ups apa102_PORTREG &= ~_BV(apa102_data); apa102_PORTREG &= ~_BV(apa102_clk); apa102_DDRREG |= _BV(apa102_data); apa102_DDRREG |= _BV(apa102_clk); _delay_ms(100); PORTC ^= _BV(LED_PIN); // Clear LEDs in the strip clear_all_leds(); // Init ROS nh.initNode(); nh.subscribe(set_sub); nh.subscribe(set_led_sub); ack_led(); // Wait for Server side to start while (!nh.connected()) { nh.spinOnce(); // LUFA functions that need to be called frequently to keep USB alive CDC_Device_USBTask(&Atmega32u4Hardware::VirtualSerial_CDC_Interface); USB_USBTask(); _delay_ms(10); } ack_led(); // Publish some debug information snprintf(log_str, MAX_MSG_SIZE, "V:%s", GIT_VERSION); nh.loginfo(log_str); snprintf(log_str, MAX_MSG_SIZE, "FM:%d", get_free_ram()); nh.loginfo(log_str); while(1) { nh.spinOnce(); // LUFA functions that need to be called frequently to keep USB alive CDC_Device_USBTask(&Atmega32u4Hardware::VirtualSerial_CDC_Interface); USB_USBTask(); } return 0; }
int main(void) { SetupHardware(); /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); GlobalInterruptEnable(); while(1) { DebounceUpdate(); EncoderUpdate(); LedUpdate(); SendSerial(); /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); HID_Device_USBTask(&Mouse_HID_Interface); HID_Device_USBTask(&Keyboard_HID_Interface); USB_USBTask(); } }
int16_t VncServerGetData(uint8_t * buffer, uint16_t maxsize) { uint16_t size = 0; if(usbConnectionReset) { usbConnectionReset = false; return -1; } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); while(debugcounter > 64) { DDRF |= (1 << 0); PORTF |= (1 << 0); debugcounter -= 64; PORTF &= ~(1 << 0); } while ( size < maxsize ) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); if(ReceivedByte < 0) break; buffer[size++] = (uint8_t)ReceivedByte; debugcounter++; } return size; }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { stdout=&mystdout; stdin=&mystdin; SetupHardware(); //LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); //Eval Prototype Sharp Reset Pin //DDRB &= ~RESET_PIN; //Set Input //PORTB |= RESET_PIN; //Set High //DDRB |= RESET_PIN; //Set Output //Drude Sharp LCD Reset PIN PORTF |= RESETN_PIN; //Set High DDRF |= RESETN_PIN; //Set Output //Digitizer Interrupt //DDRB &= ~(_BV(7)); //PB7 input //PORTB &= ~(1<<PB7); //PB7 low PORTB |= (_BV(7)); //Set high (input pullup) //IP4787CZ32Y HDMI ESD interface chip (HDMI_ACT PIN) Active-High (Test-Point 12) PORTF |= (_BV(PF1)); //Set high (input pullup) //Toshiba Interrupt Pin PORTE |= (_BV(PE6)); //Set high (input pullup) //Toshiba Standby Pin PORTF |= (_BV(PF4)); //Set high (input pullup) //Toshiba Reset Pin - Active Low PORTC |= (_BV(PC7)); //Set high (input pullup) //LCD-CABC //PORTF |= (_BV(PF7)); //Set high (defaults to input pullup) //DDRF &= ~(_BV(PF7)); //Set output //PORTF |= (_BV(PF7)); //Set low //LED-PWM PORTD |= (_BV(PD6)); //Set high (defaults to input pullup) //PORTD &= ~(_BV(PD6)); //Set low //DDRD &= ~(_BV(PD6)); //Set output RingBuffer_InitBuffer(&FromHost_Buffer, FromHost_Buffer_Data, sizeof(FromHost_Buffer_Data)); init_screen(0x1F); //magic number! mxt_list_types(); for (;;) { HandleSerial(); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); HID_Device_USBTask(&Digitizer_HID_Interface); USB_USBTask(); HandleDigitizer(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); _setBrightness(50); for (;;) { /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); DS1302_clock_burst_read((uint8_t *) &rtc); _setDigit( rtc.Seconds % 10 ); _setBrightness( 50 ); _delay_ms(4); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data)); RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data)); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); for (;;) { /* Only try to read in bytes from the CDC interface if the transmit buffer is not full */ if (!(RingBuffer_IsFull(&USBtoUSART_Buffer))) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); /* Read bytes from the USB OUT endpoint into the USART transmit buffer */ if (!(ReceivedByte < 0)) RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte); } /* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */ uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer); if (BufferCount) { Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address); /* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */ if (Endpoint_IsINReady()) { /* Never send more than one bank size less one byte to the host at a time, so that we don't block * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */ uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1)); /* Read bytes from the USART receive buffer into the USB IN endpoint */ while (BytesToSend--) { /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */ if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface, RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError) { break; } /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */ RingBuffer_Remove(&USARTtoUSB_Buffer); } } } /* Load the next byte from the USART transmit buffer into the USART */ if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer)); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); /* Create a regular blocking character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateBlockingStream(&VirtualSerial_CDC_Interface, &USBSerialStream); sei(); for (;;) { /* Read in next LED colour command from the host */ uint8_t ColourUpdate = fgetc(&USBSerialStream); /* Top 3 bits select the LED, bottom 5 control the brightness */ uint8_t Channel = (ColourUpdate & 0b11100000); uint8_t Duty = (ColourUpdate & 0b00011111); if (Channel & (1 << 5)) SoftPWM_Channel1_Duty = Duty; if (Channel & (1 << 6)) SoftPWM_Channel2_Duty = Duty; if (Channel & (1 << 7)) SoftPWM_Channel3_Duty = Duty; CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); uint16_t bytesAvailable, currentByte; CDC_Device_CreateStream(&tpad_CDC_Interface, &USBSerialStream); sei(); for (;;) { // // Read pressures from 16 buttons // ButtonStates(); // // Handle incoming bytes // bytesAvailable = CDC_Device_BytesReceived(&tpad_CDC_Interface); while (bytesAvailable--) { currentByte = CDC_Device_ReceiveByte(&tpad_CDC_Interface); // TODO: implement led updates from host } CDC_Device_USBTask(&tpad_CDC_Interface); USB_USBTask(); } }
int main(void) { uint8_t i = 1; uint8_t count = 3; setup(); blink(3); _delay_ms(100); while (1) { // Print greeting at most count times. if (i <= count) { if (USB_DeviceState == DEVICE_STATE_Configured && ok_to_send) { blink(i); CDC_Device_SendString(&VirtualSerial_CDC_Interface, "Hello World! "); CDC_Device_SendByte(&VirtualSerial_CDC_Interface, '0' + i); CDC_Device_SendString(&VirtualSerial_CDC_Interface, "\r\n"); CDC_Device_Flush(&VirtualSerial_CDC_Interface); i++; } } if (USB_DeviceState == DEVICE_STATE_Configured) { /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); RingBuffer_InitBuffer(&USBtoUSART_Buffer); RingBuffer_InitBuffer(&USARTtoUSB_Buffer); sei(); for (;;) { /* Only try to read in bytes from the CDC interface if the transmit buffer is not full */ if (!(RingBuffer_IsFull(&USBtoUSART_Buffer))) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); /* Read bytes from the USB OUT endpoint into the USART transmit buffer */ if (!(ReceivedByte < 0)) RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte); } /* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */ RingBuff_Count_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer); if ((TIFR0 & (1 << TOV0)) || (BufferCount > BUFFER_NEARLY_FULL)) { TIFR0 |= (1 << TOV0); if (USARTtoUSB_Buffer.Count) { LEDs_TurnOnLEDs(LEDMASK_TX); PulseMSRemaining.TxLEDPulse = TX_RX_LED_PULSE_MS; } /* Read bytes from the USART receive buffer into the USB IN endpoint */ while (BufferCount--) CDC_Device_SendByte(&VirtualSerial_CDC_Interface, RingBuffer_Remove(&USARTtoUSB_Buffer)); /* Turn off TX LED(s) once the TX pulse period has elapsed */ if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse)) LEDs_TurnOffLEDs(LEDMASK_TX); /* Turn off RX LED(s) once the RX pulse period has elapsed */ if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse)) LEDs_TurnOffLEDs(LEDMASK_RX); } /* Load the next byte from the USART transmit buffer into the USART */ if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) { Serial_TxByte(RingBuffer_Remove(&USBtoUSART_Buffer)); LEDs_TurnOnLEDs(LEDMASK_RX); PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS; } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); GlobalInterruptEnable(); uint8_t sending = 0; for (;;) { while (1) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); if (ReceivedByte < 0) break; if (!configured) continue; if (!sending) { PORTC.OUTSET = PIN1_bm; sending = 1; } PORTD.OUTTGL = PIN5_bm; while(!USART_IsTXDataRegisterEmpty(&USART)); USART_PutChar(&USART, ReceivedByte & 0xff); } if (sending) { USART_ClearTXComplete(&USART); while(!USART_IsTXComplete(&USART)); PORTC.OUTCLR = PIN1_bm; sending = 0; } Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address); /* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */ if (configured && Endpoint_IsINReady()) { uint8_t maxbytes = CDC_TXRX_EPSIZE; while (USART_RXBufferData_Available(&USART_data) && maxbytes-->0) { uint8_t b = USART_RXBuffer_GetByte(&USART_data); CDC_Device_SendByte(&VirtualSerial_CDC_Interface, b); PORTD.OUTTGL = PIN5_bm; } } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); if (loop++) continue; if (!configured) continue; PORTD.OUTTGL = PIN5_bm; } }
int main(void) { SetupHardware(); RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data)); RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data)); LEDs_SetAllLEDs(0); sei(); for (;;) { if ((PINF & 0x01) == 0x01) LEDs_SetAllLEDs(2); else LEDs_SetAllLEDs(0); /* Only try to read in bytes from the CDC interface if the (outbound) transmit buffer is not full */ if (!(RingBuffer_IsFull(&USBtoUSART_Buffer))) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); /* Read bytes from the USB OUT endpoint into the USART transmit buffer */ if (!(ReceivedByte < 0)) RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte); } /* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */ uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer); if ((TIFR0 & (1 << TOV0)) || (BufferCount > (uint8_t)(sizeof(USARTtoUSB_Buffer_Data) * .75))) { /* Clear flush timer expiry flag */ TIFR0 |= (1 << TOV0); /* Read bytes from the USART receive buffer into the USB IN endpoint */ while (BufferCount--) { /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */ if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface, RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError) { break; } /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */ RingBuffer_Remove(&USARTtoUSB_Buffer); } } /* Load the next byte from the USART transmit buffer into the USART */ if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer)); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
// This ISR is responsible for running the USB code. It MUST run at least // every 30mS. I'm probably going to start running it twice that often. ISR(TIMER0_OVF_vect, ISR_NOBLOCK) { // Increment the ticks counter // which will overflow once every 536 seconds, or 8.94 minutes. ticks++; CDC_Device_USBTask(&CDC_interface); USB_USBTask(); }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); RingBuffer_InitBuffer(&FromHost_Buffer, FromHost_Buffer_Data, sizeof(FromHost_Buffer_Data)); GlobalInterruptEnable(); for (;;) { /* Only try to read in bytes from the CDC interface if the transmit buffer is not full */ if (!(RingBuffer_IsFull(&FromHost_Buffer))) { int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); /* Read bytes from the USB OUT endpoint into the USART transmit buffer */ if (!(ReceivedByte < 0)) RingBuffer_Insert(&FromHost_Buffer, ReceivedByte); } while (RingBuffer_GetCount(&FromHost_Buffer) > 0) { static uint8_t EscapePending = 0; int16_t HD44780Byte = RingBuffer_Remove(&FromHost_Buffer); if (HD44780Byte == COMMAND_ESCAPE) { if (EscapePending) { HD44780_WriteData(HD44780Byte); EscapePending = 0; } else { /* Next received character is the command byte */ EscapePending = 1; } } else { if (EscapePending) { HD44780_WriteCommand(HD44780Byte); EscapePending = 0; } else { HD44780_WriteData(HD44780Byte); } } } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
void usb_tasks(void) { MS_Device_USBTask(&Disk_MS_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); HID_Device_USBTask(&Keyboard_HID_Interface); USB_USBTask(); if(usb_keyboard_sending_string_GLOBAL) usb_keyboard_service_write(); }
void lufaLoop(void) { if(!jennic_in_programming_mode){ CDC_Device_USBTask(&VirtualSerial_CDC0_Interface); CDC_Arduino_In_Task(); } do{ if (jennic_reset_event) { if (!jennic_in_programming_mode) { jennic_in_programming_mode = true; Serial_Config(38400, 8, CDC_LINEENCODING_OneStopBit, CDC_PARITY_None); Jennic_Set_Mode(true); /* pull jennic into programming mode */ } else { jennic_in_programming_mode = false; Serial_Config(1000000, 8, CDC_LINEENCODING_OneStopBit, CDC_PARITY_None); Jennic_Set_Mode(false); /* pull jennic into normal mode */ } jennic_reset_event = false; } //if(jennic_in_programming_mode){ Jennic_In_Task(); CDC_In_Task(); CDC_Device_USBTask(&VirtualSerial_CDC1_Interface); USB_USBTask(); /* do house-keeping */ // UDRE Interrupt enable (USART) // cause if our USB->USART ringbuf is full we disable the interrupt. if ( ringbuf_elements(&USBtoUSART_Buffer) && !(UCSR1B & (1 << UDRIE1)) ) UCSR1B |= (1 << UDRIE1); }while(jennic_in_programming_mode); }
static int CDC_Device_getchar_Blocking(FILE* Stream) { while (!(CDC_Device_BytesReceived((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream)))) { if (USB_DeviceState == DEVICE_STATE_Unattached) return _FDEV_EOF; CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream)); USB_USBTask(); } return CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream)); }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); sei(); DDRB |= (1 << 4); PORTB |= (1 << 4); for (;;) { int16_t c = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); if (c > 0){ switch (c) { case '1': // this will eventually be to strobe the modem on pin of a telit module // set port to output mode and low state // stall for 1000 ms // set port back to high impedance CDC_Device_SendString(&VirtualSerial_CDC_Interface, "received 1\r\n"); DDRD |= (1 << 0); PORTD &= ~(1 << 0); _delay_ms(1000); DDRD &= ~(1 << 0); PORTD |= (1 << 0); break; case 'r': // this will be to strobe the reset pin of a telit module CDC_Device_SendString(&VirtualSerial_CDC_Interface, "received r\r\n"); PORTB &= ~(1 << 4); _delay_ms(200); PORTB |= (1 << 4); break; case '?': // this wil be to inquire abouth the powermon pin of a telit module CDC_Device_SendString(&VirtualSerial_CDC_Interface, "received ?\r\n"); PORTB |= ~(1 << 4); break; default: CDC_Device_SendString(&VirtualSerial_CDC_Interface, "unrecognized input\r\n"); } } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); for (;;) { CheckJoystickMovement(); /* Discard all received data on the first CDC interface */ while (CDC_Device_BytesReceived(&VirtualSerial1_CDC_Interface)) CDC_Device_ReceiveByte(&VirtualSerial1_CDC_Interface); /* Echo all received data on the second CDC interface */ while (CDC_Device_BytesReceived(&VirtualSerial2_CDC_Interface)) CDC_Device_SendByte(&VirtualSerial2_CDC_Interface, CDC_Device_ReceiveByte(&VirtualSerial2_CDC_Interface)); CDC_Device_USBTask(&VirtualSerial1_CDC_Interface); CDC_Device_USBTask(&VirtualSerial2_CDC_Interface); USB_USBTask(); } }
int main() { // Initialize ADC Interrupts lastTimeInterruptLeft = avr_time_now(); lastTimeInterruptRight = avr_time_now(); out_msg.deltaUmLeft = 0; out_msg.deltaUmRight = 0; // Initialize ROS nh.initNode(); nh.advertise(io_board_out); ros::Subscriber<io_to_board> sub("to_ioboard", &ioboard_cb); nh.subscribe(sub); // Do timed/repeated stuff uint32_t lastTimeOdometry = 0UL; uint32_t lastTimeRake = 0UL; while(1) { // Stop engines and raise rake, if last recieved message is older then 2s // %TODO raise rake if ((lastTimeMessage != 0) && (avr_time_now() - lastTimeMessage > 1000)) { lastTimeMessage = 0; OCR1A = 0x8000; OCR1B = 0x8000; } // Publish odometry all 40ms if (avr_time_now() - lastTimeOdometry > 40) { out_msg.timestamp = avr_time_now(); io_board_out.publish(&out_msg); out_msg.deltaUmLeft = 0; out_msg.deltaUmRight = 0; lastTimeOdometry = avr_time_now(); } nh.spinOnce(); // LUFA functions that need to be called frequently to keep USB alive CDC_Device_USBTask(&Atmega32u4Hardware::VirtualSerial_CDC_Interface); USB_USBTask(); } return 0; }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); for (;;) { CheckJoystickMovement(); /* Discard all received data on the first CDC interface */ CDC_Device_ReceiveByte(&VirtualSerial1_CDC_Interface); /* Echo all received data on the second CDC interface */ int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial2_CDC_Interface); if (!(ReceivedByte < 0)) CDC_Device_SendByte(&VirtualSerial2_CDC_Interface, (uint8_t)ReceivedByte); CDC_Device_USBTask(&VirtualSerial1_CDC_Interface); CDC_Device_USBTask(&VirtualSerial2_CDC_Interface); USB_USBTask(); } }
static int CDC_Device_getchar_Blocking(FILE* Stream) { int16_t ReceivedByte; while ((ReceivedByte = CDC_Device_ReceiveByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream))) < 0) { if (USB_DeviceState[corenum] == DEVICE_STATE_Unattached) return _FDEV_EOF; CDC_Device_USBTask((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream)); USB_USBTask(); } return ReceivedByte; }
void sendCDCbyte(uint8_t b){ //TODO improve this // try to send until sucess while (CDC_Device_SendByte(&VirtualSerial_CDC_Interface, b) != ENDPOINT_READYWAIT_NoError){ CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); while (1){ // TODO remove this freezing loop! LEDs_TurnOnLEDs(LEDS_ERR); _delay_ms(100); LEDs_TurnOnLEDs(LEDS_ERR); _delay_ms(100); } } }
int main(void) { SetupHardware(); // If digital pin 6 (PD7) is low, fill channel data with a distinctive // pattern. DDRD &= 0b01111111; bool fill_with_pattern = bit_is_clear(PIND, 7); if (fill_with_pattern) { memset(_chandata, 0b01010101, 2048); } LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); while (true) { CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); if (connected) { uint8_t* position = _chandata; int16_t universe = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); if (universe == -1) { // just a normal timeout, continue continue; } position += universe; while (position < _chandata + 2048) { int16_t channel_level = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); if (channel_level != -1) { *position = (uint8_t)channel_level; position += 4; } else { if (!connected) { // connection lost, forget our position and wait for a connection break; } // just a normal timeout, continue continue; } } } } }
/* Main thread */ void usb_thread (void) { for (;;) { bcond_wait(&usb_active); t_yield(); int16_t c; while ((c = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface)) > 0) stream_put(&cdc_instr, c); t_yield(); while ( ! stream_empty(&cdc_outstr)) CDC_Device_SendByte(&VirtualSerial_CDC_Interface, stream_get(&cdc_outstr)); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
int main(void) { SetupHardware(); RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data)); RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data)); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); while(1) { if(RTR==1) { if (ReceivedByte==0xFF) { for (uint8_t i = 0; i < 4; i++) { if (ReceivedByte==0) { ReceivedByte=1; } buff[i] = ReceivedByte; RTR = 0; while(RTR!=1){} } uint8_t range = ((buff[1]*256+buff[2])/100); RingBuffer_Insert(&USARTtoUSB_Buffer,buff[1]); RingBuffer_Insert(&USARTtoUSB_Buffer,buff[2]); //RingBuffer_Insert(&USARTtoUSB_Buffer,range); sendUSARTtoUSB(); _delay_ms(500); } } // if (!RingBuffer_IsFull(&USBtoUSART_Buffer)) // { // int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); // if (!(ReceivedByte < 0)) // { // sendUSBtoUSART(); // } CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); // } } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); setupIO(); interruptInit(); /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); sei(); while (1) { /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); for (;;) { CheckJoystickMovement(); /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); HID_Device_USBTask(&Mouse_HID_Interface); USB_USBTask(); } }
// Main program entry point. int main(void){ // Disable watchdog if enabled by bootloader/fuses MCUSR &= ~(1 << WDRF); wdt_disable(); // Disable clock division clock_prescale_set(clock_div_1); // Set the LED pins on Port D as output, and default the LED pins to HIGH (off) DDRD = 0b00110011; PORTD = 0b00110011; // Set Entropy pin to input DDRC = DDRC & 0b11111011; // Hardware Initialization USB_Init(); // Create a regular character stream for the interface so that it can be used with the stdio.h functions CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); // Enable interrupts GlobalInterruptEnable(); for (;;){ // Blink the third LED as we gather entropy PORTD = PORTD & 0b11101111; // Read a bit, and dump it out the USB Serial stream. fputc(((PINC & 0b00000100) >> 2) + '0', &USBSerialStream); // Un-blink the third LED PORTD = PORTD | 0b00010000; // Must throw away unused bytes from the host, or it will lock up while waiting for the device CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); // Run the LUFA stuff CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }
/** Main program entry point. This routine contains the overall program flow, including initial * setup of all components and the main program loop. */ int main(void) { SetupHardware(); /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */ CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream); LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY); GlobalInterruptEnable(); for (;;) { CheckJoystickMovement(); /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */ CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface); CDC_Device_USBTask(&VirtualSerial_CDC_Interface); USB_USBTask(); } }