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 RingBuffer_t USARTtoUSB_Buffer;
  41
  42 /** Underlying data buffer for \ref USARTtoUSB_Buffer, where the stored bytes are located. */
  43 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                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 110                         if (PulseMSRemaining.ResetPulse && !(--PulseMSRemaining.ResetPulse))
 111                         {
 112                                 LEDs_TurnOffLEDs(LEDMASK_BUSY);
 113                                 AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 114                         }
 115
 116                         /* Check if the LEDs should be ping-ponging (during enumeration) */
 117                         if (PulseMSRemaining.PingPongLEDPulse && !(--PulseMSRemaining.PingPongLEDPulse))
 118                         {
 119                                 LEDs_ToggleLEDs(LEDMASK_TX | LEDMASK_RX);
 120                                 PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 121                         }
 122
 123                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 124                         if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse))
 125                           LEDs_TurnOffLEDs(LEDMASK_TX);
 126
 127                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 128                         if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse))
 129                           LEDs_TurnOffLEDs(LEDMASK_RX);
 130
 131                         /* Check if the receive buffer flush period has expired */
 132                         uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
 133                         if (!(--FlushPeriodRemaining) || (BufferCount > 200))
 134                         {
 135                                 /* Echo bytes from the target to the host via the virtual serial port */
 136                                 if (BufferCount)
 137                                 {
 138                                         while (BufferCount--)
 139                                         {
 140                                                 /* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 141                                                 if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
 142                                                                                                 RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 143                                                 {
 144                                                         break;
 145                                                 }
 146
 147                                                 /* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
 148                                                 RingBuffer_Remove(&USARTtoUSB_Buffer);
 149                                         }
 150
 151                                         LEDs_TurnOnLEDs(LEDMASK_RX);
 152                                         PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS;
 153                                 }
 154
 155                                 FlushPeriodRemaining = RECEIVE_BUFFER_FLUSH_MS;
 156                         }
 157
 158                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 159                         TIFR0 |= (1 << OCF0A);
 160                 }
 161
 162                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 163                 USB_USBTask();
 164         }
 165 }
 166
 167 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 168 void SetupHardware(void)
 169 {
 170         /* Disable watchdog if enabled by bootloader/fuses */
 171         MCUSR &= ~(1 << WDRF);
 172         wdt_disable();
 173
 174         /* Hardware Initialization */
 175         LEDs_Init();
 176         USB_Init();
 177
 178         /* Millisecond Timer Interrupt */
 179         OCR0A  = (F_CPU / 64 / 1000);
 180         TCCR0A = (1 << WGM01);
 181         TCCR0B = ((1 << CS01) | (1 << CS00));
 182
 183         /* Tristate target /RESET Line */
 184         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 185         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 186 }
 187
 188 /** Event handler for the library USB Connection event. */
 189 void EVENT_USB_Device_Connect(void)
 190 {
 191         PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 192         LEDs_SetAllLEDs(LEDMASK_TX);
 193 }
 194
 195 /** Event handler for the library USB Disconnection event. */
 196 void EVENT_USB_Device_Disconnect(void)
 197 {
 198         PulseMSRemaining.PingPongLEDPulse = 0;
 199         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 200 }
 201
 202 /** Event handler for the library USB Configuration Changed event. */
 203 void EVENT_USB_Device_ConfigurationChanged(void)
 204 {
 205         bool ConfigSuccess = true;
 206
 207         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
 208
 209         PulseMSRemaining.PingPongLEDPulse = 0;
 210
 211         LEDs_SetAllLEDs(ConfigSuccess ? LEDS_NO_LEDS : LEDMASK_ERROR);
 212 }
 213
 214 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 215  *  the device from the USB host before passing along unhandled control requests to the library for processing
 216  *  internally.
 217  */
 218 void EVENT_USB_Device_ControlRequest(void)
 219 {
 220         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 221 }
 222
 223 /** Event handler for the CDC Class driver Line Encoding Changed event.
 224  *
 225  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 226  */
 227 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 228 {
 229         uint8_t ConfigMask = 0;
 230
 231         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 232         {
 233                 case CDC_PARITY_Odd:
 234                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 235                         break;
 236                 case CDC_PARITY_Even:
 237                         ConfigMask = (1 << UPM11);
 238                         break;
 239         }
 240
 241         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 242           ConfigMask |= (1 << USBS1);
 243
 244         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 245         {
 246                 case 6:
 247                         ConfigMask |= (1 << UCSZ10);
 248                         break;
 249                 case 7:
 250                         ConfigMask |= (1 << UCSZ11);
 251                         break;
 252                 case 8:
 253                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 254                         break;
 255         }
 256
 257         /* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
 258         UCSR1B = 0;
 259         UCSR1A = 0;
 260         UCSR1C = 0;
 261
 262         /* Set the new baud rate before configuring the USART */
 263         UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 264
 265         /* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
 266         UCSR1C = ConfigMask;
 267         UCSR1A = (1 << U2X1);
 268         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 269 }
 270
 271 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 272  *  for later transmission to the host.
 273  */
 274 ISR(USART1_RX_vect, ISR_BLOCK)
 275 {
 276         uint8_t ReceivedByte = UDR1;
 277
 278         if (USB_DeviceState == DEVICE_STATE_Configured)
 279           RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
 280 }
 281
 282 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 283  *
 284  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 285  */
 286 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 287 {
 288         bool CurrentDTRState = (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR);
 289
 290         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 291         if (!(PreviousDTRState) && CurrentDTRState)
 292         {
 293                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 294
 295                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 296                 PulseMSRemaining.ResetPulse = AVR_RESET_PULSE_MS;
 297         }
 298
 299         PreviousDTRState = CurrentDTRState;
 300 }
 301