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 #if (ARCH == ARCH_AVR8)
 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 #endif
 156
 157         /* Hardware Initialization */
 158         LEDs_Init();
 159         USB_Init();
 160 }
 161
 162 /** Event handler for the library USB Connection event. */
 163 void EVENT_USB_Device_Connect(void)
 164 {
 165         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 166 }
 167
 168 /** Event handler for the library USB Disconnection event. */
 169 void EVENT_USB_Device_Disconnect(void)
 170 {
 171         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 172 }
 173
 174 /** Event handler for the library USB Configuration Changed event. */
 175 void EVENT_USB_Device_ConfigurationChanged(void)
 176 {
 177         bool ConfigSuccess = true;
 178
 179         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 180
 181         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 182 }
 183
 184 /** Event handler for the library USB Control Request reception event. */
 185 void EVENT_USB_Device_ControlRequest(void)
 186 {
 187         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 188 }
 189
 190 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 191  *  for later transmission to the host.
 192  */
 193 ISR(USART1_RX_vect, ISR_BLOCK)
 194 {
 195         uint8_t ReceivedByte = UDR1;
 196
 197         if (USB_DeviceState == DEVICE_STATE_Configured)
 198           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 199 }
 200
 201 /** Event handler for the CDC Class driver Line Encoding Changed event.
 202  *
 203  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 204  */
 205 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 206 {
 207         uint8_t ConfigMask = 0;
 208
 209         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 210         {
 211                 case CDC_PARITY_Odd:
 212                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 213                         break;
 214                 case CDC_PARITY_Even:
 215                         ConfigMask = (1 << UPM11);
 216                         break;
 217         }
 218
 219         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 220           ConfigMask |= (1 << USBS1);
 221
 222         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 223         {
 224                 case 6:
 225                         ConfigMask |= (1 << UCSZ10);
 226                         break;
 227                 case 7:
 228                         ConfigMask |= (1 << UCSZ11);
 229                         break;
 230                 case 8:
 231                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 232                         break;
 233         }
 234
 235         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 236         UCSR1B = 0;
 237         UCSR1A = 0;
 238         UCSR1C = 0;
 239
 240         /* Set the new baud rate before configuring the USART */
 241         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 242
 243         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 244         UCSR1C = ConfigMask;
 245         UCSR1A = (1 << U2X1);
 246         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 247 }
 248