Document inline SDP data read/write functions.

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c
index 3731e1f..589d0e1 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c
@@ -31,9 +31,6 @@
 #define  INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C
 #include "ServiceDiscoveryProtocol.h"
 
 #define  INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C
 #include "ServiceDiscoveryProtocol.h"
 

-/** Base UUID value common to all standardized Bluetooth services */
-const UUID_t BaseUUID PROGMEM = {SWAPENDIAN_32(0xFB349B5F), SWAPENDIAN_16(0x8000), SWAPENDIAN_16(0x0080), SWAPENDIAN_16(0x0010)};
-

 /** Master service table, listing all supported services (and their attribute tables) of the device, including
  *  each service's UUID.
  */
 /** Master service table, listing all supported services (and their attribute tables) of the device, including
  *  each service's UUID.
  */


@@ -49,6 +46,8 @@ const ServiceTable_t SDP_Services_Table[] PROGMEM =
                },
        };
 
                },
        };
 

+/** Base UUID value common to all standardized Bluetooth services */
+const UUID_t BaseUUID PROGMEM = {BASE_80BIT_UUID, {0, 0, 0, 0, 0, 0}};

 
 /** 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
 
 /** 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


@@ -57,7 +56,7 @@ const ServiceTable_t SDP_Services_Table[] PROGMEM =
  *  \param[in]  Data     Incomming packet data containing the SDP request
  *  \param[in]  Channel  Channel the request was issued to by the remote device
  */
  *  \param[in]  Data     Incomming packet data containing the SDP request
  *  \param[in]  Channel  Channel the request was issued to by the remote device
  */

-void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel)
+void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel)

 {
        SDP_PDUHeader_t* SDPHeader = (SDP_PDUHeader_t*)Data;
        SDPHeader->ParameterLength = SwapEndian_16(SDPHeader->ParameterLength);
 {
        SDP_PDUHeader_t* SDPHeader = (SDP_PDUHeader_t*)Data;
        SDPHeader->ParameterLength = SwapEndian_16(SDPHeader->ParameterLength);


@@ -222,6 +221,7 @@ static void SDP_ProcessServiceAttribute(const SDP_PDUHeader_t* const SDPHeader,
                /* Check if the current service in the service table has the requested service handle */
                if (ServiceHandle == CurrServiceHandle)
                {
                /* Check if the current service in the service table has the requested service handle */
                if (ServiceHandle == CurrServiceHandle)
                {

+                       /* Add the listed attributes for the found UUID to the response */

                        *TotalResponseSize += SDP_AddListedAttributesToResponse(CurrAttributeTable, AttributeList, TotalAttributes,
                                                                            &CurrResponsePos);
                        
                        *TotalResponseSize += SDP_AddListedAttributesToResponse(CurrAttributeTable, AttributeList, TotalAttributes,
                                                                            &CurrResponsePos);
                        


@@ -311,7 +311,7 @@ static void SDP_ProcessServiceSearchAttribute(const SDP_PDUHeader_t* const SDPHe
                BT_SDP_DEBUG(2, " -- Found UUID %d in table", CurrUUIDItem);
 
                /* Add the listed attributes for the found UUID to the response */
                BT_SDP_DEBUG(2, " -- Found UUID %d in table", CurrUUIDItem);
 
                /* Add the listed attributes for the found UUID to the response */

-               *TotalResponseSize += SDP_AddListedAttributesToResponse(AttributeTable, AttributeList, TotalAttributes,
+               *TotalResponseSize += SDP_AddListedAttributesToResponse(AttributeTable, AttributeList, TotalAttributes, 

                                                                        &CurrResponsePos);
        }
        
                                                                        &CurrResponsePos);
        }
        


@@ -351,8 +351,8 @@ static void SDP_ProcessServiceSearchAttribute(const SDP_PDUHeader_t* const SDPHe
  *
  *  \return Number of bytes added to the output buffer
  */
  *
  *  \return Number of bytes added to the output buffer
  */

-static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable,
-                                                  uint16_t AttributeList[][2], uint8_t TotalAttributes, void** BufferPos)
+static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable, uint16_t AttributeList[][2],
+                                                  const uint8_t TotalAttributes, void** const BufferPos)

 {
        uint16_t TotalResponseSize = 0;
 
 {
        uint16_t TotalResponseSize = 0;
 


@@ -576,7 +576,8 @@ static uint8_t SDP_GetUUIDList(uint8_t UUIDList[][UUID_SIZE_BYTES], const void**
 
 /** Retrieves the total size of the given locally stored (in PROGMEM) attribute Data Element container.
  *
 
 /** Retrieves the total size of the given locally stored (in PROGMEM) attribute Data Element container.
  *

- *  \param[in] AttributeData  Pointer to the start of the Attribute container, located in PROGMEM
+ *  \param[in]  AttributeData  Pointer to the start of the Attribute container, located in PROGMEM
+ *  \param[out] HeaderSize     Pointer to a location where the header size of the data element is to be stored

  *
  *  \return Size in bytes of the entire attribute container, including the header
  */
  *
  *  \return Size in bytes of the entire attribute container, including the header
  */

diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.h b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.h
index a3913f6..c9ce951 100644 (file)
--- a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.h
+++ b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.h
@@ -104,49 +104,45 @@
                } SDP_PDUHeader_t;
                
        /* Inline Functions: */
                } SDP_PDUHeader_t;
                
        /* Inline Functions: */

-               /** Adds a new Data Element container of the given type with a 16-bit size header to the buffer. The
-                *  buffer pointer's position is advanced past the added header once the element has been added. The
-                *  returned size header value is pre-zeroed out so that it can be incremented as data is placed into
-                *  the Data Element container.
-                *
-                *  The total added size of the container header is three bytes, regardless of the size of its contents
-                *  as long as the contents' size in bytes fits into a 16-bit integer.
+               /** Writes 8 bits of raw data to the given buffer, incrementing the buffer position afterwards.

                 *
                 *

-                *  \param[in, out] BufferPos  Pointer to a buffer where the container header is to be placed
-                *  \param[in]      Type       Type of data the container is to store, a value from the \ref ServiceDiscovery_DataTypes_t enum
-                *
-                *  \return Pointer to the 16-bit size value of the contaner header, which has been pre-zeroed
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be written to
+                *  \param[in]      Data       Data to write to the buffer

                 */
                 */

-               static inline uint16_t* SDP_AddDataElementHeader16(void** BufferPos, const uint8_t Type)
-               {
-                       *((uint8_t*)*BufferPos) = (SDP_DATASIZE_Variable16Bit | Type);
-                       *BufferPos += sizeof(uint8_t);
-
-                       uint16_t* SizePos = (uint16_t*)*BufferPos;
-                       *BufferPos += sizeof(uint16_t);
-
-                       *SizePos = 0;
-                       return SizePos;
-               }
-               

                static inline void SDP_WriteData8(void** BufferPos, uint8_t Data)
                {
                        *((uint8_t*)*BufferPos) = Data;
                        *BufferPos += sizeof(uint8_t);
                }
                
                static inline void SDP_WriteData8(void** BufferPos, uint8_t Data)
                {
                        *((uint8_t*)*BufferPos) = Data;
                        *BufferPos += sizeof(uint8_t);
                }
                

+               /** Writes 16 bits of raw data to the given buffer, incrementing the buffer position afterwards.
+                *
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be written to
+                *  \param[in]      Data       Data to write to the buffer
+                */

                static inline void SDP_WriteData16(void** BufferPos, uint16_t Data)
                {
                        *((uint16_t*)*BufferPos) = SwapEndian_16(Data);
                        *BufferPos += sizeof(uint16_t);
                }               
 
                static inline void SDP_WriteData16(void** BufferPos, uint16_t Data)
                {
                        *((uint16_t*)*BufferPos) = SwapEndian_16(Data);
                        *BufferPos += sizeof(uint16_t);
                }               
 

+               /** Writes 32 bits of raw data to the given buffer, incrementing the buffer position afterwards.
+                *
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be written to
+                *  \param[in]      Data       Data to write to the buffer
+                */

                static inline void SDP_WriteData32(void** BufferPos, uint32_t Data)
                {
                        *((uint32_t*)*BufferPos) = SwapEndian_32(Data);
                        *BufferPos += sizeof(uint32_t);
                }
 
                static inline void SDP_WriteData32(void** BufferPos, uint32_t Data)
                {
                        *((uint32_t*)*BufferPos) = SwapEndian_32(Data);
                        *BufferPos += sizeof(uint32_t);
                }
 

+               /** Reads 8 bits of raw data frpm the given buffer, incrementing the buffer position afterwards.
+                *
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be read from
+                *
+                *  \return Data read from the buffer
+                */

                static inline uint8_t SDP_ReadData8(const void** BufferPos)
                {
                        uint8_t Data = *((uint8_t*)*BufferPos);
                static inline uint8_t SDP_ReadData8(const void** BufferPos)
                {
                        uint8_t Data = *((uint8_t*)*BufferPos);


@@ -155,6 +151,12 @@
                        return Data;
                }
 
                        return Data;
                }
 

+               /** Reads 16 bits of raw data frpm the given buffer, incrementing the buffer position afterwards.
+                *
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be read from
+                *
+                *  \return Data read from the buffer
+                */

                static inline uint16_t SDP_ReadData16(const void** BufferPos)
                {
                        uint16_t Data = SwapEndian_16(*((uint16_t*)*BufferPos));
                static inline uint16_t SDP_ReadData16(const void** BufferPos)
                {
                        uint16_t Data = SwapEndian_16(*((uint16_t*)*BufferPos));


@@ -163,6 +165,12 @@
                        return Data;
                }
 
                        return Data;
                }
 

+               /** Reads 32 bits of raw data frpm the given buffer, incrementing the buffer position afterwards.
+                *
+                *  \param[in, out] BufferPos  Current position in the buffer where the data is to be read from
+                *
+                *  \return Data read from the buffer
+                */

                static inline uint32_t SDP_ReadData32(const void** BufferPos)
                {
                        uint32_t Data = SwapEndian_32(*((uint32_t*)*BufferPos));
                static inline uint32_t SDP_ReadData32(const void** BufferPos)
                {
                        uint32_t Data = SwapEndian_32(*((uint32_t*)*BufferPos));


@@ -170,16 +178,41 @@
                        
                        return Data;
                }
                        
                        return Data;
                }

+
+               /** Adds a new Data Element container of the given type with a 16-bit size header to the buffer. The
+                *  buffer pointer's position is advanced past the added header once the element has been added. The
+                *  returned size header value is pre-zeroed out so that it can be incremented as data is placed into
+                *  the Data Element container.
+                *
+                *  The total added size of the container header is three bytes, regardless of the size of its contents
+                *  as long as the contents' size in bytes fits into a 16-bit integer.
+                *
+                *  \param[in, out] BufferPos  Pointer to a buffer where the container header is to be placed
+                *  \param[in]      Type       Type of data the container is to store, a value from the \ref ServiceDiscovery_DataTypes_t enum
+                *
+                *  \return Pointer to the 16-bit size value of the contaner header, which has been pre-zeroed
+                */
+               static inline uint16_t* SDP_AddDataElementHeader16(void** BufferPos, const uint8_t Type)
+               {
+                       SDP_WriteData8(BufferPos, (SDP_DATASIZE_Variable16Bit | Type));
+
+                       uint16_t* SizePos = (uint16_t*)*BufferPos;
+                       
+                       SDP_WriteData16(BufferPos, 0);
+
+                       return SizePos;
+               }

                
        /* Function Prototypes: */
                
        /* Function Prototypes: */

-               void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel);
+               void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel);

 
                #if defined(INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C)
                        static void SDP_ProcessServiceSearch(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
                        static void SDP_ProcessServiceAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
                        static void SDP_ProcessServiceSearchAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
 
 
                #if defined(INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C)
                        static void SDP_ProcessServiceSearch(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
                        static void SDP_ProcessServiceAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
                        static void SDP_ProcessServiceSearchAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel);
 

-                       static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable, uint16_t AttributeList[][2], uint8_t TotalAttributes, void** BufferPos);
+                       static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable, uint16_t AttributeList[][2],
+                                                                         const uint8_t TotalAttributes, void** const BufferPos);

                        static uint16_t SDP_AddAttributeToResponse(const uint16_t AttributeID, const void* AttributeValue, void** ResponseBuffer);
                        static void*    SDP_GetAttributeValue(const ServiceAttributeTable_t* AttributeTable, const uint16_t AttributeID);
                        static ServiceAttributeTable_t* SDP_GetAttributeTable(const uint8_t* const UUID);
                        static uint16_t SDP_AddAttributeToResponse(const uint16_t AttributeID, const void* AttributeValue, void** ResponseBuffer);
                        static void*    SDP_GetAttributeValue(const ServiceAttributeTable_t* AttributeTable, const uint16_t AttributeID);
                        static ServiceAttributeTable_t* SDP_GetAttributeTable(const uint8_t* const UUID);