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         /* Hardware Initialization */
 149         Serial_Init(9600, false);
 150         LEDs_Init();
 151         USB_Init();
 152
 153         /* Millisecond Timer Interrupt */
 154         OCR0A  = (F_CPU / 64 / 1000);
 155         TCCR0A = (1 << WGM01);
 156         TCCR0B = ((1 << CS01) | (1 << CS00));
 157
 158         /* Tristate target /RESET Line */
 159         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 160         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 161 }
 162
 163 /** Event handler for the library USB Connection event. */
 164 void EVENT_USB_Device_Connect(void)
 165 {
 166         PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 167         LEDs_SetAllLEDs(LEDMASK_TX);
 168 }
 169
 170 /** Event handler for the library USB Disconnection event. */
 171 void EVENT_USB_Device_Disconnect(void)
 172 {
 173         PulseMSRemaining.PingPongLEDPulse = 0;
 174         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 175 }
 176
 177 /** Event handler for the library USB Configuration Changed event. */
 178 void EVENT_USB_Device_ConfigurationChanged(void)
 179 {
 180         PulseMSRemaining.PingPongLEDPulse = 0;
 181         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 182
 183         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 184           LEDs_SetAllLEDs(LEDMASK_ERROR);
 185 }
 186
 187 /** Event handler for the library USB Unhandled Control Request event. */
 188 void EVENT_USB_Device_UnhandledControlRequest(void)
 189 {
 190         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 191 }
 192
 193 /** Event handler for the CDC Class driver Line Encoding Changed event.
 194  *
 195  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 196  */
 197 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 198 {
 199         uint8_t ConfigMask = 0;
 200
 201         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 202         {
 203                 case CDC_PARITY_Odd:
 204                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 205                         break;
 206                 case CDC_PARITY_Even:
 207                         ConfigMask = (1 << UPM11);
 208                         break;
 209         }
 210
 211         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 212           ConfigMask |= (1 << USBS1);
 213
 214         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 215         {
 216                 case 6:
 217                         ConfigMask |= (1 << UCSZ10);
 218                         break;
 219                 case 7:
 220                         ConfigMask |= (1 << UCSZ11);
 221                         break;
 222                 case 8:
 223                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 224                         break;
 225         }
 226
 227         UCSR1A = (1 << U2X1);
 228         UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
 229         UCSR1C = ConfigMask;
 230         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 231 }
 232
 233 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
 234  *  for later transmission to the host.
 235  */
 236 ISR(USART1_RX_vect, ISR_BLOCK)
 237 {
 238         uint8_t ReceivedByte = UDR1;
 239
 240         if (USB_DeviceState == DEVICE_STATE_Configured)
 241           Buffer_StoreElement(&Tx_Buffer, ReceivedByte);
 242 }
 243
 244 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 245  *
 246  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 247  */
 248 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 249 {
 250         bool CurrentDTRState = (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR);
 251
 252         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 253         if (!(PreviousDTRState) && CurrentDTRState)
 254         {
 255                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 256
 257                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 258                 PulseMSRemaining.ResetPulse = AVR_RESET_PULSE_MS;
 259         }
 260
 261         PreviousDTRState = CurrentDTRState;
 262 }