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 /** LUFA CDC Class driver interface configuration and state information. This structure is
  49  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  50  *  within a device can be differentiated from one another.
  51  */
  52 USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
  53         {
  54                 .Config =
  55                         {
  56                                 .ControlInterfaceNumber     = 0,
  57
  58                                 .DataINEndpointNumber       = CDC_TX_EPNUM,
  59                                 .DataINEndpointSize         = CDC_TXRX_EPSIZE,
  60
  61                                 .DataOUTEndpointNumber      = CDC_RX_EPNUM,
  62                                 .DataOUTEndpointSize        = CDC_TXRX_EPSIZE,
  63
  64                                 .NotificationEndpointNumber = CDC_NOTIFICATION_EPNUM,
  65                                 .NotificationEndpointSize   = CDC_NOTIFICATION_EPSIZE,
  66                         },
  67
  68                 .State =
  69                         {
  70                                 // Leave all state values to their defaults
  71                         }
  72         };
  73
  74 /** Main program entry point. This routine contains the overall program flow, including initial
  75  *  setup of all components and the main program loop.
  76  */
  77 int main(void)
  78 {
  79         SetupHardware();
  80
  81         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  82
  83         for (;;)
  84         {
  85                 /* Echo bytes from the host to the target via the hardware USART */
  86                 if (CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface))
  87                 {
  88                         Serial_TxByte(CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface));
  89
  90                         LEDs_TurnOnLEDs(LEDMASK_TX);
  91                         TxPulseMSRemaining = TX_RX_LED_PULSE_MS;
  92                 }
  93
  94                 /* Echo bytes from the target to the host via the virtual serial port */
  95                 if (Serial_IsCharReceived())
  96                 {
  97                         CDC_Device_SendByte(&VirtualSerial_CDC_Interface, Serial_RxByte());
  98
  99                         LEDs_TurnOnLEDs(LEDMASK_RX);
 100                         RxPulseMSRemaining = TX_RX_LED_PULSE_MS;
 101                 }
 102
 103                 /* Check if the millisecond timer has elapsed */
 104                 if (TIFR0 & (1 << OCF0A))
 105                 {
 106                         /* Check if the reset pulse period has elapsed, if so tristate the target reset line */
 107                         if (ResetPulseMSRemaining && !(--ResetPulseMSRemaining))
 108                         {
 109                                 AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 110                                 AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 111                         }
 112
 113                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 114                         if (TxPulseMSRemaining && !(--TxPulseMSRemaining))
 115                           LEDs_TurnOffLEDs(LEDMASK_TX);
 116
 117                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 118                         if (RxPulseMSRemaining && !(--RxPulseMSRemaining))
 119                           LEDs_TurnOffLEDs(LEDMASK_RX);
 120
 121                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 122                         TIFR0 |= (1 << OCF0A);
 123                 }
 124
 125                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 126                 USB_USBTask();
 127         }
 128 }
 129
 130 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 131 void SetupHardware(void)
 132 {
 133         /* Disable watchdog if enabled by bootloader/fuses */
 134         MCUSR &= ~(1 << WDRF);
 135         wdt_disable();
 136
 137         /* Disable clock division */
 138         clock_prescale_set(clock_div_1);
 139
 140         /* Hardware Initialization */
 141         LEDs_Init();
 142         USB_Init();
 143
 144         /* Millisecond Timer Interrupt */
 145         OCR0A  = (F_CPU / 64 / 1000);
 146         TCCR0A = (1 << WGM01);
 147         TCCR0B = ((1 << CS01) | (1 << CS00));
 148
 149         /* Tristate target /RESET Line */
 150         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 151         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 152 }
 153
 154 /** Event handler for the library USB Connection event. */
 155 void EVENT_USB_Connect(void)
 156 {
 157         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 158 }
 159
 160 /** Event handler for the library USB Disconnection event. */
 161 void EVENT_USB_Disconnect(void)
 162 {
 163         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 164 }
 165
 166 /** Event handler for the library USB Configuration Changed event. */
 167 void EVENT_USB_ConfigurationChanged(void)
 168 {
 169         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 170
 171         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 172           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 173 }
 174
 175 /** Event handler for the library USB Unhandled Control Packet event. */
 176 void EVENT_USB_UnhandledControlPacket(void)
 177 {
 178         CDC_Device_ProcessControlPacket(&VirtualSerial_CDC_Interface);
 179 }
 180
 181 /** Event handler for the CDC Class driver Line Encoding Changed event.
 182  *
 183  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 184  */
 185 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 186 {
 187         uint8_t ConfigMask = 0;
 188
 189         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 190         {
 191                 case CDC_PARITY_Odd:
 192                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 193                         break;
 194                 case CDC_PARITY_Even:
 195                         ConfigMask = (1 << UPM11);
 196                         break;
 197         }
 198
 199         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 200           ConfigMask |= (1 << USBS1);
 201
 202         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 203         {
 204                 case 6:
 205                         ConfigMask |= (1 << UCSZ10);
 206                         break;
 207                 case 7:
 208                         ConfigMask |= (1 << UCSZ11);
 209                         break;
 210                 case 8:
 211                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 212                         break;
 213         }
 214
 215         UCSR1A = (1 << U2X1);
 216         UCSR1B = ((1 << TXEN1) | (1 << RXEN1));
 217         UCSR1C = ConfigMask;
 218         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 219 }
 220
 221 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 222  *
 223  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 224  */
 225 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 226 {
 227         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 228         if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 229         {
 230                 AVR_RESET_LINE_DDR  |= AVR_RESET_LINE_MASK;
 231                 AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 232
 233                 ResetPulseMSRemaining = AVR_RESET_PULSE_MS;
 234         }
 235 }