Add RFCOMM service routine, to send pending configuration requests on RFCOMM channels...

Add a new RFCOMM_SendChannelSignals() function to transmit a change in V24 terminal handshake lines to the receiving device.

Prevent SABM packets sent to the control DLCI in the RFCOMM layer from creating a new channel entry, as the control DLCI does not have connection data associated with it.

Fix up MSC control packet handling so that received responses can be acknowledged correctly, so that the RFCOMM layer can record when the receiving device has ACKed a sent change in V24 terminal handshake lines.

diff --git a/Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c b/Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c
index 66ed417..73b709d 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c
+++ b/Demos/Host/Incomplete/BluetoothHost/BluetoothHost.c
@@ -58,6 +58,12 @@ int main(void)
 
        for (;;)
        {
 
        for (;;)
        {

+               Bluetooth_Channel_t* RFCOMMChannel = Bluetooth_GetChannelData(CHANNEL_PSM_RFCOMM, CHANNEL_SEARCH_PSM);
+
+               /* If an RFCOMM channel is open, service the RFCOMM logical channels */
+               if (RFCOMMChannel)
+                 RFCOMM_ServiceChannels(RFCOMMChannel);
+

                Bluetooth_Stack_USBTask();
                Bluetooth_Host_Task();
                USB_USBTask();
                Bluetooth_Stack_USBTask();
                Bluetooth_Host_Task();
                USB_USBTask();


@@ -215,7 +221,6 @@ void Bluetooth_StackInitialized(void)
                 Bluetooth_State.LocalBDADDR[2], Bluetooth_State.LocalBDADDR[1], Bluetooth_State.LocalBDADDR[0]);
                         
        /* Reinitialize the services placed on top of the Bluetooth stack ready for new connections */
                 Bluetooth_State.LocalBDADDR[2], Bluetooth_State.LocalBDADDR[1], Bluetooth_State.LocalBDADDR[0]);
                         
        /* Reinitialize the services placed on top of the Bluetooth stack ready for new connections */

-       SDP_Initialize();

        RFCOMM_Initialize();
 }
 
        RFCOMM_Initialize();
 }
 


@@ -287,6 +292,7 @@ bool Bluetooth_ChannelConnectionRequest(const uint16_t PSM)
  */
 void Bluetooth_PacketReceived(void* Data, uint16_t DataLen, Bluetooth_Channel_t* const Channel)
 {
  */
 void Bluetooth_PacketReceived(void* Data, uint16_t DataLen, Bluetooth_Channel_t* const Channel)
 {

+       /* Run the correct packet handler based on the received packet's PSM, which indicates the service being carried */

        switch (Channel->PSM)
        {
                case CHANNEL_PSM_SDP:
        switch (Channel->PSM)
        {
                case CHANNEL_PSM_SDP:

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c
index c7b3e8d..271f2dc 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c
@@ -73,6 +73,32 @@ void RFCOMM_Initialize(void)
          RFCOMM_Channels[i].State = RFCOMM_Channel_Closed;
 }
 
          RFCOMM_Channels[i].State = RFCOMM_Channel_Closed;
 }
 

+void RFCOMM_ServiceChannels(Bluetooth_Channel_t* const BluetoothChannel)
+{
+       for (uint8_t i = 0; i < RFCOMM_MAX_OPEN_CHANNELS; i++)
+       {
+               RFCOMM_Channel_t* RFCOMMChannel = &RFCOMM_Channels[i];
+
+               if (RFCOMMChannel->State == RFCOMM_Channel_Configure)
+               {
+                       /* Check if the local signals have not yet been sent on the current channel */
+                       if (!(RFCOMMChannel->ConfigFlags & RFCOMM_CONFIG_LOCALSIGNALSSENT))
+                       {
+                               /* Indicate that the local signals have been sent, transmit them to the remote device */
+                               RFCOMMChannel->ConfigFlags |= RFCOMM_CONFIG_LOCALSIGNALSSENT;
+                               RFCOMM_SendChannelSignals(RFCOMMChannel, BluetoothChannel);
+                       }
+
+                       /* If signals have been configured in both directions, progress to the open state */
+                       if ((RFCOMMChannel->ConfigFlags & (RFCOMM_CONFIG_REMOTESIGNALS | RFCOMM_CONFIG_LOCALSIGNALS)) ==
+                                                         (RFCOMM_CONFIG_REMOTESIGNALS | RFCOMM_CONFIG_LOCALSIGNALS))
+                       {
+                               RFCOMMChannel->State = RFCOMM_Channel_Open;
+                       }
+               }
+       }
+}
+

 void RFCOMM_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel)
 {
        const RFCOMM_Header_t* FrameHeader  = (const RFCOMM_Header_t*)Data;
 void RFCOMM_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel)
 {
        const RFCOMM_Header_t* FrameHeader  = (const RFCOMM_Header_t*)Data;


@@ -103,6 +129,28 @@ void RFCOMM_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel)
        }
 }
 
        }
 }
 

+void RFCOMM_SendChannelSignals(const RFCOMM_Channel_t* const RFCOMMChannel, Bluetooth_Channel_t* const BluetoothChannel)
+{
+       BT_RFCOMM_DEBUG(1, ">> MSC Command");
+       BT_RFCOMM_DEBUG(2, "-- DLCI 0x%02X", RFCOMMChannel->DLCI);
+
+       struct
+       {
+               RFCOMM_Command_t        CommandHeader;
+               uint8_t                 Length;
+               RFCOMM_MSC_Parameters_t Params;
+       } MSCommand;
+       
+       MSCommand.CommandHeader      = (RFCOMM_Command_t){.Command = RFCOMM_Control_ModemStatus, .EA = true, .CR = true};
+       MSCommand.Length             = (sizeof(MSCommand.Params) << 1) | 0x01;
+       MSCommand.Params.Channel     = (RFCOMM_Address_t){.DLCI = RFCOMMChannel->DLCI, .EA = true, .CR = true};
+       MSCommand.Params.Signals     = RFCOMMChannel->Local.Signals;
+       MSCommand.Params.BreakSignal = RFCOMMChannel->Local.BreakSignal;
+
+       /* Send the MSC command to the remote device */
+       RFCOMM_SendFrame(RFCOMM_CONTROL_DLCI, true, RFCOMM_Frame_UIH, sizeof(MSCommand), &MSCommand, BluetoothChannel); 
+}
+

 RFCOMM_Channel_t* RFCOMM_GetChannelData(const uint8_t DLCI)
 {
        /* Search through the RFCOMM channel list, looking for the specified channel */
 RFCOMM_Channel_t* RFCOMM_GetChannelData(const uint8_t DLCI)
 {
        /* Search through the RFCOMM channel list, looking for the specified channel */


@@ -155,12 +203,7 @@ void RFCOMM_SendFrame(const uint8_t DLCI, const bool CommandResponse, const uint
        
        /* Set the frame header values to the specified address and frame type */
        ResponsePacket.FrameHeader.Control = Control;
        
        /* Set the frame header values to the specified address and frame type */
        ResponsePacket.FrameHeader.Control = Control;

-       ResponsePacket.FrameHeader.Address = (RFCOMM_Address_t)
-               {
-                       .EA   = true,
-                       .CR   = CommandResponse,
-                       .DLCI = DLCI,
-               };
+       ResponsePacket.FrameHeader.Address = (RFCOMM_Address_t){.DLCI = DLCI, .EA   = true, .CR = CommandResponse};

        
        /* Set the lower 7 bits of the packet length */
        ResponsePacket.Size[0] = (DataLen << 1);
        
        /* Set the lower 7 bits of the packet length */
        ResponsePacket.Size[0] = (DataLen << 1);


@@ -224,34 +267,46 @@ static void RFCOMM_ProcessSABM(const RFCOMM_Address_t* const FrameAddress, Bluet
 {
        BT_RFCOMM_DEBUG(1, "<< SABM Received");
        BT_RFCOMM_DEBUG(2, "-- DLCI 0x%02X", FrameAddress->DLCI);
 {
        BT_RFCOMM_DEBUG(1, "<< SABM Received");
        BT_RFCOMM_DEBUG(2, "-- DLCI 0x%02X", FrameAddress->DLCI);

+
+       RFCOMM_Channel_t* RFCOMMChannel;

        
        

-       /* Find a free entry in the RFCOMM channel multiplexer state array */
-       for (uint8_t i = 0; i < RFCOMM_MAX_OPEN_CHANNELS; i++)
+       if (FrameAddress->DLCI != RFCOMM_CONTROL_DLCI)

        {
        {

-               RFCOMM_Channel_t* CurrRFCOMMChannel = &RFCOMM_Channels[i];
-       
-               /* If the channel's state is closed, the channel state entry is free */
-               if (CurrRFCOMMChannel->State == RFCOMM_Channel_Closed)
+               /* Find a free entry in the RFCOMM channel multiplexer state array */
+               for (uint8_t i = 0; i < RFCOMM_MAX_OPEN_CHANNELS; i++)

                {
                {

-                       CurrRFCOMMChannel->DLCI     = FrameAddress->DLCI;
-                       CurrRFCOMMChannel->State    = RFCOMM_Channel_Open;
-                       CurrRFCOMMChannel->Priority = 7 + (CurrRFCOMMChannel->DLCI >> 3) + ((CurrRFCOMMChannel->DLCI >> 3) * 7);
-                       CurrRFCOMMChannel->MTU      = 0xFFFF;
-                       CurrRFCOMMChannel->Remote.Signals     = 0 | (1 << 0);
-                       CurrRFCOMMChannel->Remote.BreakSignal = 0 | (1 << 0);
-                       CurrRFCOMMChannel->Local.Signals      = RFCOMM_SIGNAL_RTC | RFCOMM_SIGNAL_RTR | RFCOMM_SIGNAL_DV | (1 << 0);
-                       CurrRFCOMMChannel->Local.BreakSignal  = 0 | (1 << 0);
-               
-                       BT_RFCOMM_DEBUG(1, ">> UA Sent");
-                       RFCOMM_SendFrame(FrameAddress->DLCI, true, (RFCOMM_Frame_UA | FRAME_POLL_FINAL), 0, NULL, Channel);
-                       return;
+                       /* If the channel's state is closed, the channel state entry is free */
+                       if (RFCOMM_Channels[i].State == RFCOMM_Channel_Closed)
+                       {
+                               RFCOMMChannel                     = &RFCOMM_Channels[i];
+                               RFCOMMChannel->DLCI               = FrameAddress->DLCI;
+                               RFCOMMChannel->State              = RFCOMM_Channel_Configure;
+                               RFCOMMChannel->Priority           = 7 + (RFCOMMChannel->DLCI & 0xF8);
+                               RFCOMMChannel->MTU                = 0xFFFF;
+                               RFCOMMChannel->Remote.Signals     = 0 | (1 << 0);
+                               RFCOMMChannel->Remote.BreakSignal = 0 | (1 << 0);
+                               RFCOMMChannel->Local.Signals      = RFCOMM_SIGNAL_RTC | RFCOMM_SIGNAL_RTR | RFCOMM_SIGNAL_DV | (1 << 0);
+                               RFCOMMChannel->Local.BreakSignal  = 0 | (1 << 0);
+                               RFCOMMChannel->ConfigFlags        = 0;
+                               break;
+                       }

                }
        }
                }
        }

+       
+       if (RFCOMMChannel || (FrameAddress->DLCI == RFCOMM_CONTROL_DLCI))
+       {
+               BT_RFCOMM_DEBUG(1, ">> UA Sent");
+               
+               /* Free channel found, or request was to the control channel - accept SABM by sending a UA frame */
+               RFCOMM_SendFrame(FrameAddress->DLCI, true, (RFCOMM_Frame_UA | FRAME_POLL_FINAL), 0, NULL, Channel);
+       }
+       else
+       {
+               BT_RFCOMM_DEBUG(1, ">> DM Sent");

 
 

-       BT_RFCOMM_DEBUG(1, ">> DM Sent");
-
-       /* No free channel in the multiplexer - decline the SABM by sending a DM frame */
-       RFCOMM_SendFrame(FrameAddress->DLCI, true, (RFCOMM_Frame_DM | FRAME_POLL_FINAL), 0, NULL, Channel);
+               /* No free channel in the multiplexer - decline the SABM by sending a DM frame */
+               RFCOMM_SendFrame(FrameAddress->DLCI, true, (RFCOMM_Frame_DM | FRAME_POLL_FINAL), 0, NULL, Channel);
+       }

 }
 
 static void RFCOMM_ProcessUA(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel)
 }
 
 static void RFCOMM_ProcessUA(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel)

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.h b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.h
index edd93f9..e7ed7ec 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.h
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.h
@@ -51,7 +51,7 @@
                
        /* Macros: */
                #define BT_RFCOMM_DEBUG(l, s, ...)              do { if (RFCOMM_DEBUG_LEVEL >= l) printf_P(PSTR("(RFCOMM) " s "\r\n"), ##__VA_ARGS__); } while (0)
                
        /* Macros: */
                #define BT_RFCOMM_DEBUG(l, s, ...)              do { if (RFCOMM_DEBUG_LEVEL >= l) printf_P(PSTR("(RFCOMM) " s "\r\n"), ##__VA_ARGS__); } while (0)

-               #define RFCOMM_DEBUG_LEVEL                      2
+               #define RFCOMM_DEBUG_LEVEL                      0

                
                #define FRAME_POLL_FINAL                        (1 << 4)
                
                
                #define FRAME_POLL_FINAL                        (1 << 4)
                


@@ -72,11 +72,8 @@
                enum RFCOMM_Channel_States_t
                {
                        RFCOMM_Channel_Closed      = 0,
                enum RFCOMM_Channel_States_t
                {
                        RFCOMM_Channel_Closed      = 0,

-                       RFCOMM_Channel_Create      = 1,
-                       RFCOMM_Channel_Creating    = 2,
-                       RFCOMM_Channel_Configure   = 3,
-                       RFCOMM_Channel_Configuring = 4,
-                       RFCOMM_Channel_Open        = 5,
+                       RFCOMM_Channel_Configure   = 1,
+                       RFCOMM_Channel_Open        = 2,

                };
                
        /* Type Defines: */
                };
                
        /* Type Defines: */


@@ -86,15 +83,16 @@
                        uint8_t  State;
                        uint8_t  Priority;
                        uint16_t MTU;
                        uint8_t  State;
                        uint8_t  Priority;
                        uint16_t MTU;

+                       uint8_t  ConfigFlags;

                        struct
                        {
                        struct
                        {

-                               uint8_t  Signals;
-                               uint8_t  BreakSignal;
+                               uint8_t Signals;
+                               uint8_t BreakSignal;

                        } Remote;
                        struct
                        {
                        } Remote;
                        struct
                        {

-                               uint8_t  Signals;
-                               uint8_t  BreakSignal;
+                               uint8_t Signals;
+                               uint8_t BreakSignal;

                        } Local;
                } RFCOMM_Channel_t;
                
                        } Local;
                } RFCOMM_Channel_t;
                


@@ -103,15 +101,19 @@
 
        /* Function Prototypes: */
                void              RFCOMM_Initialize(void);
 
        /* Function Prototypes: */
                void              RFCOMM_Initialize(void);

-               void              RFCOMM_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel);
+               void              RFCOMM_ServiceChannels(Bluetooth_Channel_t* const Channel);
+               void              RFCOMM_ProcessPacket(void* Data, Bluetooth_Channel_t* const BluetoothChannel);

                
                

+               void              RFCOMM_SendChannelSignals(const RFCOMM_Channel_t* const RFCOMMChannel,
+                                                           Bluetooth_Channel_t* const BluetoothChannel);

                RFCOMM_Channel_t* RFCOMM_GetChannelData(const uint8_t DLCI);
                RFCOMM_Channel_t* RFCOMM_GetChannelData(const uint8_t DLCI);

+

                uint16_t          RFCOMM_GetVariableFieldValue(const uint8_t** BufferPos);
                void              RFCOMM_SendFrame(const uint8_t DLCI, const bool CommandResponse, const uint8_t Control,
                                                       const uint16_t DataLen, const void* Data, Bluetooth_Channel_t* const Channel);
 
                #if defined(INCLUDE_FROM_RFCOMM_C)
                uint16_t          RFCOMM_GetVariableFieldValue(const uint8_t** BufferPos);
                void              RFCOMM_SendFrame(const uint8_t DLCI, const bool CommandResponse, const uint8_t Control,
                                                       const uint16_t DataLen, const void* Data, Bluetooth_Channel_t* const Channel);
 
                #if defined(INCLUDE_FROM_RFCOMM_C)

-                       static uint8_t RFCOMM_GetFCSValue(const void* FrameStart, uint8_t Length);                      
+                       static uint8_t RFCOMM_GetFCSValue(const void* FrameStart, uint8_t Length);

 
                        static void RFCOMM_ProcessDM(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel);
                        static void RFCOMM_ProcessDISC(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel);
 
                        static void RFCOMM_ProcessDM(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel);
                        static void RFCOMM_ProcessDISC(const RFCOMM_Address_t* const FrameAddress, Bluetooth_Channel_t* const Channel);

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.c b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.c
index 5e9c86b..2495bb4 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.c
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.c
@@ -56,7 +56,7 @@ void RFCOMM_ProcessControlCommand(const uint8_t* Command, Bluetooth_Channel_t* c
                        RFCOMM_ProcessFCDCommand(CommandHeader, CommandData, Channel);\r
                        break;\r
                case RFCOMM_Control_ModemStatus:\r
                        RFCOMM_ProcessFCDCommand(CommandHeader, CommandData, Channel);\r
                        break;\r
                case RFCOMM_Control_ModemStatus:\r

-                       RFCOMM_ProcessMSCommand(CommandHeader, CommandDataLen, CommandData, Channel);\r
+                       RFCOMM_ProcessMSCCommand(CommandHeader, CommandDataLen, CommandData, Channel);\r

                        break;\r
                case RFCOMM_Control_RemotePortNegotiation:\r
                        RFCOMM_ProcessRPNCommand(CommandHeader, CommandData, Channel);\r
                        break;\r
                case RFCOMM_Control_RemotePortNegotiation:\r
                        RFCOMM_ProcessRPNCommand(CommandHeader, CommandData, Channel);\r


@@ -110,12 +110,12 @@ static void RFCOMM_ProcessFCDCommand(const RFCOMM_Command_t* const CommandHeader
        BT_RFCOMM_DEBUG(1, "<< FCD Command");\r
 }\r
 \r
        BT_RFCOMM_DEBUG(1, "<< FCD Command");\r
 }\r
 \r

-static void RFCOMM_ProcessMSCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t CommandDataLen,\r
-                                    const uint8_t* CommandData, Bluetooth_Channel_t* const Channel)\r
+static void RFCOMM_ProcessMSCCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t CommandDataLen,\r
+                                     const uint8_t* CommandData, Bluetooth_Channel_t* const Channel)\r

 {\r
 {\r

-       const RFCOMM_MS_Parameters_t* Params = (const RFCOMM_MS_Parameters_t*)CommandData;\r
+       const RFCOMM_MSC_Parameters_t* Params = (const RFCOMM_MSC_Parameters_t*)CommandData;\r

 \r
 \r

-       BT_RFCOMM_DEBUG(1, "<< MS Command");\r
+       BT_RFCOMM_DEBUG(1, "<< MSC %s", (CommandHeader->CR) ? "Command" : "Response");\r

        BT_RFCOMM_DEBUG(2, "-- DLCI: 0x%02X", Params->Channel.DLCI);\r
        \r
        /* Ignore status flags sent to the control channel */\r
        BT_RFCOMM_DEBUG(2, "-- DLCI: 0x%02X", Params->Channel.DLCI);\r
        \r
        /* Ignore status flags sent to the control channel */\r


@@ -128,31 +128,41 @@ static void RFCOMM_ProcessMSCommand(const RFCOMM_Command_t* const CommandHeader,
        /* If the channel does not exist, abort */\r
        if (RFCOMMChannel == NULL)\r
          return;\r
        /* If the channel does not exist, abort */\r
        if (RFCOMMChannel == NULL)\r
          return;\r

-         \r
-       /* Save the new channel signals to the channel state structure */\r
-       RFCOMMChannel->Remote.Signals = Params->Signals;\r
-       \r
-       /* If the command contains the optional break signals field, store the value */\r
-       if (CommandDataLen == sizeof(RFCOMM_MS_Parameters_t))\r
-         RFCOMMChannel->Remote.BreakSignal = Params->BreakSignal;\r
-         \r
-       struct\r
+\r
+       /* Check if the MSC packet is a command or a response */\r
+       if (CommandHeader->CR)\r

        {\r
        {\r

-               RFCOMM_Command_t       CommandHeader;\r
-               uint8_t                Length;\r
-               RFCOMM_MS_Parameters_t Params;\r
-       } MSResponse;\r
-\r
-       /* Fill out the MS response data */\r
-       MSResponse.CommandHeader  = (RFCOMM_Command_t){.Command = RFCOMM_Control_ModemStatus, .EA = true, .CR = false};\r
-       MSResponse.Length         = (CommandDataLen << 1) | 0x01;\r
-       memcpy(&MSResponse.Params, Params, sizeof(RFCOMM_MS_Parameters_t));\r
-       \r
-       BT_RFCOMM_DEBUG(1, ">> MS Response");\r
+               /* Save the new channel signals to the channel state structure */\r
+               RFCOMMChannel->Remote.Signals  = Params->Signals;       \r
+               RFCOMMChannel->ConfigFlags    |= RFCOMM_CONFIG_REMOTESIGNALS;\r
+               \r
+               /* If the command contains the optional break signals field, store the value */\r
+               if (CommandDataLen == sizeof(RFCOMM_MSC_Parameters_t))\r
+                 RFCOMMChannel->Remote.BreakSignal = Params->BreakSignal;\r
+                 \r
+               struct\r
+               {\r
+                       RFCOMM_Command_t        CommandHeader;\r
+                       uint8_t                 Length;\r
+                       RFCOMM_MSC_Parameters_t Params;\r
+               } MSResponse;\r

 \r
 \r

-       /* Send the PDN response to acknowledge the command */\r
-       RFCOMM_SendFrame(RFCOMM_CONTROL_DLCI, false, RFCOMM_Frame_UIH,\r
-                        (sizeof(MSResponse) - sizeof(MSResponse.Params) + CommandDataLen), &MSResponse, Channel);\r
+               /* Fill out the MS response data */\r
+               MSResponse.CommandHeader  = (RFCOMM_Command_t){.Command = RFCOMM_Control_ModemStatus, .EA = true, .CR = false};\r
+               MSResponse.Length         = (CommandDataLen << 1) | 0x01;\r
+               memcpy(&MSResponse.Params, Params, sizeof(RFCOMM_MSC_Parameters_t));\r
+\r
+               BT_RFCOMM_DEBUG(1, ">> MSC Response");\r
+\r
+               /* Send the MSC response to acknowledge the command */\r
+               RFCOMM_SendFrame(RFCOMM_CONTROL_DLCI, false, RFCOMM_Frame_UIH,\r
+                                                (sizeof(MSResponse) - sizeof(MSResponse.Params) + CommandDataLen), &MSResponse, Channel);\r
+       }\r
+       else\r
+       {\r
+               /* Indicate that the remote device has acknowledged the sent signals */\r
+               RFCOMMChannel->ConfigFlags |= RFCOMM_CONFIG_LOCALSIGNALS;\r
+       }       \r

 }\r
 \r
 static void RFCOMM_ProcessRPNCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
 }\r
 \r
 static void RFCOMM_ProcessRPNCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r


@@ -189,15 +199,16 @@ static void RFCOMM_ProcessDPNCommand(const RFCOMM_Command_t* const CommandHeader
                for (uint8_t i = 0; i < RFCOMM_MAX_OPEN_CHANNELS; i++)\r
                {\r
                        /* If the channel's state is closed, the channel state entry is free */\r
                for (uint8_t i = 0; i < RFCOMM_MAX_OPEN_CHANNELS; i++)\r
                {\r
                        /* If the channel's state is closed, the channel state entry is free */\r

-                       if (RFCOMMChannel->State == RFCOMM_Channel_Closed)\r
+                       if (RFCOMM_Channels[i].State == RFCOMM_Channel_Closed)\r

                        {\r
                        {\r

-                               RFCOMMChannel        = &RFCOMM_Channels[i];\r
-                               RFCOMMChannel->DLCI  = Params->DLCI;\r
-                               RFCOMMChannel->MTU   = 0xFFFF;\r
+                               RFCOMMChannel                     = &RFCOMM_Channels[i];\r
+                               RFCOMMChannel->DLCI               = Params->DLCI;\r
+                               RFCOMMChannel->MTU                = 0xFFFF;\r

                                RFCOMMChannel->Remote.Signals     = 0 | (1 << 0);\r
                                RFCOMMChannel->Remote.BreakSignal = 0 | (1 << 0);\r
                                RFCOMMChannel->Local.Signals      = RFCOMM_SIGNAL_RTC | RFCOMM_SIGNAL_RTR | RFCOMM_SIGNAL_DV | (1 << 0);\r
                                RFCOMMChannel->Local.BreakSignal  = 0 | (1 << 0);\r
                                RFCOMMChannel->Remote.Signals     = 0 | (1 << 0);\r
                                RFCOMMChannel->Remote.BreakSignal = 0 | (1 << 0);\r
                                RFCOMMChannel->Local.Signals      = RFCOMM_SIGNAL_RTC | RFCOMM_SIGNAL_RTR | RFCOMM_SIGNAL_DV | (1 << 0);\r
                                RFCOMMChannel->Local.BreakSignal  = 0 | (1 << 0);\r

+                               RFCOMMChannel->ConfigFlags        = 0;\r

                                break;\r
                        }\r
                }\r
                                break;\r
                        }\r
                }\r


@@ -211,9 +222,9 @@ static void RFCOMM_ProcessDPNCommand(const RFCOMM_Command_t* const CommandHeader
        }\r
        \r
        /* Save the new channel configuration */\r
        }\r
        \r
        /* Save the new channel configuration */\r

-       RFCOMMChannel->State    = RFCOMM_Channel_Open;\r
-       RFCOMMChannel->Priority = Params->Priority;\r
-       RFCOMMChannel->MTU      = Params->MaximumFrameSize;\r
+       RFCOMMChannel->State       = RFCOMM_Channel_Configure;\r
+       RFCOMMChannel->Priority    = Params->Priority;\r
+       RFCOMMChannel->MTU         = Params->MaximumFrameSize;\r

        \r
        struct\r
        {\r
        \r
        struct\r
        {\r


@@ -223,7 +234,7 @@ static void RFCOMM_ProcessDPNCommand(const RFCOMM_Command_t* const CommandHeader
        } DPNResponse;\r
        \r
        /* Fill out the DPN response data */\r
        } DPNResponse;\r
        \r
        /* Fill out the DPN response data */\r

-       DPNResponse.CommandHeader           = (RFCOMM_Command_t){.Command = RFCOMM_Control_DLCParameterNegotiation, .EA = true, .CR = false};\r
+       DPNResponse.CommandHeader = (RFCOMM_Command_t){.Command = RFCOMM_Control_DLCParameterNegotiation, .EA = true, .CR = false};\r

        DPNResponse.Length                  = (sizeof(DPNResponse.Params) << 1) | 0x01;\r
        memcpy(&DPNResponse.Params, Params, sizeof(RFCOMM_DPN_Parameters_t));\r
        DPNResponse.Params.ConvergenceLayer = 0x00; // TODO: Enable credit based transaction support\r
        DPNResponse.Length                  = (sizeof(DPNResponse.Params) << 1) | 0x01;\r
        memcpy(&DPNResponse.Params, Params, sizeof(RFCOMM_DPN_Parameters_t));\r
        DPNResponse.Params.ConvergenceLayer = 0x00; // TODO: Enable credit based transaction support\r

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.h b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.h
index adad433..7928d94 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.h
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMMControl.h
@@ -50,11 +50,15 @@
                #include "RFCOMM.h"\r
                \r
        /* Macros: */\r
                #include "RFCOMM.h"\r
                \r
        /* Macros: */\r

-               #define RFCOMM_SIGNAL_FC     (1 << 1)\r
-               #define RFCOMM_SIGNAL_RTC    (1 << 2)\r
-               #define RFCOMM_SIGNAL_RTR    (1 << 3)\r
-               #define RFCOMM_SIGNAL_IC     (1 << 6)\r
-               #define RFCOMM_SIGNAL_DV     (1 << 7)\r
+               #define RFCOMM_SIGNAL_FC               (1 << 1)\r
+               #define RFCOMM_SIGNAL_RTC              (1 << 2)\r
+               #define RFCOMM_SIGNAL_RTR              (1 << 3)\r
+               #define RFCOMM_SIGNAL_IC               (1 << 6)\r
+               #define RFCOMM_SIGNAL_DV               (1 << 7)\r
+               \r
+               #define RFCOMM_CONFIG_REMOTESIGNALS    (1 << 0)\r
+               #define RFCOMM_CONFIG_LOCALSIGNALS     (1 << 1)\r
+               #define RFCOMM_CONFIG_LOCALSIGNALSSENT (1 << 2)\r

 \r
        /* Enums: */\r
                enum RFCOMM_Control_Commands_t\r
 \r
        /* Enums: */\r
                enum RFCOMM_Control_Commands_t\r


@@ -107,7 +111,7 @@
                        RFCOMM_Address_t Channel;\r
                        uint8_t          Signals;\r
                        uint8_t          BreakSignal;\r
                        RFCOMM_Address_t Channel;\r
                        uint8_t          Signals;\r
                        uint8_t          BreakSignal;\r

-               } RFCOMM_MS_Parameters_t;\r
+               } RFCOMM_MSC_Parameters_t;\r

 \r
        /* Function Prototypes: */\r
                void RFCOMM_ProcessControlCommand(const uint8_t* Command, Bluetooth_Channel_t* const Channel);\r
 \r
        /* Function Prototypes: */\r
                void RFCOMM_ProcessControlCommand(const uint8_t* Command, Bluetooth_Channel_t* const Channel);\r


@@ -119,8 +123,8 @@
                                                             Bluetooth_Channel_t* const Channel);\r
                        static void RFCOMM_ProcessFCDCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
                                                             Bluetooth_Channel_t* const Channel);\r
                                                             Bluetooth_Channel_t* const Channel);\r
                        static void RFCOMM_ProcessFCDCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
                                                             Bluetooth_Channel_t* const Channel);\r

-                       static void RFCOMM_ProcessMSCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t CommandDataLen,\r
-                                                           const uint8_t* CommandData, Bluetooth_Channel_t* const Channel);\r
+                       static void RFCOMM_ProcessMSCCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t CommandDataLen,\r
+                                                            const uint8_t* CommandData, Bluetooth_Channel_t* const Channel);\r

                        static void RFCOMM_ProcessRPNCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
                                                             Bluetooth_Channel_t* const Channel);\r
                        static void RFCOMM_ProcessRLSCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
                        static void RFCOMM_ProcessRPNCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r
                                                             Bluetooth_Channel_t* const Channel);\r
                        static void RFCOMM_ProcessRLSCommand(const RFCOMM_Command_t* const CommandHeader, const uint8_t* CommandData,\r

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c b/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c
index c5c490e..4529e8f 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c
@@ -52,12 +52,6 @@ const ServiceAttributeTable_t* SDP_Services_Table[] PROGMEM =
 /** Base UUID value common to all standardized Bluetooth services */
 const UUID_t BaseUUID PROGMEM = {0x00000000, BASE_80BIT_UUID};
 
 /** Base UUID value common to all standardized Bluetooth services */
 const UUID_t BaseUUID PROGMEM = {0x00000000, BASE_80BIT_UUID};
 

-/** Initializes the SDP service, ready for new connections from a SDP client. */
-void SDP_Initialize(void)
-{
-       /* Not currently used */
-}
-

 /** Main Service Discovery Protocol packet processing routine. This function processes incomming SDP packets from
  *  a connected Bluetooth device, and sends back appropriate responses to allow other devices to determine the
  *  services the local device exposes.
 /** Main Service Discovery Protocol packet processing routine. This function processes incomming SDP packets from
  *  a connected Bluetooth device, and sends back appropriate responses to allow other devices to determine the
  *  services the local device exposes.

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.h b/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.h
index 5310b6f..809d0f8 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.h
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/SDP.h
@@ -203,7 +203,6 @@
                }
                
        /* Function Prototypes: */
                }
                
        /* Function Prototypes: */

-               void SDP_Initialize(void);

                void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel);
 
                #if defined(INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C)
                void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel);
 
                #if defined(INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C)