Demos/Host/LowLevel/PrinterHost/PrinterHost.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 PrinterHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "PrinterHost.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  starts the scheduler to run the application tasks.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  47
  48         puts_P(PSTR(ESC_FG_CYAN "Printer Host Demo running.\r\n" ESC_FG_WHITE));
  49
  50         for (;;)
  51         {
  52                 USB_Printer_Host();
  53                 USB_USBTask();
  54         }
  55 }
  56
  57 void SetupHardware(void)
  58 {
  59         /* Disable watchdog if enabled by bootloader/fuses */
  60         MCUSR &= ~(1 << WDRF);
  61         wdt_disable();
  62
  63         /* Disable clock division */
  64         clock_prescale_set(clock_div_1);
  65
  66         /* Hardware Initialization */
  67         SerialStream_Init(9600, false);
  68         LEDs_Init();
  69         USB_Init();
  70 }
  71
  72 void EVENT_USB_DeviceAttached(void)
  73 {
  74         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  75         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  76 }
  77
  78 void EVENT_USB_DeviceUnattached(void)
  79 {
  80         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  81         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  82 }
  83
  84 void EVENT_USB_HostError(uint8_t ErrorCode)
  85 {
  86         USB_ShutDown();
  87
  88         puts_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"));
  89         printf_P(PSTR(" -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
  90
  91         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  92         for(;;);
  93 }
  94
  95 void EVENT_USB_DeviceEnumerationFailed(uint8_t ErrorCode, uint8_t SubErrorCode)
  96 {
  97         puts_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"));
  98         printf_P(PSTR(" -- Error Code %d\r\n"), ErrorCode);
  99         printf_P(PSTR(" -- In State %d\r\n" ESC_FG_WHITE), USB_HostState);
 100
 101         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 102 }
 103
 104 void EVENT_USB_DeviceEnumerationComplete(void)
 105 {
 106         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 107 }
 108
 109 void USB_Printer_Host(void)
 110 {
 111         uint8_t ErrorCode;
 112
 113         switch (USB_HostState)
 114         {
 115                 case HOST_STATE_Addressed:
 116                         puts_P(PSTR("Getting Config Data.\r\n"));
 117
 118                         /* Select the control pipe for the request transfer */
 119                         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 120
 121                         /* Get and process the configuration descriptor data */
 122                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 123                         {
 124                                 if (ErrorCode == ControlError)
 125                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 126                                 else
 127                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 128
 129                                 printf_P(PSTR(" -- Error Code: %d\r\n"), ErrorCode);
 130
 131                                 /* Indicate error via status LEDs */
 132                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 133
 134                                 /* Wait until USB device disconnected */
 135                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 136                                 break;
 137                         }
 138
 139                         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 140                         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 141                         {
 142                                 puts_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"));
 143                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 144
 145                                 /* Indicate error via status LEDs */
 146                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 147
 148                                 /* Wait until USB device disconnected */
 149                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 150                                 break;
 151                         }
 152
 153                         /* Some printers use alternate settings to determine the communication protocol used - if so, send a SetInterface
 154                          * request to switch to the interface alternate setting with the Bidirectional protocol */
 155                         if (PrinterAltSetting)
 156                         {
 157                                 USB_ControlRequest = (USB_Request_Header_t)
 158                                         {
 159                                                 bmRequestType: (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 160                                                 bRequest:      REQ_SetInterface,
 161                                                 wValue:        PrinterAltSetting,
 162                                                 wIndex:        PrinterInterfaceNumber,
 163                                                 wLength:       0,
 164                                         };
 165
 166                                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 167                                 {
 168                                         puts_P(PSTR(ESC_FG_RED "Control Error (Set Interface).\r\n"));
 169                                         printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 170
 171                                         /* Indicate error via status LEDs */
 172                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 173
 174                                         /* Wait until USB device disconnected */
 175                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 176                                         break;
 177                                 }
 178                         }
 179
 180                         USB_HostState = HOST_STATE_Configured;
 181                         break;
 182                 case HOST_STATE_Configured:
 183                         puts_P(PSTR("Retrieving Device ID...\r\n"));
 184
 185                         char DeviceIDString[256];
 186                         if ((ErrorCode = Printer_GetDeviceID(DeviceIDString, sizeof(DeviceIDString))) != HOST_SENDCONTROL_Successful)
 187                         {
 188                                 puts_P(PSTR(ESC_FG_RED "Control Error (Get DeviceID).\r\n"));
 189                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 190
 191                                 /* Indicate error via status LEDs */
 192                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 193
 194                                 /* Wait until USB device disconnected */
 195                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 196                                 break;
 197                         }
 198
 199                         printf_P(PSTR("Printer Device ID: %s\r\n"), DeviceIDString);
 200
 201                         puts_P(PSTR("Printer Enumerated.\r\n"));
 202
 203                         USB_HostState = HOST_STATE_Ready;
 204                         break;
 205                 case HOST_STATE_Ready:
 206                         /* Indicate device busy via the status LEDs */
 207                         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 208
 209                         Printer_Data_t TestPageData =
 210                                 {
 211 //                                      "\033%-12345X\033E LUFA PCL Test Page \033E\033%-12345X",
 212                                         "\033@\033i\001\033X\001\060\000\r\nLUFA ESCP/2 Test Page\r\n",
 213                                         (sizeof(TestPageData.Data) - 1)
 214                                 };
 215
 216                         printf_P(PSTR("Sending Test Page (%d bytes)...\r\n"), TestPageData.Length);
 217
 218                         if ((ErrorCode = Printer_SendData(&TestPageData)) != PIPE_RWSTREAM_NoError)
 219                         {
 220                                 puts_P(PSTR(ESC_FG_RED "Error Sending Test Page.\r\n"));
 221                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 222
 223                                 /* Indicate error via status LEDs */
 224                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 225
 226                                 /* Wait until USB device disconnected */
 227                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 228                                 break;
 229                         }
 230
 231                         puts_P(PSTR("Test Page Sent.\r\n"));
 232
 233                         /* Indicate device no longer busy */
 234                         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 235
 236                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 237                         break;
 238         }
 239 }