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                           AVR_RESET_LINE_DDR &= ~AVR_RESET_LINE_MASK;
 109
 110                         /* Turn off TX LED(s) once the TX pulse period has elapsed */
 111                         if (TxPulseMSRemaining && !(--TxPulseMSRemaining))
 112                           LEDs_TurnOffLEDs(LEDMASK_TX);
 113
 114                         /* Turn off RX LED(s) once the RX pulse period has elapsed */
 115                         if (RxPulseMSRemaining && !(--RxPulseMSRemaining))
 116                           LEDs_TurnOffLEDs(LEDMASK_RX);
 117
 118                         /* Clear the millisecond timer CTC flag (cleared by writing logic one to the register) */
 119                         TIFR0 |= (1 << OCF0A);
 120                 }
 121
 122                 CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 123                 USB_USBTask();
 124         }
 125 }
 126
 127 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 128 void SetupHardware(void)
 129 {
 130         /* Disable watchdog if enabled by bootloader/fuses */
 131         MCUSR &= ~(1 << WDRF);
 132         wdt_disable();
 133
 134         /* Disable clock division */
 135         clock_prescale_set(clock_div_1);
 136
 137         /* Hardware Initialization */
 138         LEDs_Init();
 139         USB_Init();
 140
 141         /* Millisecond Timer Interrupt */
 142         OCR0A  = (F_CPU / 64 / 1000);
 143         TCCR0A = (1 << WGM01);
 144         TCCR0B = ((1 << CS01) | (1 << CS00));
 145
 146         /* Tristate target /RESET Line */
 147         AVR_RESET_LINE_PORT &= ~AVR_RESET_LINE_MASK;
 148         AVR_RESET_LINE_DDR  &= ~AVR_RESET_LINE_MASK;
 149 }
 150
 151 /** Event handler for the library USB Connection event. */
 152 void EVENT_USB_Connect(void)
 153 {
 154         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 155 }
 156
 157 /** Event handler for the library USB Disconnection event. */
 158 void EVENT_USB_Disconnect(void)
 159 {
 160         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 161 }
 162
 163 /** Event handler for the library USB Configuration Changed event. */
 164 void EVENT_USB_ConfigurationChanged(void)
 165 {
 166         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 167
 168         if (!(CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface)))
 169           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 170 }
 171
 172 /** Event handler for the library USB Unhandled Control Packet event. */
 173 void EVENT_USB_UnhandledControlPacket(void)
 174 {
 175         CDC_Device_ProcessControlPacket(&VirtualSerial_CDC_Interface);
 176 }
 177
 178 /** Event handler for the CDC Class driver Line Encoding Changed event.
 179  *
 180  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 181  */
 182 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 183 {
 184         uint8_t ConfigMask = 0;
 185
 186         switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
 187         {
 188                 case CDC_PARITY_Odd:
 189                         ConfigMask = ((1 << UPM11) | (1 << UPM10));
 190                         break;
 191                 case CDC_PARITY_Even:
 192                         ConfigMask = (1 << UPM11);
 193                         break;
 194         }
 195
 196         if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
 197           ConfigMask |= (1 << USBS1);
 198
 199         switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
 200         {
 201                 case 6:
 202                         ConfigMask |= (1 << UCSZ10);
 203                         break;
 204                 case 7:
 205                         ConfigMask |= (1 << UCSZ11);
 206                         break;
 207                 case 8:
 208                         ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
 209                         break;
 210         }
 211
 212         UCSR1A = (1 << U2X1);
 213         UCSR1B = ((1 << TXEN1) | (1 << RXEN1));
 214         UCSR1C = ConfigMask;
 215         UBRR1  = SERIAL_2X_UBBRVAL((uint16_t)CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
 216 }
 217
 218 /** Event handler for the CDC Class driver Host-to-Device Line Encoding Changed event.
 219  *
 220  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 221  */
 222 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 223 {
 224         /* Check if the DTR line has been asserted - if so, start the target AVR's reset pulse */
 225         if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 226         {
 227                 AVR_RESET_LINE_DDR |= AVR_RESET_LINE_MASK;
 228                 ResetPulseMSRemaining = AVR_RESET_PULSE_MS;
 229         }
 230 }