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