Projects/Benito/Benito.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 RingBuff_t Tx_Buffer;
  41
  42 /** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */
  43 volatile struct
  44 {
  45         uint8_t ResetPulse; /**< Milliseconds remaining for target /RESET pulse */
  46         uint8_t TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */
  47         uint8_t RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */
  48         uint8_t PingPongLEDPulse; /**< Milliseconds remaining for enumeration Tx/Rx ping-pong LED pulse */
  49 } PulseMSRemaining;
  50
  51 /** Previous state of the virtual DTR control line from the host */
  52 bool PreviousDTRState = false;
  53
  54 /** LUFA CDC Class driver interface configuration and state information. This structure is
  55  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  56  *  within a device can be differentiated from one another.
  57  */
  58 USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
  59         {
  60                 .Config =
  61                         {
  62                                 .ControlInterfaceNumber         = 0,
  63
  64                                 .DataINEndpointNumber           = CDC_TX_EPNUM,
  65                                 .DataINEndpointSize             = CDC_TXRX_EPSIZE,
  66                                 .DataINEndpointDoubleBank       = false,
  67
  68                                 .DataOUTEndpointNumber          = CDC_RX_EPNUM,
  69                                 .DataOUTEndpointSize            = CDC_TXRX_EPSIZE,
  70                                 .DataOUTEndpointDoubleBank      = false,
  71
  72                                 .NotificationEndpointNumber     = CDC_NOTIFICATION_EPNUM,
  73                                 .NotificationEndpointSize       = CDC_NOTIFICATION_EPSIZE,
  74                                 .NotificationEndpointDoubleBank = false,
  75                         },
  76         };
  77
  78 /** Main program entry point. This routine contains the overall program flow, including initial
  79  *  setup of all components and the main program loop.
  80  */
  81 int main(void)
  82 {
  83         SetupHardware();
  84
  85         Buffer_Initialize(&Tx_Buffer);
  86
  87         for (;;)
  88         {
  89                 /* Echo bytes from the host to the target via the hardware USART */
  90                 while (CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface) > 0)
  91                 {
  92                         Serial_TxByte(CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface));
  93
  94                         LEDs_TurnOnLEDs(LEDMASK_TX);
  95                         PulseMSRemaining.TxLEDPulse = TX_RX_LED_PULSE_MS;
  96                 }
  97
  98                 /* Echo bytes from the target to the host via the virtual serial port */
  99                 while (Tx_Buffer.Elements > 0)
 100                 {
 101                         CDC_Device_SendByte(&VirtualSerial_CDC_Interface, Buffer_GetElement(&Tx_Buffer));
 102
 103                         LEDs_TurnOnLEDs(LEDMASK_RX);
 104                         PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS;
 105                 }
 106
 107                 /* Check if the millisecond timer has elapsed */
 108                 if (TIFR0 & (1 << OCF0A))
 109                 {
 110                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 111                         if (PulseMSRemaining.ResetPulse && !(--PulseMSRemaining.ResetPulse))
 112                         {
 113                                 LEDs_TurnOffLEDs(LEDMASK_BUSY);
 114                                 AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 115                         }
 116
 117                         /* Check if the LEDs should be ping-ponging (during enumeration) */
 118                         if (PulseMSRemaining.PingPongLEDPulse && !(--PulseMSRemaining.PingPongLEDPulse))
 119                         {
 120                                 LEDs_ToggleLEDs(LEDMASK_TX | LEDMASK_RX);
 121                                 PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 122                         }
 123
 124                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 125                         if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse))
 126                           LEDs_TurnOffLEDs(LEDMASK_TX);
 127
 128                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 129                         if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse))
 130                           LEDs_TurnOffLEDs(LEDMASK_RX);
 131
 132                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 133                         TIFR0 |= (1 << OCF0A);
 134                 }
 135
 136                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 137                 USB_USBTask();
 138         }
 139 }
 140
 141 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 142 void SetupHardware(void)
 143 {
 144         /* Disable watchdog if enabled by bootloader/fuses */
 145         MCUSR &= ~(1 << WDRF);
 146         wdt_disable();
 147
 148         /* Disable clock division */
 149         clock_prescale_set(clock_div_1);
 150
 151         /* Hardware Initialization */
 152         Serial_Init(9600, false);
 153         LEDs_Init();
 154         USB_Init();
 155
 156         /* Millisecond Timer Interrupt */
 157         OCR0A  = (F_CPU / 64 / 1000);
 158         TCCR0A = (1 << WGM01);
 159         TCCR0B = ((1 << CS01) | (1 << CS00));
 160
 161         /* Tristate target /RESET Line */
 162         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 163         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 164 }
 165
 166 /** Event handler for the library USB Connection event. */
 167 void EVENT_USB_Device_Connect(void)
 168 {
 169         PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 170         LEDs_SetAllLEDs(LEDMASK_TX);
 171 }
 172
 173 /** Event handler for the library USB Disconnection event. */
 174 void EVENT_USB_Device_Disconnect(void)
 175 {
 176         PulseMSRemaining.PingPongLEDPulse = 0;
 177         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 178 }
 179
 180 /** Event handler for the library USB Configuration Changed event. */
 181 void EVENT_USB_Device_ConfigurationChanged(void)
 182 {
 183         PulseMSRemaining.PingPongLEDPulse = 0;
 184         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 185
 186         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 187           LEDs_SetAllLEDs(LEDMASK_ERROR);
 188 }
 189
 190 /** Event handler for the library USB Unhandled Control Request event. */
 191 void EVENT_USB_Device_UnhandledControlRequest(void)
 192 {
 193         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 194 }
 195
 196 /** Event handler for the CDC Class driver Line Encoding Changed event.
 197  *
 198  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 199  */
 200 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 201 {
 202         uint8_t ConfigMask = 0;
 203
 204         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 205         {
 206                 case CDC_PARITY_Odd:
 207                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 208                         break;
 209                 case CDC_PARITY_Even:
 210                         ConfigMask = (1 << UPM11);
 211                         break;
 212         }
 213
 214         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 215           ConfigMask |= (1 << USBS1);
 216
 217         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 218         {
 219                 case 6:
 220                         ConfigMask |= (1 << UCSZ10);
 221                         break;
 222                 case 7:
 223                         ConfigMask |= (1 << UCSZ11);
 224                         break;
 225                 case 8:
 226                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 227                         break;
 228         }
 229
 230         UCSR1A = (1 << U2X1);
 231         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 232         UCSR1C = ConfigMask;
 233         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 234 }
 235
 236 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 237  *  for later transmission to the host.
 238  */
 239 ISR(USART1_RX_vect, ISR_BLOCK)
 240 {
 241         uint8_t ReceivedByte = UDR1;
 242
 243         if (USB_DeviceState == DEVICE_STATE_Configured)
 244           Buffer_StoreElement(&Tx_Buffer, ReceivedByte);
 245 }
 246
 247 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 248  *
 249  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 250  */
 251 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 252 {
 253         bool CurrentDTRState = (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR);
 254
 255         /* Check if the DTR line has been de-asserted - if so, start the target AVR's reset pulse */
 256         if (PreviousDTRState && !(CurrentDTRState))
 257         {
 258                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 259
 260                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 261                 PulseMSRemaining.ResetPulse = AVR_RESET_PULSE_MS;
 262         }
 263
 264         PreviousDTRState = CurrentDTRState;
 265 }