Projects/USBtoSerial/USBtoSerial.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the USBtoSerial project. This file contains the main tasks of
  34  *  the project and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "USBtoSerial.h"
  38
  39 /** Circular buffer to hold data from the host before it is sent to the device via the serial port. */
  40 static RingBuffer_t USBtoUSART_Buffer;
  41
  42 /** Underlying data buffer for \ref USBtoUSART_Buffer, where the stored bytes are located. */
  43 static uint8_t      USBtoUSART_Buffer_Data[128];
  44
  45 /** Circular buffer to hold data from the serial port before it is sent to the host. */
  46 static RingBuffer_t USARTtoUSB_Buffer;
  47
  48 /** Underlying data buffer for \ref USARTtoUSB_Buffer, where the stored bytes are located. */
  49 static uint8_t      USARTtoUSB_Buffer_Data[128];
  50
  51 /** LUFA CDC Class driver interface configuration and state information. This structure is
  52  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  53  *  within a device can be differentiated from one another.
  54  */
  55 USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
  56         {
  57                 .Config =
  58                         {
  59                                 .ControlInterfaceNumber         = 0,
  60
  61                                 .DataINEndpointNumber           = CDC_TX_EPNUM,
  62                                 .DataINEndpointSize             = CDC_TXRX_EPSIZE,
  63                                 .DataINEndpointDoubleBank       = false,
  64
  65                                 .DataOUTEndpointNumber          = CDC_RX_EPNUM,
  66                                 .DataOUTEndpointSize            = CDC_TXRX_EPSIZE,
  67                                 .DataOUTEndpointDoubleBank      = false,
  68
  69                                 .NotificationEndpointNumber     = CDC_NOTIFICATION_EPNUM,
  70                                 .NotificationEndpointSize       = CDC_NOTIFICATION_EPSIZE,
  71                                 .NotificationEndpointDoubleBank = false,
  72                         },
  73         };
  74
  75
  76 /** Main program entry point. This routine contains the overall program flow, including initial
  77  *  setup of all components and the main program loop.
  78  */
  79 int main(void)
  80 {
  81         SetupHardware();
  82
  83         RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
  84         RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
  85
  86         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  87         sei();
  88
  89         for (;;)
  90         {
  91                 /* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
  92                 if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
  93                 {
  94                         int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
  95
  96                         /* Read bytes from the USB OUT endpoint into the USART transmit buffer */
  97                         if (!(ReceivedByte < 0))
  98                           RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
  99                 }
 100
 101                 /* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
 102                 uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
 103                 if ((TIFR0 & (1 << TOV0)) || (BufferCount > 200))
 104                 {
 105                         /* Clear flush timer expiry flag */
 106                         TIFR0 |= (1 << TOV0);
 107
 108                         /* Read bytes from the USART receive buffer into the USB IN endpoint */
 109                         while (BufferCount--)
 110                         {
 111                                 /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 112                                 if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
 113                                                         RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 114                                 {
 115                                         break;
 116                                 }
 117
 118                                 /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
 119                                 RingBuffer_Remove(&USARTtoUSB_Buffer);
 120                         }
 121                 }
 122
 123                 /* Load the next byte from the USART transmit buffer into the USART */
 124                 if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
 125                   Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
 126
 127                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 128                 USB_USBTask();
 129         }
 130 }
 131
 132 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 133 void SetupHardware(void)
 134 {
 135         /* Disable watchdog if enabled by bootloader/fuses */
 136         MCUSR &= ~(1 << WDRF);
 137         wdt_disable();
 138
 139         /* Disable clock division */
 140         clock_prescale_set(clock_div_1);
 141
 142         /* Hardware Initialization */
 143         LEDs_Init();
 144         USB_Init();
 145
 146         /* Start the flush timer so that overflows occur rapidly to push received bytes to the USB interface */
 147         TCCR0B = (1 << CS02);
 148 }
 149
 150 /** Event handler for the library USB Connection event. */
 151 void EVENT_USB_Device_Connect(void)
 152 {
 153         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 154 }
 155
 156 /** Event handler for the library USB Disconnection event. */
 157 void EVENT_USB_Device_Disconnect(void)
 158 {
 159         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 160 }
 161
 162 /** Event handler for the library USB Configuration Changed event. */
 163 void EVENT_USB_Device_ConfigurationChanged(void)
 164 {
 165         bool ConfigSuccess = true;
 166
 167         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 168
 169         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 170 }
 171
 172 /** Event handler for the library USB Control Request reception event. */
 173 void EVENT_USB_Device_ControlRequest(void)
 174 {
 175         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 176 }
 177
 178 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 179  *  for later transmission to the host.
 180  */
 181 ISR(USART1_RX_vect, ISR_BLOCK)
 182 {
 183         uint8_t ReceivedByte = UDR1;
 184
 185         if (USB_DeviceState == DEVICE_STATE_Configured)
 186           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 187 }
 188
 189 /** Event handler for the CDC Class driver Line Encoding Changed event.
 190  *
 191  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 192  */
 193 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 194 {
 195         uint8_t ConfigMask = 0;
 196
 197         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 198         {
 199                 case CDC_PARITY_Odd:
 200                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 201                         break;
 202                 case CDC_PARITY_Even:
 203                         ConfigMask = (1 << UPM11);
 204                         break;
 205         }
 206
 207         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 208           ConfigMask |= (1 << USBS1);
 209
 210         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 211         {
 212                 case 6:
 213                         ConfigMask |= (1 << UCSZ10);
 214                         break;
 215                 case 7:
 216                         ConfigMask |= (1 << UCSZ11);
 217                         break;
 218                 case 8:
 219                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 220                         break;
 221         }
 222
 223         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 224         UCSR1B = 0;
 225         UCSR1A = 0;
 226         UCSR1C = 0;
 227
 228         /* Set the new baud rate before configuring the USART */
 229         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 230
 231         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 232         UCSR1C = ConfigMask;
 233         UCSR1A = (1 << U2X1);
 234         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 235 }
 236