Demos/Host/LowLevel/CDCHost/CDCHost.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 CDCHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "CDCHost.h"
  38
  39 #if 0
  40 /* NOTE: Here you can set up a standard stream using the created virtual serial port, so that the standard stream functions in
  41  *       <stdio.h> can be used on the virtual serial port (e.g. fprintf(&USBSerial, "Test"); to print a string).
  42  */
  43
  44 static int CDC_putchar(char c, FILE *stream)
  45 {
  46         Pipe_SelectPipe(CDC_DATAPIPE_OUT);
  47
  48         if (Pipe_WaitUntilReady())
  49           return -1;
  50
  51         Pipe_Write_Byte(c);
  52         Pipe_ClearIN();
  53
  54         return 0;
  55 }
  56
  57 static int CDC_getchar(FILE *stream)
  58 {
  59         int c;
  60
  61         Pipe_SelectPipe(CDC_DATAPIPE_IN);
  62
  63         for (;;)
  64         {
  65                 if (Pipe_WaitUntilReady())
  66                   return -1;
  67
  68                 if (!(Pipe_BytesInPipe()))
  69                 {
  70                         Pipe_ClearOUT();
  71                 }
  72                 else
  73                 {
  74                         c = Pipe_Read_Byte();
  75                         break;
  76                 }
  77         }
  78
  79         return c;
  80 }
  81
  82 static FILE USBSerial = FDEV_SETUP_STREAM(CDC_putchar, CDC_getchar, _FDEV_SETUP_RW);
  83 #endif
  84
  85 /** Main program entry point. This routine configures the hardware required by the application, then
  86  *  enters a loop to run the application tasks in sequence.
  87  */
  88 int main(void)
  89 {
  90         SetupHardware();
  91
  92         puts_P(PSTR(ESC_FG_CYAN "CDC Host Demo running.\r\n" ESC_FG_WHITE));
  93
  94         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  95
  96         for (;;)
  97         {
  98                 CDC_Host_Task();
  99                 USB_USBTask();
 100         }
 101 }
 102
 103 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 104 void SetupHardware(void)
 105 {
 106         /* Disable watchdog if enabled by bootloader/fuses */
 107         MCUSR &= ~(1 << WDRF);
 108         wdt_disable();
 109
 110         /* Disable clock division */
 111         clock_prescale_set(clock_div_1);
 112
 113         /* Hardware Initialization */
 114         SerialStream_Init(9600, false);
 115         LEDs_Init();
 116         USB_Init();
 117 }
 118
 119 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 120  *  starts the library USB task to begin the enumeration and USB management process.
 121  */
 122 void EVENT_USB_Host_DeviceAttached(void)
 123 {
 124         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
 125         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 126 }
 127
 128 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 129  *  stops the library USB task management process.
 130  */
 131 void EVENT_USB_Host_DeviceUnattached(void)
 132 {
 133         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
 134         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 135 }
 136
 137 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 138  *  enumerated by the host and is now ready to be used by the application.
 139  */
 140 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 141 {
 142         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 143 }
 144
 145 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 146 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 147 {
 148         USB_ShutDown();
 149
 150         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 151                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 152
 153         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 154         for(;;);
 155 }
 156
 157 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 158  *  enumerating an attached USB device.
 159  */
 160 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 161 {
 162         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 163                                  " -- Error Code %d\r\n"
 164                                  " -- Sub Error Code %d\r\n"
 165                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 166
 167         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 168 }
 169
 170 /** Task to set the configuration of the attached device after it has been enumerated, and to read in
 171  *  data received from the attached CDC device and print it to the serial port.
 172  */
 173 void CDC_Host_Task(void)
 174 {
 175         uint8_t ErrorCode;
 176
 177         switch (USB_HostState)
 178         {
 179                 case HOST_STATE_Addressed:
 180                         puts_P(PSTR("Getting Config Data.\r\n"));
 181
 182                         /* Get and process the configuration descriptor data */
 183                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 184                         {
 185                                 if (ErrorCode == ControlError)
 186                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 187                                 else
 188                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 189
 190                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 191
 192                                 /* Indicate error via status LEDs */
 193                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 194
 195                                 /* Wait until USB device disconnected */
 196                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 197                                 break;
 198                         }
 199
 200                         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 201                         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 202                         {
 203                                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 204                                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 205
 206                                 /* Indicate error via status LEDs */
 207                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 208
 209                                 /* Wait until USB device disconnected */
 210                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 211                                 break;
 212                         }
 213
 214                         puts_P(PSTR("CDC Device Enumerated.\r\n"));
 215
 216                         USB_HostState = HOST_STATE_Configured;
 217                         break;
 218                 case HOST_STATE_Configured:
 219                         /* Select and the data IN pipe */
 220                         Pipe_SelectPipe(CDC_DATAPIPE_IN);
 221                         Pipe_Unfreeze();
 222
 223                         /* Check to see if a packet has been received */
 224                         if (Pipe_IsINReceived())
 225                         {
 226                                 /* Re-freeze IN pipe after the packet has been received */
 227                                 Pipe_Freeze();
 228
 229                                 /* Check if data is in the pipe */
 230                                 if (Pipe_IsReadWriteAllowed())
 231                                 {
 232                                         /* Get the length of the pipe data, and create a new buffer to hold it */
 233                                         uint16_t BufferLength = Pipe_BytesInPipe();
 234                                         uint8_t  Buffer[BufferLength];
 235
 236                                         /* Read in the pipe data to the temporary buffer */
 237                                         Pipe_Read_Stream_LE(Buffer, BufferLength);
 238
 239                                         /* Print out the buffer contents to the USART */
 240                                         for (uint16_t BufferByte = 0; BufferByte < BufferLength; BufferByte++)
 241                                           putchar(Buffer[BufferByte]);
 242                                 }
 243
 244                                 /* Clear the pipe after it is read, ready for the next packet */
 245                                 Pipe_ClearIN();
 246                         }
 247
 248                         /* Re-freeze IN pipe after use */
 249                         Pipe_Freeze();
 250
 251                         /* Select and unfreeze the notification pipe */
 252                         Pipe_SelectPipe(CDC_NOTIFICATIONPIPE);
 253                         Pipe_Unfreeze();
 254
 255                         /* Check if a packet has been received */
 256                         if (Pipe_IsINReceived())
 257                         {
 258                                 /* Discard the unused event notification */
 259                                 Pipe_ClearIN();
 260                         }
 261
 262                         /* Freeze notification IN pipe after use */
 263                         Pipe_Freeze();
 264
 265                         break;
 266         }
 267 }