Projects/USBtoSerial/USBtoSerial.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2013.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2013  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 disclaims 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                                 .DataINEndpoint                 =
  61                                         {
  62                                                 .Address                = CDC_TX_EPADDR,
  63                                                 .Size                   = CDC_TXRX_EPSIZE,
  64                                                 .Banks                  = 1,
  65                                         },
  66                                 .DataOUTEndpoint                =
  67                                         {
  68                                                 .Address                = CDC_RX_EPADDR,
  69                                                 .Size                   = CDC_TXRX_EPSIZE,
  70                                                 .Banks                  = 1,
  71                                         },
  72                                 .NotificationEndpoint           =
  73                                         {
  74                                                 .Address                = CDC_NOTIFICATION_EPADDR,
  75                                                 .Size                   = CDC_NOTIFICATION_EPSIZE,
  76                                                 .Banks                  = 1,
  77                                         },
  78                         },
  79         };
  80
  81
  82 /** Main program entry point. This routine contains the overall program flow, including initial
  83  *  setup of all components and the main program loop.
  84  */
  85 int main(void)
  86 {
  87         SetupHardware();
  88
  89         RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
  90         RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
  91
  92         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  93         GlobalInterruptEnable();
  94
  95         for (;;)
  96         {
  97                 /* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
  98                 if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
  99                 {
 100                         int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
 101
 102                         /* Read bytes from the USB OUT endpoint into the USART transmit buffer */
 103                         if (!(ReceivedByte < 0))
 104                           RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
 105                 }
 106
 107                 /* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
 108                 uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
 109                 if (BufferCount)
 110                 {
 111                         Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
 112
 113                         /* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data
 114                          * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */
 115                         if (Endpoint_IsINReady())
 116                         {
 117                                 /* Never send more than one bank size less one byte to the host at a time, so that we don't block
 118                                  * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
 119                                 uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
 120
 121                                 /* Read bytes from the USART receive buffer into the USB IN endpoint */
 122                                 while (BytesToSend--)
 123                                 {
 124                                         /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 125                                         if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
 126                                                                                         RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 127                                         {
 128                                                 break;
 129                                         }
 130
 131                                         /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
 132                                         RingBuffer_Remove(&USARTtoUSB_Buffer);
 133                                 }
 134                         }
 135                 }
 136
 137                 /* Load the next byte from the USART transmit buffer into the USART */
 138                 if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
 139                   Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
 140
 141                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 142                 USB_USBTask();
 143         }
 144 }
 145
 146 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 147 void SetupHardware(void)
 148 {
 149         /* Disable watchdog if enabled by bootloader/fuses */
 150         MCUSR &= ~(1 << WDRF);
 151         wdt_disable();
 152
 153         /* Disable clock division */
 154         clock_prescale_set(clock_div_1);
 155
 156         /* Hardware Initialization */
 157         LEDs_Init();
 158         USB_Init();
 159 }
 160
 161 /** Event handler for the library USB Connection event. */
 162 void EVENT_USB_Device_Connect(void)
 163 {
 164         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 165 }
 166
 167 /** Event handler for the library USB Disconnection event. */
 168 void EVENT_USB_Device_Disconnect(void)
 169 {
 170         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 171 }
 172
 173 /** Event handler for the library USB Configuration Changed event. */
 174 void EVENT_USB_Device_ConfigurationChanged(void)
 175 {
 176         bool ConfigSuccess = true;
 177
 178         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 179
 180         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 181 }
 182
 183 /** Event handler for the library USB Control Request reception event. */
 184 void EVENT_USB_Device_ControlRequest(void)
 185 {
 186         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 187 }
 188
 189 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 190  *  for later transmission to the host.
 191  */
 192 ISR(USART1_RX_vect, ISR_BLOCK)
 193 {
 194         uint8_t ReceivedByte = UDR1;
 195
 196         if (USB_DeviceState == DEVICE_STATE_Configured)
 197           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 198 }
 199
 200 /** Event handler for the CDC Class driver Line Encoding Changed event.
 201  *
 202  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 203  */
 204 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 205 {
 206         uint8_t ConfigMask = 0;
 207
 208         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 209         {
 210                 case CDC_PARITY_Odd:
 211                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 212                         break;
 213                 case CDC_PARITY_Even:
 214                         ConfigMask = (1 << UPM11);
 215                         break;
 216         }
 217
 218         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 219           ConfigMask |= (1 << USBS1);
 220
 221         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 222         {
 223                 case 6:
 224                         ConfigMask |= (1 << UCSZ10);
 225                         break;
 226                 case 7:
 227                         ConfigMask |= (1 << UCSZ11);
 228                         break;
 229                 case 8:
 230                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 231                         break;
 232         }
 233
 234         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 235         UCSR1B = 0;
 236         UCSR1A = 0;
 237         UCSR1C = 0;
 238
 239         /* Set the new baud rate before configuring the USART */
 240         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 241
 242         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 243         UCSR1C = ConfigMask;
 244         UCSR1A = (1 << U2X1);
 245         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 246 }
 247