lib/lufa/Demos/Device/ClassDriver/DualVirtualSerial/DualVirtualSerial.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2017.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2017  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 disclaims 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 DualVirtualSerial demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "DualVirtualSerial.h"
  38
  39 /** LUFA CDC Class driver interface configuration and state information. This structure is
  40  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  41  *  within a device can be differentiated from one another. This is for the first CDC interface,
  42  *  which sends strings to the host for each joystick movement.
  43  */
  44 USB_ClassInfo_CDC_Device_t VirtualSerial1_CDC_Interface =
  45         {
  46                 .Config =
  47                         {
  48                                 .ControlInterfaceNumber   = INTERFACE_ID_CDC1_CCI,
  49                                 .DataINEndpoint           =
  50                                         {
  51                                                 .Address          = CDC1_TX_EPADDR,
  52                                                 .Size             = CDC_TXRX_EPSIZE,
  53                                                 .Banks            = 1,
  54                                         },
  55                                 .DataOUTEndpoint =
  56                                         {
  57                                                 .Address          = CDC1_RX_EPADDR,
  58                                                 .Size             = CDC_TXRX_EPSIZE,
  59                                                 .Banks            = 1,
  60                                         },
  61                                 .NotificationEndpoint =
  62                                         {
  63                                                 .Address          = CDC1_NOTIFICATION_EPADDR,
  64                                                 .Size             = CDC_NOTIFICATION_EPSIZE,
  65                                                 .Banks            = 1,
  66                                         },
  67                         },
  68         };
  69
  70 /** LUFA CDC Class driver interface configuration and state information. This structure is
  71  *  passed to all CDC Class driver functions, so that multiple instances of the same class
  72  *  within a device can be differentiated from one another. This is for the second CDC interface,
  73  *  which echos back all received data from the host.
  74  */
  75 USB_ClassInfo_CDC_Device_t VirtualSerial2_CDC_Interface =
  76         {
  77                 .Config =
  78                         {
  79                                 .ControlInterfaceNumber   = INTERFACE_ID_CDC2_CCI,
  80                                 .DataINEndpoint           =
  81                                         {
  82                                                 .Address          = CDC2_TX_EPADDR,
  83                                                 .Size             = CDC_TXRX_EPSIZE,
  84                                                 .Banks            = 1,
  85                                         },
  86                                 .DataOUTEndpoint =
  87                                         {
  88                                                 .Address          = CDC2_RX_EPADDR,
  89                                                 .Size             = CDC_TXRX_EPSIZE,
  90                                                 .Banks            = 1,
  91                                         },
  92                                 .NotificationEndpoint =
  93                                         {
  94                                                 .Address          = CDC2_NOTIFICATION_EPADDR,
  95                                                 .Size             = CDC_NOTIFICATION_EPSIZE,
  96                                                 .Banks            = 1,
  97                                         },
  98
  99                         },
 100         };
 101
 102
 103 /** Main program entry point. This routine contains the overall program flow, including initial
 104  *  setup of all components and the main program loop.
 105  */
 106 int main(void)
 107 {
 108         SetupHardware();
 109
 110         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 111         GlobalInterruptEnable();
 112
 113         for (;;)
 114         {
 115                 CheckJoystickMovement();
 116
 117                 /* Discard all received data on the first CDC interface */
 118                 CDC_Device_ReceiveByte(&VirtualSerial1_CDC_Interface);
 119
 120                 /* Echo all received data on the second CDC interface */
 121                 int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial2_CDC_Interface);
 122                 if (!(ReceivedByte < 0))
 123                   CDC_Device_SendByte(&VirtualSerial2_CDC_Interface, (uint8_t)ReceivedByte);
 124
 125                 CDC_Device_USBTask(&VirtualSerial1_CDC_Interface);
 126                 CDC_Device_USBTask(&VirtualSerial2_CDC_Interface);
 127                 USB_USBTask();
 128         }
 129 }
 130
 131 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 132 void SetupHardware(void)
 133 {
 134 #if (ARCH == ARCH_AVR8)
 135         /* Disable watchdog if enabled by bootloader/fuses */
 136         MCUSR &= ~(1 << WDRF);
 137         wdt_disable();
 138
 139         /* Disable clock division */
 140         clock_prescale_set(clock_div_1);
 141 #elif (ARCH == ARCH_XMEGA)
 142         /* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
 143         XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
 144         XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
 145
 146         /* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
 147         XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
 148         XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
 149
 150         PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
 151 #endif
 152
 153         /* Hardware Initialization */
 154         Joystick_Init();
 155         LEDs_Init();
 156         USB_Init();
 157 }
 158
 159 /** Checks for changes in the position of the board joystick, sending strings to the host upon each change
 160  *  through the first of the CDC interfaces.
 161  */
 162 void CheckJoystickMovement(void)
 163 {
 164         uint8_t     JoyStatus_LCL = Joystick_GetStatus();
 165         char*       ReportString  = NULL;
 166         static bool ActionSent = false;
 167
 168         if (JoyStatus_LCL & JOY_UP)
 169           ReportString = "Joystick Up\r\n";
 170         else if (JoyStatus_LCL & JOY_DOWN)
 171           ReportString = "Joystick Down\r\n";
 172         else if (JoyStatus_LCL & JOY_LEFT)
 173           ReportString = "Joystick Left\r\n";
 174         else if (JoyStatus_LCL & JOY_RIGHT)
 175           ReportString = "Joystick Right\r\n";
 176         else if (JoyStatus_LCL & JOY_PRESS)
 177           ReportString = "Joystick Pressed\r\n";
 178         else
 179           ActionSent = false;
 180
 181         if ((ReportString != NULL) && (ActionSent == false))
 182         {
 183                 ActionSent = true;
 184
 185                 CDC_Device_SendString(&VirtualSerial1_CDC_Interface, ReportString);
 186         }
 187 }
 188
 189 /** Event handler for the library USB Connection event. */
 190 void EVENT_USB_Device_Connect(void)
 191 {
 192         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 193 }
 194
 195 /** Event handler for the library USB Disconnection event. */
 196 void EVENT_USB_Device_Disconnect(void)
 197 {
 198         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 199 }
 200
 201 /** Event handler for the library USB Configuration Changed event. */
 202 void EVENT_USB_Device_ConfigurationChanged(void)
 203 {
 204         bool ConfigSuccess = true;
 205
 206         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial1_CDC_Interface);
 207         ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial2_CDC_Interface);
 208
 209         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 210 }
 211
 212 /** Event handler for the library USB Control Request reception event. */
 213 void EVENT_USB_Device_ControlRequest(void)
 214 {
 215         CDC_Device_ProcessControlRequest(&VirtualSerial1_CDC_Interface);
 216         CDC_Device_ProcessControlRequest(&VirtualSerial2_CDC_Interface);
 217 }
 218
 219 /** CDC class driver callback function the processing of changes to the virtual
 220  *  control lines sent from the host..
 221  *
 222  *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
 223  */
 224 void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t *const CDCInterfaceInfo)
 225 {
 226         /* You can get changes to the virtual CDC lines in this callback; a common
 227            use-case is to use the Data Terminal Ready (DTR) flag to enable and
 228            disable CDC communications in your application when set to avoid the
 229            application blocking while waiting for a host to become ready and read
 230            in the pending data from the USB endpoints.
 231         */
 232         bool HostReady = (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR) != 0;
 233
 234         if (CDCInterfaceInfo == &VirtualSerial1_CDC_Interface)
 235         {
 236                 // CDC interface 1's host is ready to send/receive data
 237         }
 238         else
 239         {
 240                 // CDC interface 2's host is ready to send/receive data
 241         }
 242 }