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 /** 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
  61                                 .DataINEndpointNumber           = CDC_TX_EPNUM,
  62                                 .DataINEndpointSize             = CDC_TXRX_EPSIZE,
  63                                 .DataINEndpointDoubleBank       = false,
  64
  65                                 .DataOUTEndpointNumber          = CDC_RX_EPNUM,
  66                                 .DataOUTEndpointSize            = CDC_TXRX_EPSIZE,
  67                                 .DataOUTEndpointDoubleBank      = false,
  68
  69                                 .NotificationEndpointNumber     = CDC_NOTIFICATION_EPNUM,
  70                                 .NotificationEndpointSize       = CDC_NOTIFICATION_EPSIZE,
  71                                 .NotificationEndpointDoubleBank = false,
  72                         },
  73         };
  74
  75 /** Main program entry point. This routine contains the overall program flow, including initial
  76  *  setup of all components and the main program loop.
  77  */
  78 int main(void)
  79 {
  80         SetupHardware();
  81
  82         Buffer_Initialize(&Tx_Buffer);
  83
  84         for (;;)
  85         {
  86                 /* Echo bytes from the host to the target via the hardware USART */
  87                 while (CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface) > 0)
  88                 {
  89                         Serial_TxByte(CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface));
  90
  91                         LEDs_TurnOnLEDs(LEDMASK_TX);
  92                         PulseMSRemaining.TxLEDPulse = TX_RX_LED_PULSE_MS;
  93                 }
  94
  95                 /* Echo bytes from the target to the host via the virtual serial port */
  96                 while (Tx_Buffer.Elements > 0)
  97                 {
  98                         CDC_Device_SendByte(&VirtualSerial_CDC_Interface, Buffer_GetElement(&Tx_Buffer));
  99
 100                         LEDs_TurnOnLEDs(LEDMASK_RX);
 101                         PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS;
 102                 }
 103
 104                 /* Check if the millisecond timer has elapsed */
 105                 if (TIFR0 & (1 << OCF0A))
 106                 {
 107                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 108                         if (PulseMSRemaining.ResetPulse && !(--PulseMSRemaining.ResetPulse))
 109                         {
 110                                 LEDs_TurnOffLEDs(LEDMASK_BUSY);
 111                                 AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 112                         }
 113
 114                         /* Check if the LEDs should be ping-ponging (during enumeration) */
 115                         if (PulseMSRemaining.PingPongLEDPulse && !(--PulseMSRemaining.PingPongLEDPulse))
 116                         {
 117                                 LEDs_ToggleLEDs(LEDMASK_TX | LEDMASK_RX);
 118                                 PulseMSRemaining.PingPongLEDPulse = PING_PONG_LED_PULSE_MS;
 119                         }
 120
 121                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 122                         if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse))
 123                           LEDs_TurnOffLEDs(LEDMASK_TX);
 124
 125                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 126                         if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse))
 127                           LEDs_TurnOffLEDs(LEDMASK_RX);
 128
 129                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 130                         TIFR0 |= (1 << OCF0A);
 131                 }
 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         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         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 251         if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 252         {
 253                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 254
 255                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 256                 PulseMSRemaining.ResetPulse = AVR_RESET_PULSE_MS;
 257         }
 258 }