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                         /* Store received byte into the USART transmit buffer */
 103                         if (!(ReceivedByte < 0))
 104                           RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
 105                 }
 106
 107                 uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
 108                 if (BufferCount)
 109                 {
 110                         Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
 111
 112                         /* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data
 113                          * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */
 114                         if (Endpoint_IsINReady())
 115                         {
 116                                 /* Never send more than one bank size less one byte to the host at a time, so that we don't block
 117                                  * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
 118                                 uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
 119
 120                                 /* Read bytes from the USART receive buffer into the USB IN endpoint */
 121                                 while (BytesToSend--)
 122                                 {
 123                                         /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 124                                         if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
 125                                                                                         RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 126                                         {
 127                                                 break;
 128                                         }
 129
 130                                         /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
 131                                         RingBuffer_Remove(&USARTtoUSB_Buffer);
 132                                 }
 133                         }
 134                 }
 135
 136                 /* Load the next byte from the USART transmit buffer into the USART */
 137                 if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
 138                   Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
 139
 140                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 141                 USB_USBTask();
 142         }
 143 }
 144
 145 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 146 void SetupHardware(void)
 147 {
 148         /* Disable watchdog if enabled by bootloader/fuses */
 149         MCUSR &= ~(1 << WDRF);
 150         wdt_disable();
 151
 152         /* Disable clock division */
 153         clock_prescale_set(clock_div_1);
 154
 155         /* Hardware Initialization */
 156         LEDs_Init();
 157         USB_Init();
 158 }
 159
 160 /** Event handler for the library USB Connection event. */
 161 void EVENT_USB_Device_Connect(void)
 162 {
 163         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 164 }
 165
 166 /** Event handler for the library USB Disconnection event. */
 167 void EVENT_USB_Device_Disconnect(void)
 168 {
 169         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 170 }
 171
 172 /** Event handler for the library USB Configuration Changed event. */
 173 void EVENT_USB_Device_ConfigurationChanged(void)
 174 {
 175         bool ConfigSuccess = true;
 176
 177         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 178
 179         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 180 }
 181
 182 /** Event handler for the library USB Control Request reception event. */
 183 void EVENT_USB_Device_ControlRequest(void)
 184 {
 185         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 186 }
 187
 188 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 189  *  for later transmission to the host.
 190  */
 191 ISR(USART1_RX_vect, ISR_BLOCK)
 192 {
 193         uint8_t ReceivedByte = UDR1;
 194
 195         if (USB_DeviceState == DEVICE_STATE_Configured)
 196           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 197 }
 198
 199 /** Event handler for the CDC Class driver Line Encoding Changed event.
 200  *
 201  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 202  */
 203 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 204 {
 205         uint8_t ConfigMask = 0;
 206
 207         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 208         {
 209                 case CDC_PARITY_Odd:
 210                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 211                         break;
 212                 case CDC_PARITY_Even:
 213                         ConfigMask = (1 << UPM11);
 214                         break;
 215         }
 216
 217         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 218           ConfigMask |= (1 << USBS1);
 219
 220         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 221         {
 222                 case 6:
 223                         ConfigMask |= (1 << UCSZ10);
 224                         break;
 225                 case 7:
 226                         ConfigMask |= (1 << UCSZ11);
 227                         break;
 228                 case 8:
 229                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 230                         break;
 231         }
 232
 233         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 234         UCSR1B = 0;
 235         UCSR1A = 0;
 236         UCSR1C = 0;
 237
 238         /* Set the new baud rate before configuring the USART */
 239         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 240
 241         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 242         UCSR1C = ConfigMask;
 243         UCSR1A = (1 << U2X1);
 244         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 245 }
 246