Projects/USBtoSerial/USBtoSerial.c

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