Projects/Benito/Benito.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 Benito project. This file contains the main tasks of
  34  *  the project and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "Benito.h"
  38
  39 /** Circular buffer to hold data from the serial port before it is sent to the host. */
  40 static RingBuffer_t USARTtoUSB_Buffer;
  41
  42 /** Underlying data buffer for \ref USARTtoUSB_Buffer, where the stored bytes are located. */
  43 static uint8_t      USARTtoUSB_Buffer_Data[128];
  44
  45 /** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */
  46 volatile struct
  47 {
  48         uint8_t ResetPulse; /**< Milliseconds remaining for target /RESET pulse */
  49         uint8_t TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */
  50         uint8_t RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */
  51         uint8_t PingPongLEDPulse; /**< Milliseconds remaining for enumeration Tx/Rx ping-pong LED pulse */
  52 } PulseMSRemaining;
  53
  54 /** Previous state of the virtual DTR control line from the host */
  55 bool PreviousDTRState = false;
  56
  57 /** Milliseconds remaining until the receive buffer is flushed to the USB host */
  58 uint8_t FlushPeriodRemaining = RECEIVE_BUFFER_FLUSH_MS;
  59
  60 /** LUFA CDC Class driver interface configuration and state information. This structure is
  61  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  62  *  within a device can be differentiated from one another.
  63  */
  64 USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
  65         {
  66                 .Config =
  67                         {
  68                                 .ControlInterfaceNumber         = 0,
  69
  70                                 .DataINEndpointNumber           = CDC_TX_EPNUM,
  71                                 .DataINEndpointSize             = CDC_TXRX_EPSIZE,
  72                                 .DataINEndpointDoubleBank       = false,
  73
  74                                 .DataOUTEndpointNumber          = CDC_RX_EPNUM,
  75                                 .DataOUTEndpointSize            = CDC_TXRX_EPSIZE,
  76                                 .DataOUTEndpointDoubleBank      = false,
  77
  78                                 .NotificationEndpointNumber     = CDC_NOTIFICATION_EPNUM,
  79                                 .NotificationEndpointSize       = CDC_NOTIFICATION_EPSIZE,
  80                                 .NotificationEndpointDoubleBank = false,
  81                         },
  82         };
  83
  84 /** Main program entry point. This routine contains the overall program flow, including initial
  85  *  setup of all components and the main program loop.
  86  */
  87 int main(void)
  88 {
  89         SetupHardware();
  90
  91         RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
  92
  93         sei();
  94
  95         for (;;)
  96         {
  97                 /* Echo bytes from the host to the target via the hardware USART */
  98                 if ((UCSR1A & (1 << UDRE1)) && CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface))
  99                 {
 100                         UDR1 = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
 101
 102                         LEDs_TurnOnLEDs(LEDMASK_TX);
 103                         PulseMSRemaining.TxLEDPulse = TX_RX_LED_PULSE_MS;
 104                 }
 105
 106                 /* Check if the millisecond timer has elapsed */
 107                 if (TIFR0 & (1 << OCF0A))
 108                 {
 109                         /* Clear flush timer expiry flag */
 110                         TIFR0 |= (1 << TOV0);
 111
 112                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 113                         if (PulseMSRemaining.ResetPulse && !(--PulseMSRemaining.ResetPulse))
 114                         {
 115                                 LEDs_TurnOffLEDs(LEDMASK_BUSY);
 116                                 AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 117                         }
 118
 119                         /* Check if the LEDs should be ping-ponging (during enumeration) */
 120                         if (PulseMSRemaining.PingPongLEDPulse && !(--PulseMSRemaining.PingPongLEDPulse))
 121                         {
 122                                 LEDs_ToggleLEDs(LEDMASK_TX | LEDMASK_RX);
 123                                 PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 124                         }
 125
 126                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 127                         if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse))
 128                           LEDs_TurnOffLEDs(LEDMASK_TX);
 129
 130                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 131                         if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse))
 132                           LEDs_TurnOffLEDs(LEDMASK_RX);
 133
 134                         /* Check if the receive buffer flush period has expired */
 135                         uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
 136                         if (!(--FlushPeriodRemaining) || (BufferCount > 200))
 137                         {
 138                                 FlushPeriodRemaining = RECEIVE_BUFFER_FLUSH_MS;
 139
 140                                 /* Start RX LED indicator pulse */
 141                                 if (BufferCount)
 142                                 {
 143                                         LEDs_TurnOnLEDs(LEDMASK_RX);
 144                                         PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS;
 145                                 }
 146
 147                                 /* Echo bytes from the target to the host via the virtual serial port */
 148                                 while (BufferCount--)
 149                                 {
 150                                         /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 151                                         if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
 152                                                                                         RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 153                                         {
 154                                                 break;
 155                                         }
 156
 157                                         /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
 158                                         RingBuffer_Remove(&USARTtoUSB_Buffer);
 159                                 }
 160                         }
 161                 }
 162
 163                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 164                 USB_USBTask();
 165         }
 166 }
 167
 168 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 169 void SetupHardware(void)
 170 {
 171         /* Disable watchdog if enabled by bootloader/fuses */
 172         MCUSR &= ~(1 << WDRF);
 173         wdt_disable();
 174
 175         /* Hardware Initialization */
 176         LEDs_Init();
 177         USB_Init();
 178
 179         /* Millisecond Timer Interrupt */
 180         OCR0A  = (F_CPU / 64 / 1000);
 181         TCCR0A = (1 << WGM01);
 182         TCCR0B = ((1 << CS01) | (1 << CS00));
 183
 184         /* Tristate target /RESET Line */
 185         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 186         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 187 }
 188
 189 /** Event handler for the library USB Connection event. */
 190 void EVENT_USB_Device_Connect(void)
 191 {
 192         PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 193         LEDs_SetAllLEDs(LEDMASK_TX);
 194 }
 195
 196 /** Event handler for the library USB Disconnection event. */
 197 void EVENT_USB_Device_Disconnect(void)
 198 {
 199         PulseMSRemaining.PingPongLEDPulse = 0;
 200         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 201 }
 202
 203 /** Event handler for the library USB Configuration Changed event. */
 204 void EVENT_USB_Device_ConfigurationChanged(void)
 205 {
 206         bool ConfigSuccess = true;
 207
 208         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 209
 210         PulseMSRemaining.PingPongLEDPulse = 0;
 211
 212         LEDs_SetAllLEDs(ConfigSuccess ? LEDS_NO_LEDS : LEDMASK_ERROR);
 213 }
 214
 215 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 216  *  the device from the USB host before passing along unhandled control requests to the library for processing
 217  *  internally.
 218  */
 219 void EVENT_USB_Device_ControlRequest(void)
 220 {
 221         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 222 }
 223
 224 /** Event handler for the CDC Class driver Line Encoding Changed event.
 225  *
 226  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 227  */
 228 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 229 {
 230         uint8_t ConfigMask = 0;
 231
 232         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 233         {
 234                 case CDC_PARITY_Odd:
 235                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 236                         break;
 237                 case CDC_PARITY_Even:
 238                         ConfigMask = (1 << UPM11);
 239                         break;
 240         }
 241
 242         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 243           ConfigMask |= (1 << USBS1);
 244
 245         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 246         {
 247                 case 6:
 248                         ConfigMask |= (1 << UCSZ10);
 249                         break;
 250                 case 7:
 251                         ConfigMask |= (1 << UCSZ11);
 252                         break;
 253                 case 8:
 254                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 255                         break;
 256         }
 257
 258         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 259         UCSR1B = 0;
 260         UCSR1A = 0;
 261         UCSR1C = 0;
 262
 263         /* Set the new baud rate before configuring the USART */
 264         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 265
 266         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 267         UCSR1C = ConfigMask;
 268         UCSR1A = (1 << U2X1);
 269         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 270 }
 271
 272 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 273  *  for later transmission to the host.
 274  */
 275 ISR(USART1_RX_vect, ISR_BLOCK)
 276 {
 277         uint8_t ReceivedByte = UDR1;
 278
 279         if (USB_DeviceState == DEVICE_STATE_Configured)
 280           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 281 }
 282
 283 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 284  *
 285  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 286  */
 287 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 288 {
 289         bool CurrentDTRState = (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR);
 290
 291         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 292         if (!(PreviousDTRState) && CurrentDTRState)
 293         {
 294                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 295
 296                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 297                 PulseMSRemaining.ResetPulse = AVR_RESET_PULSE_MS;
 298         }
 299
 300         PreviousDTRState = CurrentDTRState;
 301 }
 302