forksand
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Massive cleanups to the incomplete BluetoothHost demo, to make the HCL layer code much easier to read, block less and work correctly.

Browse Source
pull/1469/head
Dean Camera 14 years ago
parent c9148f9b47
commit a2e6d54336
6 changed files with 167 additions and 257 deletions
Show Stats Download Patch File Download Diff File

3
Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c
Unescape View File

@ -179,6 +179,9 @@ void Bluetooth_Management_Task(void)
}
puts_P(PSTR("Bluetooth Dongle Enumerated.\r\n"));
/* Initialize the Bluetooth stack */
Bluetooth_State_Init();
USB_HostState = HOST_STATE_Configured;
break;

337
Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothHCICommands.c
Unescape View File

@ -34,6 +34,7 @@ static Bluetooth_HCICommand_Header_t HCICommandHeader;
static Bluetooth_HCIEvent_Header_t HCIEventHeader;
uint8_t Bluetooth_HCIProcessingState;
uint8_t Bluetooth_HCINextState;
static uint8_t Bluetooth_TempDeviceAddress[6];
static uint8_t Bluetooth_SendHCICommand(void* Parameters, uint8_t ParamLength)
@ -56,51 +57,92 @@ static uint8_t Bluetooth_SendHCICommand(void* Parameters, uint8_t ParamLength)
memcpy(&CommandBuffer[sizeof(HCICommandHeader)], Parameters, ParamLength);
Pipe_SelectPipe(PIPE_CONTROLPIPE);
return USB_Host_SendControlRequest(CommandBuffer);
}
static bool Bluetooth_GetNextHCIEventHeader(void)
{
Pipe_SelectPipe(BLUETOOTH_EVENTS_PIPE);
Pipe_Unfreeze();
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_Freeze();
return false;
}
Pipe_Read_Stream_LE(&HCIEventHeader, sizeof(HCIEventHeader));
Pipe_Freeze();
return true;
}
static void Bluetooth_DiscardRemainingHCIEventParameters(void)
{
Pipe_SelectPipe(BLUETOOTH_EVENTS_PIPE);
Pipe_Unfreeze();
Pipe_Discard_Stream(HCIEventHeader.ParameterLength);
Pipe_ClearIN();
Pipe_Freeze();
HCIEventHeader.ParameterLength = 0;
}
void Bluetooth_ProcessHCICommands(void)
{
uint8_t ErrorCode;
switch (Bluetooth_HCIProcessingState)
{
case Bluetooth_Init:
case Bluetooth_ProcessEvents:
Pipe_SelectPipe(BLUETOOTH_EVENTS_PIPE);
Pipe_Unfreeze();
if (Pipe_IsReadWriteAllowed())
{
Pipe_Read_Stream_LE(&HCIEventHeader, sizeof(HCIEventHeader));
uint8_t EventParams[HCIEventHeader.ParameterLength];
Pipe_Read_Stream_LE(&EventParams, HCIEventHeader.ParameterLength);
Pipe_ClearIN();
BT_DEBUG("(HCI) Event Code: 0x%02X", HCIEventHeader.EventCode);
switch (HCIEventHeader.EventCode)
{
case EVENT_COMMAND_COMPLETE:
Bluetooth_HCIProcessingState = Bluetooth_HCINextState;
BT_DEBUG("(HCI) >> Command Complete (Opcode 0x%04x)",
((Bluetooth_HCIEvent_CommandComplete_t*)&EventParams)->Opcode);
break;
case EVENT_COMMAND_STATUS:
if (((Bluetooth_HCIEvent_CommandStatus_t*)&EventParams)->Status)
Bluetooth_HCIProcessingState = Bluetooth_Init;
BT_DEBUG("(HCI) >> Command Status: 0x%02X",
((Bluetooth_HCIEvent_CommandStatus_t*)&EventParams)->Status);
break;
case EVENT_CONNECTION_REQUEST:
memcpy(Bluetooth_TempDeviceAddress,
&((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->RemoteAddress,
sizeof(Bluetooth_TempDeviceAddress));
Bluetooth_HCIProcessingState = (Bluetooth_Connection.IsConnected ||
(((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->LinkType != 0x01)) ?
Bluetooth_Conn_RejectConnection : Bluetooth_Conn_AcceptConnection;
BT_DEBUG("(HCI) >> Connection Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
break;
case EVENT_PIN_CODE_REQUEST:
memcpy(Bluetooth_TempDeviceAddress,
&((Bluetooth_HCIEvent_PinCodeRequest_t*)&EventParams)->RemoteAddress,
sizeof(Bluetooth_TempDeviceAddress));
Bluetooth_HCIProcessingState = Bluetooth_Conn_SendPINCode;
BT_DEBUG("(HCI) >> PIN Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
break;
case EVENT_CONNECTION_COMPLETE:
memcpy(Bluetooth_Connection.RemoteAddress,
&((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->RemoteAddress,
sizeof(Bluetooth_TempDeviceAddress));
Bluetooth_Connection.ConnectionHandle = ((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->ConnectionHandle;
Bluetooth_Connection.IsConnected = true;
BT_DEBUG("(HCI) >> Connection Complete to Device %02X:%02X:%02X:%02X:%02X:%02X, Handle 0x%04x",
Bluetooth_Connection.RemoteAddress[5], Bluetooth_Connection.RemoteAddress[4],
Bluetooth_Connection.RemoteAddress[3], Bluetooth_Connection.RemoteAddress[2],
Bluetooth_Connection.RemoteAddress[1], Bluetooth_Connection.RemoteAddress[0],
Bluetooth_Connection.ConnectionHandle);
break;
}
}
Pipe_Freeze();
break;
case Bluetooth_Init:
memset(&Bluetooth_Connection, 0x00, sizeof(Bluetooth_Connection));
Bluetooth_HCIProcessingState = Bluetooth_Init_Reset;
break;
case Bluetooth_Init_Reset:
@ -113,19 +155,9 @@ void Bluetooth_ProcessHCICommands(void)
BT_DEBUG("(HCI) Enter State: Bluetooth_Init_Reset", NULL);
ErrorCode = Bluetooth_SendHCICommand(NULL, 0);
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_Init_ReadBufferSize;
Bluetooth_HCINextState = Bluetooth_Init_ReadBufferSize;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Init_ReadBufferSize:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
@ -138,46 +170,8 @@ void Bluetooth_ProcessHCICommands(void)
ErrorCode = Bluetooth_SendHCICommand(NULL, 0);
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_Init_SetEventMask;
break;
case Bluetooth_Init_SetEventMask:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
{
OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_SET_EVENT_MASK},
ParameterLength: 8,
};
BT_DEBUG("(HCI) Enter State: Bluetooth_Init_SetEventMask", NULL);
uint8_t EventMask[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
ErrorCode = Bluetooth_SendHCICommand(&EventMask, 8);
BT_DEBUG("(HCI) -- Event mask: 0x%02X%02X%02X%02X%02X%02X%02X%02X", EventMask[7], EventMask[6], EventMask[5], EventMask[4],
EventMask[3], EventMask[2], EventMask[1], EventMask[0]);
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_Init_SetLocalName;
Bluetooth_HCINextState = Bluetooth_Init_SetLocalName;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Init_SetLocalName:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
@ -190,19 +184,9 @@ void Bluetooth_ProcessHCICommands(void)
BT_DEBUG("(HCI) -- Name: %s", Bluetooth_DeviceConfiguration.Name);
ErrorCode = Bluetooth_SendHCICommand(Bluetooth_DeviceConfiguration.Name, strlen(Bluetooth_DeviceConfiguration.Name));
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_Init_SetDeviceClass;
Bluetooth_HCINextState = Bluetooth_Init_SetDeviceClass;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Init_SetDeviceClass:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
@ -215,18 +199,8 @@ void Bluetooth_ProcessHCICommands(void)
ErrorCode = Bluetooth_SendHCICommand(&Bluetooth_DeviceConfiguration.Class, 3);
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_Init_WriteScanEnable;
Bluetooth_HCINextState = Bluetooth_Init_WriteScanEnable;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Init_WriteScanEnable:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
@ -239,168 +213,65 @@ void Bluetooth_ProcessHCICommands(void)
uint8_t Interval = InquiryAndPageScans;
ErrorCode = Bluetooth_SendHCICommand(&Interval, 1);
do
{
while (!(Bluetooth_GetNextHCIEventHeader()))
{
if (USB_HostState == HOST_STATE_Unattached)
return;
}
Bluetooth_DiscardRemainingHCIEventParameters();
} while (HCIEventHeader.EventCode != EVENT_COMMAND_COMPLETE);
Bluetooth_HCIProcessingState = Bluetooth_PrepareToProcessEvents;
break;
case Bluetooth_PrepareToProcessEvents:
BT_DEBUG("(HCI) Enter State: Bluetooth_ProcessEvents", NULL);
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_ProcessEvents:
if (Bluetooth_GetNextHCIEventHeader())
{
BT_DEBUG("(HCI) Event Code: 0x%02X", HCIEventHeader.EventCode);
if (HCIEventHeader.EventCode == EVENT_COMMAND_STATUS)
{
Bluetooth_HCIEvent_CommandStatus_Header_t CommandStatusHeader;
Pipe_Read_Stream_LE(&CommandStatusHeader, sizeof(CommandStatusHeader));
HCIEventHeader.ParameterLength -= sizeof(CommandStatusHeader);
BT_DEBUG("(HCI) >> Command status: 0x%02X", CommandStatusHeader.CommandStatus);
if (CommandStatusHeader.CommandStatus)
Bluetooth_HCIProcessingState = Bluetooth_Init;
}
else if (HCIEventHeader.EventCode == EVENT_CONNECTION_REQUEST)
{
Bluetooth_HCIEvent_ConnectionRequest_Header_t ConnectionRequestParams;
Pipe_Read_Stream_LE(&ConnectionRequestParams, sizeof(ConnectionRequestParams));
HCIEventHeader.ParameterLength -= sizeof(ConnectionRequestParams);
BT_DEBUG("(HCI) >> Connection Request from device %02X:%02X:%02X:%02X:%02X:%02X",
ConnectionRequestParams.RemoteAddress[5], ConnectionRequestParams.RemoteAddress[4],
ConnectionRequestParams.RemoteAddress[3], ConnectionRequestParams.RemoteAddress[2],
ConnectionRequestParams.RemoteAddress[1], ConnectionRequestParams.RemoteAddress[0]);
BT_DEBUG("(HCI) -- Device Class: 0x%02X%04X", ConnectionRequestParams.ClassOfDevice_Service,
ConnectionRequestParams.ClassOfDevice_MajorMinor);
BT_DEBUG("(HCI) -- Link Type: 0x%02x", ConnectionRequestParams.LinkType);
memcpy(Bluetooth_TempDeviceAddress, ConnectionRequestParams.RemoteAddress,
sizeof(Bluetooth_TempDeviceAddress));
Bluetooth_HCIProcessingState = (Bluetooth_Connection.IsConnected) ? Bluetooth_Conn_RejectConnection :
Bluetooth_Conn_AcceptConnection;
}
else if (HCIEventHeader.EventCode == EVENT_DISCONNECTION_COMPLETE)
{
BT_DEBUG("(HCI) >> Disconnection from device complete.", NULL);
Bluetooth_HCIProcessingState = Bluetooth_Init;
}
else if (HCIEventHeader.EventCode == EVENT_CONNECTION_COMPLETE)
{
Bluetooth_HCIEvent_ConnectionComplete_Header_t ConnectionCompleteParams;
Pipe_Read_Stream_LE(&ConnectionCompleteParams, sizeof(ConnectionCompleteParams));
HCIEventHeader.ParameterLength -= sizeof(ConnectionCompleteParams);
BT_DEBUG("(HCI) >> Connection to device complete.", NULL);
BT_DEBUG("(HCI) -- Status: %d", ConnectionCompleteParams.Status);
BT_DEBUG("(HCI) -- Handle: %d", ConnectionCompleteParams.ConnectionHandle);
if (ConnectionCompleteParams.Status == 0x00)
{
memcpy(Bluetooth_Connection.DeviceAddress, ConnectionCompleteParams.RemoteAddress,
sizeof(Bluetooth_Connection.DeviceAddress));
Bluetooth_Connection.ConnectionHandle = ConnectionCompleteParams.ConnectionHandle;
Bluetooth_Connection.IsConnected = true;
}
}
else if (HCIEventHeader.EventCode == EVENT_PIN_CODE_REQUEST)
{
Pipe_Read_Stream_LE(&Bluetooth_TempDeviceAddress, sizeof(Bluetooth_TempDeviceAddress));
HCIEventHeader.ParameterLength -= sizeof(Bluetooth_TempDeviceAddress);
BT_DEBUG("(HCI) >> PIN code Request from device %02X:%02X:%02X:%02X:%02X:%02X",
Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
Bluetooth_HCIProcessingState = Bluetooth_Conn_SendPINCode;
}
else if (HCIEventHeader.EventCode == EVENT_COMMAND_COMPLETE)
{
BT_DEBUG("(HCI) >> Command Complete", NULL);
}
BT_DEBUG("(HCI) -- Unread Event Param Length: %d", HCIEventHeader.ParameterLength);
Bluetooth_DiscardRemainingHCIEventParameters();
}
Bluetooth_HCINextState = Bluetooth_ProcessEvents;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Conn_AcceptConnection:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
{
OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_ACCEPT_CONNECTION_REQUEST},
ParameterLength: sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_Params_t),
ParameterLength: sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t),
};
BT_DEBUG("(HCI) Enter State: Bluetooth_Conn_AcceptConnection", NULL);
Bluetooth_HCICommand_AcceptConnectionRequest_Params_t AcceptConnectionParams;
memcpy(AcceptConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress,
sizeof(Bluetooth_TempDeviceAddress));
Bluetooth_HCICommand_AcceptConnectionRequest_t AcceptConnectionParams;
memcpy(AcceptConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(Bluetooth_TempDeviceAddress));
AcceptConnectionParams.SlaveRole = true;
Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(AcceptConnectionParams));
ErrorCode = Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(AcceptConnectionParams));
Bluetooth_HCIProcessingState = Bluetooth_PrepareToProcessEvents;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Conn_RejectConnection:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
{
OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_ACCEPT_CONNECTION_REQUEST},
ParameterLength: sizeof(Bluetooth_HCICommand_RejectConnectionRequest_Params_t),
OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_REJECT_CONNECTION_REQUEST},
ParameterLength: sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t),
};
BT_DEBUG("(HCI) Enter State: Bluetooth_Conn_RejectConnection", NULL);
Bluetooth_HCICommand_RejectConnectionRequest_Params_t RejectConnectionParams;
Bluetooth_HCICommand_RejectConnectionRequest_t RejectConnectionParams;
memcpy(RejectConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress,
sizeof(Bluetooth_TempDeviceAddress));
memcpy(RejectConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(RejectConnectionParams.RemoteAddress));
RejectConnectionParams.Reason = ERROR_LIMITED_RESOURCES;
Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(AcceptConnectionParams));
ErrorCode = Bluetooth_SendHCICommand(&RejectConnectionParams, sizeof(RejectConnectionParams));
Bluetooth_HCIProcessingState = Bluetooth_PrepareToProcessEvents;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
case Bluetooth_Conn_SendPINCode:
HCICommandHeader = (Bluetooth_HCICommand_Header_t)
{
OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_PIN_CODE_REQUEST_REPLY},
ParameterLength: sizeof(Bluetooth_HCICommand_PinCodeResponse_Params_t),
ParameterLength: sizeof(Bluetooth_HCICommand_PinCodeResponse_t),
};
BT_DEBUG("(HCI) Enter State: Bluetooth_Conn_SendPINCode", NULL);
BT_DEBUG("(HCI) -- PIN: %s", Bluetooth_DeviceConfiguration.PINCode);
Bluetooth_HCICommand_PinCodeResponse_Params_t PINCodeRequestParams;
Bluetooth_HCICommand_PinCodeResponse_t PINCodeRequestParams;
memcpy(PINCodeRequestParams.RemoteAddress, Bluetooth_TempDeviceAddress,
sizeof(Bluetooth_TempDeviceAddress));
memcpy(PINCodeRequestParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(Bluetooth_TempDeviceAddress));
PINCodeRequestParams.PINCodeLength = strlen(Bluetooth_DeviceConfiguration.PINCode);
memcpy(PINCodeRequestParams.PINCode, Bluetooth_DeviceConfiguration.PINCode,
sizeof(Bluetooth_DeviceConfiguration.PINCode));
memcpy(PINCodeRequestParams.PINCode, Bluetooth_DeviceConfiguration.PINCode, sizeof(PINCodeRequestParams.PINCode));
Bluetooth_SendHCICommand(&PINCodeRequestParams, sizeof(PINCodeRequestParams));
ErrorCode = Bluetooth_SendHCICommand(&PINCodeRequestParams, sizeof(PINCodeRequestParams));
Bluetooth_HCIProcessingState = Bluetooth_PrepareToProcessEvents;
Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
break;
}
}

48
Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothHCICommands.h
Unescape View File

@ -103,23 +103,30 @@
typedef struct
{
uint8_t CommandStatus;
uint8_t CommandPackets;
uint8_t Status;
uint8_t Packets;
struct
{
int OCF : 10;
int OGF : 6;
} OpCode;
} Bluetooth_HCIEvent_CommandStatus_Header_t;
} Bluetooth_HCIEvent_CommandStatus_t;
typedef struct
{
uint8_t HCLPacketsAllowable;
uint16_t Opcode;
uint8_t ReturnParams[];
} Bluetooth_HCIEvent_CommandComplete_t;
typedef struct
{
uint8_t RemoteAddress[6];
uint8_t ClassOfDevice_Service;
uint16_t ClassOfDevice_MajorMinor;
uint8_t LinkType;
} Bluetooth_HCIEvent_ConnectionRequest_Header_t;
} Bluetooth_HCIEvent_ConnectionRequest_t;
typedef struct
{
@ -128,26 +135,31 @@
uint8_t RemoteAddress[6];
uint8_t LinkType;
uint8_t EncryptionEnabled;
} Bluetooth_HCIEvent_ConnectionComplete_Header_t;
} Bluetooth_HCIEvent_ConnectionComplete_t;
typedef struct
{
uint8_t RemoteAddress[6];
} Bluetooth_HCIEvent_PinCodeRequest_t;
typedef struct
{
uint8_t RemoteAddress[6];
uint8_t SlaveRole;
} Bluetooth_HCICommand_AcceptConnectionRequest_Params_t;
} Bluetooth_HCICommand_AcceptConnectionRequest_t;
typedef struct
{
uint8_t RemoteAddress[6];
uint8_t Reason;
} Bluetooth_HCICommand_RejectConnectionRequest_Params_t;
} Bluetooth_HCICommand_RejectConnectionRequest_t;
typedef struct
{
uint8_t RemoteAddress[6];
uint8_t PINCodeLength;
char PINCode[16];
} Bluetooth_HCICommand_PinCodeResponse_Params_t;
} Bluetooth_HCICommand_PinCodeResponse_t;
/* Enums: */
enum Bluetooth_ScanEnable_Modes_t
@ -160,18 +172,16 @@
enum BluetoothStack_States_t
{
Bluetooth_Init = 0,
Bluetooth_Init_Reset = 1,
Bluetooth_Init_ReadBufferSize = 2,
Bluetooth_Init_SetEventMask = 3,
Bluetooth_ProcessEvents = 0,
Bluetooth_Init = 1,
Bluetooth_Init_Reset = 2,
Bluetooth_Init_ReadBufferSize = 3,
Bluetooth_Init_SetLocalName = 4,
Bluetooth_Init_SetDeviceClass = 5,
Bluetooth_Init_WriteScanEnable = 6,
Bluetooth_PrepareToProcessEvents = 7,
Bluetooth_ProcessEvents = 8,
Bluetooth_Conn_AcceptConnection = 9,
Bluetooth_Conn_RejectConnection = 10,
Bluetooth_Conn_SendPINCode = 11,
Bluetooth_Conn_AcceptConnection = 7,
Bluetooth_Conn_RejectConnection = 8,
Bluetooth_Conn_SendPINCode = 9,
};
/* External Variables: */
@ -179,12 +189,10 @@
/* Function Prototypes: */
void Bluetooth_ProcessHCICommands(void);
void Bluetooth_ProcessHCIEvents(void);
#if defined(INCLUDE_FROM_BLUETOOTHHCICOMMANDS_C)
static uint8_t Bluetooth_SendHCICommand(void* Parameters, uint8_t ParamLength);
static bool Bluetooth_GetNextHCIEventHeader(void);
static void Bluetooth_DiscardRemainingHCIEventParameters(void);
static void Bluetooth_ProcessHCICommands(void);
#endif
#endif

8
Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothStack.c
Unescape View File

@ -39,11 +39,13 @@ Bluetooth_Device_t Bluetooth_DeviceConfiguration ATTR_WEAK =
Name: "LUFA BT Device"
};
void Bluetooth_State_Init(void)
{
Bluetooth_HCIProcessingState = Bluetooth_Init;
}
void Bluetooth_Stack_Task(void)
{
if (USB_HostState != HOST_STATE_Configured)
Bluetooth_HCIProcessingState = Bluetooth_Init;
Bluetooth_ProcessHCICommands();
Bluetooth_ProcessACLPackets();
}

3
Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothStack.h
Unescape View File

@ -72,7 +72,7 @@
{
bool IsConnected;
uint16_t ConnectionHandle;
uint8_t DeviceAddress[6];
uint8_t RemoteAddress[6];
Bluetooth_Channel_t Channels[BLUETOOTH_MAX_OPEN_CHANNELS];
} Bluetooth_Connection_t;
@ -87,6 +87,7 @@
Bluetooth_Channel_t* Bluetooth_GetChannelData(uint16_t ChannelNumber, bool SearchBySource);
Bluetooth_Channel_t* Bluetooth_InitChannelData(uint16_t RemoteChannelNumber, uint16_t PSM);
void Bluetooth_State_Init(void);
void Bluetooth_Stack_Task(void);
/* External Variables: */

25
LUFA/ManPages/AlternativeStacks.txt
Unescape View File

@ -10,6 +10,10 @@
* LUFA is not the only stack available for the USB AVRs, although it is perhaps the best (see \ref Page_WhyUseLUFA).
* In the interests of completeness and user choice, other known USB AVR stacks are listed here.
*
* \section Sec_HardwareStacks Hardware USB AVR Stacks
* These are the known alternative USB stacks which are designed for and run exclusively on the USB AVR series microcontrollers,
* which contain on-chip USB controller hardware for maximum features and speed.
*
* - <b>Name:</b> Atmel USB AVR Stack (<i>Atmel Inc.</i>) \n
* <b>Cost:</b> Free \n
* <b>License:</b> Atmel Limited License (see Atmel download for details) \n
@ -33,5 +37,26 @@
* designed for the PJRC Teensy line of USB AVRs, and thus may need to be modified for other USB AVR
* chips. These minimal code samples shows the inner workings of the USB controller, without all the
* abstraction present in most other USB AVR stacks.
*
* \section Sec_SoftwareStacks Software AVR Stacks
* These are the known alternative USB stacks which can run on regular AVR models, lacking dedicated hardware USB controllers
* via a bit-banged (emulated) version of the USB protocol. They are limited in their capabilities due to the cycles required
* to be dedicated to managing the USB bus, but offer a cheap way to implement USB functionality into a design.
*
* - <b>Name:</b> AVR309: Software USB (<i>Objective Development</i>) \n
* <b>Cost:</b> Free for some uses, see website for licensing \n
* <b>License:</b> None Stated \n
* <b>Website:</b> http://www.atmel.com/dyn/Products/app_notes.asp?family_id=607 \n
* <b>Description:</b> Atmel's official software USB implementation, an Application Note containing work by Igor Cesko. This
* is a minimal assembly-only implementation of software USB, providing HID functionality. Less compile
* options than V-USB (see below).
*
* - <b>Name:</b> V-USB (<i>Objective Development</i>) \n
* <b>Cost:</b> Free for some uses, see website for licensing \n
* <b>License:</b> Dual GPL2/Custom \n
* <b>Website:</b> http://www.obdev.at/products/vusb/index.html \n
* <b>Description:</b> Well regarded and complete USB 1.1 software stack for several AVR models, implementing Low Speed HID.
* Used in many commercial and non-commercial designs, with user-submitted projects available for viewing
* on the company's website. Uses C language code mixed with assembly for time-critical sections.
*/
Write Preview
Loading…
Cancel
Save