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         Serial_Init(9600, false);
 145         LEDs_Init();
 146         USB_Init();
 147
 148         /* Millisecond Timer Interrupt */
 149         OCR0A  = (F_CPU / 64 / 1000);
 150         TCCR0A = (1 << WGM01);
 151         TCCR0B = ((1 << CS01) | (1 << CS00));
 152
 153         /* Tristate target /RESET Line */
 154         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 155         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 156 }
 157
 158 /** Event handler for the library USB Connection event. */
 159 void EVENT_USB_Device_Connect(void)
 160 {
 161         PingPongMSRemaining = PING_PONG_LED_PULSE_MS;
 162         LEDs_SetAllLEDs(LEDMASK_TX);
 163 }
 164
 165 /** Event handler for the library USB Disconnection event. */
 166 void EVENT_USB_Device_Disconnect(void)
 167 {
 168         PingPongMSRemaining = 0;
 169         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 170 }
 171
 172 /** Event handler for the library USB Configuration Changed event. */
 173 void EVENT_USB_Device_ConfigurationChanged(void)
 174 {
 175         PingPongMSRemaining = 0;
 176         LEDs_SetAllLEDs(LEDS_NO_LEDS);
 177
 178         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 179           LEDs_SetAllLEDs(LEDMASK_ERROR);
 180 }
 181
 182 /** Event handler for the library USB Unhandled Control Request event. */
 183 void EVENT_USB_Device_UnhandledControlRequest(void)
 184 {
 185         CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 186 }
 187
 188 /** Event handler for the CDC Class driver Line Encoding Changed event.
 189  *
 190  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 191  */
 192 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 193 {
 194         uint8_t ConfigMask = 0;
 195
 196         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 197         {
 198                 case CDC_PARITY_Odd:
 199                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 200                         break;
 201                 case CDC_PARITY_Even:
 202                         ConfigMask = (1 << UPM11);
 203                         break;
 204         }
 205
 206         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 207           ConfigMask |= (1 << USBS1);
 208
 209         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 210         {
 211                 case 6:
 212                         ConfigMask |= (1 << UCSZ10);
 213                         break;
 214                 case 7:
 215                         ConfigMask |= (1 << UCSZ11);
 216                         break;
 217                 case 8:
 218                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 219                         break;
 220         }
 221
 222         UCSR1A = (1 << U2X1);
 223         UCSR1B = ((1 << TXEN1) | (1 << RXEN1));
 224         UCSR1C = ConfigMask;
 225         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 226 }
 227
 228 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 229  *
 230  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 231  */
 232 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 233 {
 234         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 235         if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 236         {
 237                 LEDs_SetAllLEDs(LEDMASK_BUSY);
 238
 239                 AVR_RESET_LINE_DDR    |= AVR_RESET_LINE_MASK;
 240                 ResetPulseMSRemaining  = AVR_RESET_PULSE_MS;
 241         }
 242 }