Projects/Benito/Benito.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "Benito.h"
  38
  39 /** Counter for the number of milliseconds remaining for the target /RESET pulse being generated. */
  40 volatile uint8_t ResetPulseMSRemaining = 0;
  41
  42 /** Counter for the number of milliseconds remaining for the TX activity LED pulse being generated. */
  43 volatile uint8_t TxPulseMSRemaining    = 0;
  44
  45 /** Counter for the number of milliseconds remaining for the RX activity LED pulse being generated. */
  46 volatile uint8_t RxPulseMSRemaining    = 0;
  47
  48 /** Counter for the number of milliseconds remaining for the enumeration LED ping-pong being generated. */
  49 volatile uint8_t PingPongMSRemaining   = 0;
  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
  64                                 .DataOUTEndpointNumber      = CDC_RX_EPNUM,
  65                                 .DataOUTEndpointSize        = CDC_TXRX_EPSIZE,
  66
  67                                 .NotificationEndpointNumber = CDC_NOTIFICATION_EPNUM,
  68                                 .NotificationEndpointSize   = CDC_NOTIFICATION_EPSIZE,
  69                         },
  70         };
  71
  72 /** Main program entry point. This routine contains the overall program flow, including initial
  73  *  setup of all components and the main program loop.
  74  */
  75 int main(void)
  76 {
  77         SetupHardware();
  78
  79         for (;;)
  80         {
  81                 /* Echo bytes from the host to the target via the hardware USART */
  82                 if (CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface) > 0)
  83                 {
  84                         Serial_TxByte(CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface));
  85
  86                         LEDs_TurnOnLEDs(LEDMASK_TX);
  87                         TxPulseMSRemaining = TX_RX_LED_PULSE_MS;
  88                 }
  89
  90                 /* Echo bytes from the target to the host via the virtual serial port */
  91                 if (Serial_IsCharReceived())
  92                 {
  93                         CDC_Device_SendByte(&VirtualSerial_CDC_Interface, Serial_RxByte());
  94
  95                         LEDs_TurnOnLEDs(LEDMASK_RX);
  96                         RxPulseMSRemaining = TX_RX_LED_PULSE_MS;
  97                 }
  98
  99                 /* Check if the millisecond timer has elapsed */
 100                 if (TIFR0 & (1 << OCF0A))
 101                 {
 102                         /* Check if the LEDs should be ping-ponging (during enumeration) */
 103                         if (PingPongMSRemaining && !(--PingPongMSRemaining))
 104                         {
 105                                 LEDs_ToggleLEDs(LEDMASK_BUSY);
 106                                 PingPongMSRemaining = PING_PONG_LED_PULSE_MS;
 107                         }
 108
 109                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 110                         if (ResetPulseMSRemaining && !(--ResetPulseMSRemaining))
 111                         {
 112                                 LEDs_TurnOffLEDs(LEDMASK_BUSY);
 113                                 AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 114                         }
 115
 116                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 117                         if (TxPulseMSRemaining && !(--TxPulseMSRemaining))
 118                           LEDs_TurnOffLEDs(LEDMASK_TX);
 119
 120                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 121                         if (RxPulseMSRemaining && !(--RxPulseMSRemaining))
 122                           LEDs_TurnOffLEDs(LEDMASK_RX);
 123
 124                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 125                         TIFR0 |= (1 << OCF0A);
 126                 }
 127
 128                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 129                 USB_USBTask();
 130         }
 131 }
 132
 133 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 134 void SetupHardware(void)
 135 {
 136         /* Disable watchdog if enabled by bootloader/fuses */
 137         MCUSR &= ~(1 << WDRF);
 138         wdt_disable();
 139
 140         /* Disable clock division */
 141         clock_prescale_set(clock_div_1);
 142
 143         /* Hardware Initialization */
 144         LEDs_Init();
 145         USB_Init();
 146
 147         /* Millisecond Timer Interrupt */
 148         OCR0A  = (F_CPU / 64 / 1000);
 149         TCCR0A = (1 << WGM01);
 150         TCCR0B = ((1 << CS01) | (1 << CS00));
 151
 152         /* Tristate target /RESET Line */
 153         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 154         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 155 }
 156
 157 /** Event handler for the library USB Connection event. */
 158 void EVENT_USB_Device_Connect(void)
 159 {
 160         PingPongMSRemaining = PING_PONG_LED_PULSE_MS;
 161         LEDs_SetAllLEDs(LEDMASK_TX);
 162 }
 163
 164 /** Event handler for the library USB Disconnection event. */
 165 void EVENT_USB_Device_Disconnect(void)
 166 {
 167         PingPongMSRemaining = 0;
 168         LEDs_TurnOffLEDs(LEDMASK_BUSY);
 169 }
 170
 171 /** Event handler for the library USB Configuration Changed event. */
 172 void EVENT_USB_Device_ConfigurationChanged(void)
 173 {
 174         PingPongMSRemaining = 0;
 175         LEDs_TurnOffLEDs(LEDMASK_BUSY);
 176
 177         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 178           LEDs_TurnOnLEDs(LEDMASK_ERROR);
 179 }
 180
 181 /** Event handler for the library USB Unhandled Control Request event. */
 182 void EVENT_USB_Device_UnhandledControlRequest(void)
 183 {
 184         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 185 }
 186
 187 /** Event handler for the CDC Class driver Line Encoding Changed event.
 188  *
 189  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 190  */
 191 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 192 {
 193         uint8_t ConfigMask = 0;
 194
 195         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 196         {
 197                 case CDC_PARITY_Odd:
 198                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 199                         break;
 200                 case CDC_PARITY_Even:
 201                         ConfigMask = (1 << UPM11);
 202                         break;
 203         }
 204
 205         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 206           ConfigMask |= (1 << USBS1);
 207
 208         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 209         {
 210                 case 6:
 211                         ConfigMask |= (1 << UCSZ10);
 212                         break;
 213                 case 7:
 214                         ConfigMask |= (1 << UCSZ11);
 215                         break;
 216                 case 8:
 217                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 218                         break;
 219         }
 220
 221         UCSR1A = (1 << U2X1);
 222         UCSR1B = ((1 << TXEN1) | (1 << RXEN1));
 223         UCSR1C = ConfigMask;
 224         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 225 }
 226
 227 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 228  *
 229  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 230  */
 231 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 232 {
 233         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 234         if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 235         {
 236                 LEDs_TurnOnLEDs(LEDMASK_BUSY);
 237
 238                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 239                 ResetPulseMSRemaining = AVR_RESET_PULSE_MS;
 240         }
 241 }