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();
}
}
