Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 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 BluetoothHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "BluetoothHost.h"
  38
  39 /** Bluetooth configuration structure. This structure configures the bluetooth stack's user alterable settings. */
  40 Bluetooth_Device_t Bluetooth_DeviceConfiguration =
  41         {
  42                 Class:   (DEVICE_CLASS_SERVICE_CAPTURING | DEVICE_CLASS_MAJOR_COMPUTER | DEVICE_CLASS_MINOR_COMPUTER_PALM),
  43                 PINCode: "0000",
  44                 Name:    "LUFA Bluetooth Demo"
  45         };
  46
  47 /** Main program entry point. This routine configures the hardware required by the application, then
  48  *  enters a loop to run the application tasks in sequence.
  49  */
  50 int main(void)
  51 {
  52         SetupHardware();
  53
  54         puts_P(PSTR(ESC_FG_CYAN "Bluetooth Host Demo running.\r\n" ESC_FG_WHITE));
  55
  56         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  57         sei();
  58
  59         for (;;)
  60         {
  61                 Bluetooth_Stack_USBTask();
  62                 Bluetooth_Host_Task();
  63                 USB_USBTask();
  64         }
  65 }
  66
  67 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  68 void SetupHardware(void)
  69 {
  70         /* Disable watchdog if enabled by bootloader/fuses */
  71         MCUSR &= ~(1 << WDRF);
  72         wdt_disable();
  73
  74         /* Disable clock division */
  75         clock_prescale_set(clock_div_1);
  76
  77         /* Hardware Initialization */
  78         SerialStream_Init(9600, false);
  79         LEDs_Init();
  80         USB_Init();
  81 }
  82
  83 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  84  *  starts the library USB task to begin the enumeration and USB management process.
  85  */
  86 void EVENT_USB_Host_DeviceAttached(void)
  87 {
  88         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  89         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  90 }
  91
  92 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  93  *  stops the library USB task management process.
  94  */
  95 void EVENT_USB_Host_DeviceUnattached(void)
  96 {
  97         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  98         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  99 }
 100
 101 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 102  *  enumerated by the host and is now ready to be used by the application.
 103  */
 104 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 105 {
 106         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 107 }
 108
 109 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 110 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 111 {
 112         USB_ShutDown();
 113
 114         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 115                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 116
 117         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 118         for(;;);
 119 }
 120
 121 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 122  *  enumerating an attached USB device.
 123  */
 124 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 125 {
 126         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 127                                  " -- Error Code %d\r\n"
 128                                  " -- Sub Error Code %d\r\n"
 129                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 130
 131         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 132 }
 133
 134 /** Task to set the configuration of the attached device after it has been enumerated. */
 135 void Bluetooth_Host_Task(void)
 136 {
 137         uint8_t ErrorCode;
 138
 139         switch (USB_HostState)
 140         {
 141                 case HOST_STATE_Addressed:
 142                         puts_P(PSTR("Getting Device Data.\r\n"));
 143
 144                         /* Get and process the configuration descriptor data */
 145                         if ((ErrorCode = ProcessDeviceDescriptor()) != SuccessfulDeviceRead)
 146                         {
 147                                 if (ErrorCode == DevControlError)
 148                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Device).\r\n"));
 149                                 else
 150                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 151
 152                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 153
 154                                 /* Indicate error via status LEDs */
 155                                 LEDs_SetAllLEDs(LEDS_LED1);
 156
 157                                 /* Wait until USB device disconnected */
 158                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 159                                 break;
 160                         }
 161
 162                         puts_P(PSTR("Bluetooth Dongle Detected.\r\n"));
 163
 164                         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 165                         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 166                         {
 167                                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 168                                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 169
 170                                 /* Indicate error via status LEDs */
 171                                 LEDs_SetAllLEDs(LEDS_LED1);
 172
 173                                 /* Wait until USB device disconnected */
 174                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 175                                 break;
 176                         }
 177
 178                         puts_P(PSTR("Getting Config Data.\r\n"));
 179
 180                         /* Get and process the configuration descriptor data */
 181                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 182                         {
 183                                 if (ErrorCode == ControlError)
 184                                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 185                                 else
 186                                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 187
 188                                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 189
 190                                 /* Indicate error via status LEDs */
 191                                 LEDs_SetAllLEDs(LEDS_LED1);
 192
 193                                 /* Wait until USB device disconnected */
 194                                 USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 195                                 break;
 196                         }
 197
 198                         puts_P(PSTR("Bluetooth Dongle Enumerated.\r\n"));
 199
 200                         /* Initialize the Bluetooth stack */
 201                         Bluetooth_Stack_Init();
 202
 203                         USB_HostState = HOST_STATE_Configured;
 204                         break;
 205         }
 206 }
 207
 208 /** Bluetooth stack callback event for when the Bluetooth stack has fully initialized using the attached
 209  *  Bluetooth dongle.
 210  */
 211 void Bluetooth_StackInitialized(void)
 212 {
 213         printf_P(PSTR("Stack initialized with local address %02X:%02X:%02X:%02X:%02X:%02X.\r\n"),
 214                  Bluetooth_State.LocalBDADDR[5], Bluetooth_State.LocalBDADDR[4], Bluetooth_State.LocalBDADDR[3],
 215                  Bluetooth_State.LocalBDADDR[2], Bluetooth_State.LocalBDADDR[1], Bluetooth_State.LocalBDADDR[0]);
 216 }
 217
 218 /** Bluetooth stack callback event for a Bluetooth connection request. When this callback fires, the
 219  *  user application must indicate if the connection is to be allowed or rejected.
 220  *
 221  *  \param[in] RemoteAddress  Bluetooth address of the remote device attempting the connection
 222  *
 223  *  \return Boolean true to accept the connection, false to reject it
 224  */
 225 bool Bluetooth_ConnectionRequest(const uint8_t* RemoteAddress)
 226 {
 227         printf_P(PSTR("Connection Request from Device %02X:%02X:%02X:%02X:%02X:%02X.\r\n"),
 228                  RemoteAddress[5], RemoteAddress[4], RemoteAddress[3], RemoteAddress[2],
 229                  RemoteAddress[1], RemoteAddress[0]);
 230
 231         /* Always accept connections from remote devices */
 232         return true;
 233 }
 234
 235 /** Bluetooth stack callback event for a completed Bluetooth connection. When this callback is made,
 236  *  the connection information can be accessed through the global \ref Bluetooth_Connection structure.
 237  */
 238 void Bluetooth_ConnectionComplete(void)
 239 {
 240         printf_P(PSTR("Connection Complete to Device %02X:%02X:%02X:%02X:%02X:%02X.\r\n"),
 241                  Bluetooth_Connection.RemoteAddress[5], Bluetooth_Connection.RemoteAddress[4],
 242                  Bluetooth_Connection.RemoteAddress[3], Bluetooth_Connection.RemoteAddress[2],
 243                  Bluetooth_Connection.RemoteAddress[1], Bluetooth_Connection.RemoteAddress[0]);
 244 }
 245
 246 /** Bluetooth stack callback event for a completed Bluetooth disconnection. When this callback is made,
 247  *  the connection information in the global \ref Bluetooth_Connection structure is invalidated with the
 248  *  exception of the RemoteAddress element, which can be used to determine the address of the device that
 249  *  was disconnected.
 250  */
 251 void Bluetooth_DisconnectionComplete(void)
 252 {
 253         printf_P(PSTR("Disconnection Complete to Device %02X:%02X:%02X:%02X:%02X:%02X.\r\n"),
 254                  Bluetooth_Connection.RemoteAddress[5], Bluetooth_Connection.RemoteAddress[4],
 255                  Bluetooth_Connection.RemoteAddress[3], Bluetooth_Connection.RemoteAddress[2],
 256                  Bluetooth_Connection.RemoteAddress[1], Bluetooth_Connection.RemoteAddress[0]);
 257 }
 258
 259 /** Bluetooth stack callback event for a Bluetooth ACL Channel connection request. When is callback fires,
 260  *  the user application must indicate if the channel connection should be rejected or not, based on the
 261  *  protocol (PSM) value of the requested channel.
 262  *
 263  *  \param PSM  Protocol PSM value for the requested channel
 264  *
 265  *  \return Boolean true to accept the channel connection request, false to reject it
 266  */
 267 bool Bluetooth_ChannelConnectionRequest(const uint16_t PSM)
 268 {
 269         /* Always accept channel connection requests regardless of PSM */
 270         return true;
 271 }
 272
 273 /** Bluetooth stack callback event for a non-signal ACL packet reception. This callback fires once a connection
 274  *  to a remote Bluetooth device has been made, and the remote device has sent a non-signalling ACL packet.
 275  *
 276  *  \param[in] Data    Pointer to a buffer where the received data is stored
 277  *  \param[in] DataLen Length of the packet data, in bytes
 278  *  \param[in] Channel Bluetooth ACL data channel information structure for the packet's destination channel
 279  */
 280 void Bluetooth_PacketReceived(void* Data, uint16_t DataLen, Bluetooth_Channel_t* const Channel)
 281 {
 282         switch (Channel->PSM)
 283         {
 284                 case CHANNEL_PSM_SDP:
 285                         /* Service Discovery Protocol packet */
 286                         ServiceDiscovery_ProcessPacket(Data, Channel);
 287                         break;
 288                 default:
 289                         /* Unknown Protocol packet */
 290                         printf_P(PSTR("Packet Received (Channel 0x%04X, PSM: 0x%02x):\r\n"), Channel->LocalNumber, Channel->PSM);
 291                         for (uint16_t Byte = 0; Byte < DataLen; Byte++)
 292                           printf_P(PSTR("0x%02X "), ((uint8_t*)Data)[Byte]);
 293                         puts_P(PSTR("\r\n"));
 294
 295                         break;
 296         }
 297 }