实战Linux Bluetooth编程

痛定思痛。 2022-07-12 07:50 101阅读 0赞

文章来源：[http://blog.chinaunix.net/u3/104073/showart\_2081838.html][http_blog.chinaunix.net_u3_104073_showart_2081838.html]

实战Linux Bluetooth编程（一） 协议栈概述

Sam一年前在Linux下写了一个类似Windows下BTW的库--BTX。现在需要添加新功能时发现很多知识点都忘记

了。所以决定在这次学习中，把一些bluez API记录下来。这几天又想，这样还不够，不如把Linux下的

Bluetooth编程基础给记录下来吧。

前言：随着嵌入式系统的飞速发展，很多嵌入式平台上需要Bluetooth设备和应用。但在Linux下如何对

Bluetooth编程，一直没有一份很好的中文文档。Sam结合自己的工作，一步一步将一些有用的东西记录下来

，希望对其它Linux下Bluetooth编程的朋友有点帮助。

一：Bluetooth基本概念：

Bluetooth是爱立信、诺基亚、东芝、IBM和Intel 5家公司在1998年联合推出的一项无线网络技术。其宗旨

是提供一种短距离、低成本的无线传输应用技术。在行业协会筹备阶段,需要一个极具有表现力的名字来命

名这项高新技术。行业组织人员，在经过一夜关于欧洲历史和未来无限技术发展的讨论后，有些人认为用

Blatand国王的名字命名再合适不过了。Blatand国王将现在的挪威，瑞典和丹麦统一起来；就如同这项即将

面世的技术,将标准不一的短距离无线传输技术统一起来。

Intel负责半导体芯片和传输软件的开发，爱立信负责无线射频和移动电话软件的开发，IBM和东芝负责笔记

本电脑接口规格的开发。

蓝牙是无线数据和语音传输的开放式标准，它将各种通信设备、计算机及其终端设备、各种数字数据系统、

甚至家用电器采用无线方式联接起来。它的传输距离为10cm～10m，如果增加功率或是加上某些外设便可达

到100m的传输距离。它采用2.4GHz ISM频段和调频、跳频技术，使用权向纠错编码、ARQ、TDD和基带协议。

TDMA每时隙为0.625μs，基带符合速率为1Mb/s。蓝牙支持64kb/s实时语音传输和数据传输，语音编码为

CVSD，发射功率分别为1mW、2.5mW和100mW，并使用全球统一的48比特的设备识别码。由于蓝牙采用无线接

口来代替有线电缆连接，具有很强的移植性，并且适用于多种场合，加上该技术功耗低、对人体危害小，而

且应用简单、容易实现，所以易于推广。

蓝牙技术的系统结构分为三大部分：底层硬件模块、中间协议层和高层应用。底层硬件部分包括无线跳频（

RF）、基带（BB）和链路管理（LM）。无线跳频层通过2.4GHz无需授权的ISM频段的微波，实现数据位流的

过滤和传输，本层协议主要定义了蓝牙收发器在此频带正常工作所需要满足的条件。基带负责跳频以及蓝牙

数据和信息帧的传输。链路管理负责连接、建立和拆除链路并进行安全控制。

关于bluetooth协议栈，接下来再谈。

当前已经实现的Bluetooth栈有以下各种：

1. Widcomm:  第一个windows上的协议栈，由Widcomm公司开发，也就是现在的Broadcom.

2. Microsoft Windows stack: Windows XP SP2中包括了这个内建的协议栈，开发者也可以调用其API开发

第三方软件。

3. Toshiba stack: 它也是基于Windows的，不支持第三方开发，但它把协议栈授权给一些laptop商(sony,

asus等，我的本本上就是Toshiba的）。它支持的Profile有： SPP, DUN, FAX, LAP, OPP, FTP, HID,

HCRP, PAN, BIP, HSP, HFP , A2DP, AVRCP, GAVDP）

4. BlueSoleil: 著名的IVT公司的产品．该产品可以用于桌面和嵌入式，他也支持第三方开发，DUN, FAX,

HFP, HSP, LAP, OBEX, OPP, PAN SPP, AV, BIP, FTP, GAP, HID, SDAP, and SYNC。

5. Bluez: Linux官方协议栈，该协议栈的上层用Socket封装，便于开发者使用，通过DBUS与其它应用程序

通信。

6. Affix: NOKIA公司的协议栈，在Symbian系统上运行.

7. BlueDragon：东软公司产品，好像2002年6月就通过了蓝牙的认证，支持的Profile：SDP、Serial-DevB

、AVCTP、AVRCP-Controller、AVRCP-Target、Headset-AG、Headset-HS、OPP-Client、OPP-Server、CT-GW

、CT-Term、Intercom、FT-Server、FT-Client、GAP、SDAP、Serial-DevA、AVDTP、GAVDP、A2DP-Source、

A2DP-Sink.

8. BlueMagic：美国Open Interface 公司for portable embedded divce的协议栈，iphone(apple)，nav-

u(sony)等很多电子产品都用该商业的协议栈，BlueMagic 3.0是第一个通过bluetooth 协议栈1.1认证的协

议栈，那么我现在就在用它，那么该栈用起来简单，API清晰明了。实现了的profile

有:HCI,L2CAP,RFCOMM,A/V,Remote,Control,A/V,Streaming,BIP,BPP,DUN,FAX,FTP,GAP,Hands-

Free,and,Headset,HCRP,HID,OBEX,OPP,PAN,BNEP,PBAP,SAP,SPP,Synchronization,SyncML,Telephony,XML.  
9. BCHS-Bluecore Host Software: 蓝牙芯片CSR的协议栈，同时他也提供了一些上层应用的Profile的库，

当然了它也是为嵌入式产品了，支持的Profile有：A2DP,AVRCP,PBAP,BIP,BPP,CTP,DUN,FAX,FM API,FTP

GAP,GAVDP,GOEP,HCRP,Headset,HF1.5,HID,ICP,JSR82,LAP Message Access

Profile,OPP,PAN,SAP,SDAP,SPP,SYNC,SYNC ML。

10. Windows CE：微软给Windows CE开发的协议栈，但是windows ce本身也支持其它的协议栈

11. BlueLet：IVT公司for embedded product的清量级协议栈。

实战Linux Bluetooth编程（二） BlueZ简介

Linux下Bluetooth协议栈的实现. Linux下开放的蓝牙协议栈主要包括IBM公司的BlueDrekar，Nokia公司的

Affix, Axis公司的OpenBT和官方协议栈BlueZ。我们主要面对Bluez来探讨。

BlueZ基础代码均是由Maxim Krasnyansky完成的。包括：HCI，L2CAP，RFCOMM和基本socket的实现。他就职

于Qualcomm(高通)。Marcel Holtmann开发层的协议和应用，包括：BNEP, CMTP等。当然，这些中也有Maxim

Krasnyansky的参预。有部分代码由Nokia提供的。

Bluez是如何实现Bluetooth协议栈的呢？ 它分2部分实现：

1.Kernel层实现：

正如上一篇所谈到的，bluetooth协议栈有多层结构，最底层的硬件协议在硬件中就已经实现了。（例如

broadcom的芯片中，底层硬件协议已经包含于芯片之中了）。软件级别的协议实现，从HCI这一层起就可以

了。 BlueZ对各层协议的实现是依托于Socket的。BlueZ首先创建了一个新的Socket中的协议--

PF\_BLUETOOTH （AF\_BLUETOOTH=31). （也就是说，Socket（）的第一个参数：domain必须是：

PF\_BLUETOOTH ）。这也意味着，地址类型需要使用Bluetooth所定义的。

其实很简单，就是在net\_families(网络协议列表)中添加了PF\_BLUETOOTH这一项。如果对Linux Kernel有了

解的话，就知道这个注册动作一定在Bluetooth init部分作的。

同样，各个协议层（如：HCI，L2CAP,HID等）都将自己的行为规范添加到PF\_BLUETOOTH协议中。

2.应用程序层实现：

虽然Kernel层已经将Bluetooth协议栈完全实现了，但如果要使用起来，还是非常不方便的。毕竟应用程序

与kernel最方便的交流通道就是ioctl().这非常不直观。于是，BlueZ又提供了一套API,这个API帮助开发者

方便的与Kernel层协议打交道。当然，这些API底层的实现其就是是ioctl.

BlueZ的时间，基本就是这样了。下面咱们具体研究如何使用BlueZ所提供的这套API。

实战Linux Bluetooth编程（三） HCI层编程  
1. HCI层协议概述：

HCI提供一套统一的方法来访问Bluetooth底层。如图所示：

从图上可以看出，Host Controller Interface(HCI)  就是用来沟通Host和Module。Host通常就是PC，

Module则是以各种物理连接形式（USB,serial,pc-card等）连接到PC上的bluetooth Dongle。

在Host这一端：application,SDP,L2cap等协议都是软件形式提出的（Bluez中是以kernel层程序)。在

Module这一端：Link Manager, BB, 等协议都是硬件中firmware提供的。

而HCI则比较特殊，它一部分在软件中实现，用来给上层协议和程序提供访问接口（Bluez中,hci.c

hci\_usb.c，hci\_sock.c等）.另一部分也是在Firmware中实现，用来将软件部分的指令等用底层协议明白的

方式传递给底层。

居于PC的上层程序与协议和居于Modules的下层协议之间通过HCI沟通，有4种不同形式的传输：Commands,

Event, ACL Data, SCO/eSCO Data。

1.1. HCI Command：

HCI Command是Host向Modules发送命令的一种方式。HCI Command Packet结构如下：

OpCode用来唯一标识HCI Command.它由2部分组成，10bit的Opcode Command. 6bit的Opcode Group。

1.1.1: OpCode Group:

Linux Kernel（BlueZ）中，~/include/net/bluetooth/hci.h中定义了OpCode Group。

\#define OGF\_LINK\_CTL 0x01

\#define OGF\_LINK\_POLICY 0x02

\#define OGF\_HOST\_CTL 0x03

\#define OGF\_INFO\_PARAM 0x04

\#define OGF\_STATUS\_PARAM 0x05

它们代表了不同的Command Group：

OGF\_LINK\_CTL: Link control,这个Command Group中的Command允许Host控制与其它bluetooth device 的连

接。

OGF\_LINK\_POLICY ：Link Policy。这个Command Group中的Command允许调整Link Manager control.

OGF\_HOST\_CTL: Control and Baseband.

1.1.2: Opcode Command:

用来在同一个Group内唯一识别Command。~/include/net/bluetooth/hci.h中定义。

1.2: HCI Event：

Modules向Host发送一些信息，使用HCI Event。Event Packet结构如下：

HCI Event分3种：Command complete Event, Command States Event，Command Subsequently Completend.

Command complete Event: 如果Host发送的Command可以立刻有结果，则会发送此类Event。也就是说，如果

发送的Command只与本地Modules有关，不与remote设备打交道，则使用Command complete Event。例如：

HCI\_Read\_Buffer\_Size.

Command States Event：如果Host发送的Command不能立刻得知结果，则发送此类Event。Host发送的

Command执行要与Remote设备打交道，则必然无法立刻得知结果，所以会发送Command States Event.例如：

HCI Connect。

Command Subsequently Completend:Command延后完成Event。例如：连接已建立。

下图是一个Command-Event例子：

从这里可以看出，如果Host发送的Command是与Remote device有关的，则会先发送Command States Event

。等动作真正完成了，再发送 Command Subsequently Completend。

HCI ACL与SCO数据，这里就不多讲了。只需要明白，l2cap数据是通过ACL数据传输给remote device的。

下图很明白的展示了l2cap数据如何一步一步转化为USB数据并传递给底层协议的。

很明显，一个l2cap包会按照规则先切割为多个HCI数据包。HCI数据包再通过HCI-usb这一层传递给USB设备

。每个包又通过USB driver发送到底层。

2. HCI protocol的实现：

（稍后添加）

3. HCI 层的编程：

正如上一节所说，HCI是沟通上层协议以及程序与底层硬件协议的通道。所以，通过HCI发送的Command都是

上层协议或者应用程序发送给Bluetooth Dongle的。它命令Bluetooth Dongle（或其中的硬件协议）去做什

么何种动作。

3.0：得到Host上插入Dongle数目以及Dongle信息：

我们先复习一下socket的概念：

使用函数socket()建立一个Socket，就如同你有一部电话.bind()则是把这个电话和某个电话号码（网络地

址）对应起来。

类似的，我们可以把Host理解为一个房间，这个房间有多部电话（Dongle）。

当使用socket() 打开一个HCI protocol的socket，表明得到这个房间的句柄。HOST可能会有多个Dongle。

换句话说，这个房间可以有多个电话号码。所以HCI会提供一套指令去得到这些Dongle。

// 0. 分配一个空间给 hci\_dev\_list\_req。这里面将放所有Dongle信息。

struct hci\_dev\_list\_req \*dl;  
struct hci\_dev\_req \*dr;

struct hci\_dev\_info di;

int i;

if (!(dl = malloc(HCI\_MAX\_DEV \* sizeof(struct hci\_dev\_req) + sizeof(uint16\_t)))) \{  
  perror("Can't allocate memory");  
  exit(1);  
 \}  
 dl->dev\_num = HCI\_MAX\_DEV;  
 dr = dl->dev\_req;

//1. 打开一个HCI socket.此socket相当于一个房间。

if ((ctl = socket(AF\_BLUETOOTH, SOCK\_RAW, BTPROTO\_HCI)) < 0) \{  
  perror("Can't open HCI socket.");  
  exit(1);  
 \}

// 2. 使用HCIGETDEVLIST,得到所有dongle的Device ID。存放在dl中。

if (ioctl(ctl, HCIGETDEVLIST, (void \*) dl) < 0) \{  
  perror("Can't get device list");  
  exit(1);  
 \}

// 3 使用HCIGETDEVINFO，得到对应Device ID的Dongle信息。

di.dev\_id = (dr+i)->dev\_id;  
ioctl(ctl, HCIGETDEVINFO, (void \*) &di)；

这样就能得到所有Dongle信息。

struct hci\_dev\_info \{  
 uint16\_t dev\_id;   //dongle Device ID  
 char     name\[8\];  //Dongle name

bdaddr\_t bdaddr;   //Dongle bdaddr

uint32\_t flags;    //Dongle Flags：如：UP，RUNING，Down等。  
 uint8\_t  type;   //Dongle连接方式：如USB，PC Card，UART，RS232等。

uint8\_t  features\[8\];

uint32\_t pkt\_type;  
 uint32\_t link\_policy;  
 uint32\_t link\_mode;

uint16\_t acl\_mtu;  
 uint16\_t acl\_pkts;  
 uint16\_t sco\_mtu;  
 uint16\_t sco\_pkts;

struct   hci\_dev\_stats stat;  //此Dongle的数据信息，如发送多少个ACL Packet，正确多少，错误多

少，等等。  
\};

3.0.1: UP和Down Bluetooth Dongle：

ioctl(ctl, HCIDEVUP, hdev)

ioctl(ctl, HCIDEVDOWN, hdev)

ctl：为使用socket(AF\_BLUETOOTH, SOCK\_RAW, BTPROTO\_HCI)打开的Socket.

hdev: Dongle Device ID.(所以上面的Socket不需要bind,因为这边指定了)

3.1 BlueZ提供的HCI编程接口一（针对本地Dongle的API系列）：

3.1。1 打开一个HCI Socket---int hci\_open\_dev(int dev\_id):

这个function用来打开一个HCI Socket。它首先打开一个HCI protocol的Socket（房间），并将此Socket与

device ID=参数dev\_id的Dongle绑定起来。只有bind后，它才将Socket句柄与Dongle对应起来。

注意，所有的HCI Command发送之前，都需要使用 hci\_open\_dev打开并绑定。

3.1.2: 关闭一个HCI Socket：

int hci\_close\_dev(int dd) //简单的关闭使用hci\_open\_dev打开的Socket。

3.1.3: 向HCI Socket（对应一个Dongle）发送 request:

int hci\_send\_req(int dd, struct hci\_request \*r, int to)

BlueZ提供这个function非常有用，它可以实现一切Host向Modules发送Command的功能。

参数1：HCI Socket。

参数2：Command内容。

参数3：以milliseconds为单位的timeout.

下面详细解释此function和用法：

当应用程序需要向Dongle(对应为一个bind后的Socket)发送Command时，调用此function.

其中，参数一dd对应一个使用hci\_open\_dev（）打开的Socket（Dongle）。

参数三to则为等待Dongle执行并回复命令结果的timeout.以毫秒为单位。

参数二hci\_request \* r 最为重要,首先看它的结构：

struct hci\_request \{  
 uint16\_t ogf;    //Opcode Group  
 uint16\_t ocf;    //Opcode Command  
 int      event;  //此Command产生的Event类型。  
 void     \*cparam; //Command 参数  
 int      clen;    //Command参数长度  
 void     \*rparam;  //Response 参数  
 int      rlen;    //Response 参数长度  
\};

ogf,ocf不用多说，对应前面的图就明白这是Group Code和Command Code。这两项先确定下来，然后可以查

HCI Spec。察看输入参数（cparam）以及输出参数（rparam）含义。至于他们的结构以及参数长度，则在

~/include/net/bluetooth/hci.h中有定义。

至于event.如果设置，它会被setsockopt设置于Socket。

例1：得到某个连接的Policy Setting.

HCI Spec以及~/include/net/bluetooth/hci.h中均可看到，OGF=OGF\_LINK\_POLICY(0x02).

OCF=OCF\_READ\_LINK\_POLICY(0x0C).

因为这个Command用来读取某个ACL连接的Policy Setting。所以输入参数即为此连接Handle.

返回参数则包含3部分，status（Command是否顺利执行）， handle(连接Handle)。 policy（得到的policy

值）

这就又引入了一个新问题，如何得到某个ACL连接的Handle。

可以使用ioctl HCIGETCONNINFO得到ACL 连接Handle。

ioctl(dd, HCIGETCONNINFO, (unsigned long) cr)；

Connect\_handle = htobs(cr->conn\_info->handle);

所以完整的过程如下：

struct hci\_request HCI\_Request;  
 read\_link\_policy\_cp Command\_Param;  
 read\_link\_policy\_rp Response\_Param;

// 1.得到ACL Connect Handle

if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0)  
 \{   
  return -1；  
 \}  
 Connect\_handle = htobs(cr->conn\_info->handle);

memset(&HCI\_Request, 0, sizeof(HCI\_Request));  
 memset(&Command\_Param, 0 , sizeof(Command\_Param));  
 memset(&Response\_Param, 0 , sizeof(Response\_Param));

// 2.填写Command输入参数  
 Command\_Param.handle = Connect\_handle;

HCI\_Request.ogf = OGF\_LINK\_POLICY;  //Command组ID  
 HCI\_Request.ocf = OCF\_READ\_LINK\_POLICY; //Command ID  
 HCI\_Request.cparam = &Command\_Param;  
 HCI\_Request.clen = READ\_LINK\_POLICY\_CP\_SIZE;  
 HCI\_Request.rparam = &Response\_Param;  
 HCI\_Request.rlen = READ\_LINK\_POLICY\_RP\_SIZE;

if (hci\_send\_req(dd, &HCI\_Request, to) < 0)  
 \{  
  perror("/nhci\_send\_req()");  
  return -1;  
 \}

//如果返回值状态不对

if (Response\_Param.status) \{  
  return -1;  
 \}

//得到当前policy  
 \*policy = Response\_Param.policy;

3.1.4:几个更基础的function:

static inline void bacpy(bdaddr\_t \*dst, const bdaddr\_t \*src) //bdaddr copy

static inline int bacmp(const bdaddr\_t \*ba1, const bdaddr\_t \*ba2)//bdaddr 比较

3.1.5: 得到指定Dongle BDAddr：

int hci\_read\_bd\_addr(int dd, bdaddr\_t \*bdaddr, int to)；

参数1：HCI Socket,使用hci\_open\_dev（）打开的Socket（Dongle）。

参数2：输出参数，其中会放置bdaddr.

参数3：以milliseconds为单位的timeout.

3.1.6: 读写Dongle Name：

int hci\_read\_local\_name(int dd, int len, char \*name, int to)

int hci\_write\_local\_name(int dd, const char \*name, int to)

参数1：HCI Socket,使用hci\_open\_dev（）打开的Socket（Dongle）。

参数2：读取或设置Name。

参数3：以milliseconds为单位的timeout.

注意：这里的Name与IOCTL HCIGETDEVINFO 得到hci\_dev\_info中的name不同。

3.1.7：得到HCI Version:

int hci\_read\_local\_version(int dd, struct hci\_version \*ver, int to)

3.1.8：得到已经UP的Dongle BDaddr：

int hci\_devba(int dev\_id, bdaddr\_t \*bdaddr)；

dev\_id: Dongle Device ID.

bdaddr:输出参数，指定Dongle如果UP， 则放置其BDAddr。

3.1.9: 得到Dongle Info：

int hci\_devinfo(int dev\_id, struct hci\_dev\_info \*di)

dev\_id: Dongle Device ID.

di: 此Dongle信息。

出错返回 -1。

注意，这个Function的做法与3.0的方法完全一致。

3.1.10：从hciX中得到X：

int hci\_devid(const char \*str)

str: 类似 hci0这样的字串。

如果hciX对应的Device ID(X)是现实存在且UP。则返回此设备Device ID。

3.1.11：得到BDADDR不等于参数bdaddr的Dongle Device ID：

int hci\_get\_route(bdaddr\_t \*bdaddr)

查找Dongle，发现Dongle Bdaddr不等于参数bdaddr的第一个Dongle，则返回此Dongle Device ID。

所以，如果: int hci\_get\_route(NULL),则得到第一个可用的Dongle Device ID。

3.1.12: 将BDADDR转换为字符串：

int ba2str(const bdaddr\_t \*ba, char \*str)

3.1.13: 将自串转换为BDADDR：

int str2ba(const char \*str, bdaddr\_t \*ba)

3.2 BlueZ提供的HCI编程接口二（针对Remote Device的API系列）：

3.2.1  inquiry 远程Bluetooth Device：

int hci\_inquiry(int dev\_id, int len, int nrsp, const uint8\_t \*lap, inquiry\_info \*\*ii, long

flags)

hci\_inquiry（）用来命令指定的Dongle去搜索周围所有bluetooth device.并将搜索到的Bluetooth Device

bdaddr 传递回来。

参数1：dev\_id：指定Dongle Device ID。如果此值小于0，则会使用第一个可用的Dongle。

参数2：len: 此次inquiry的时间长度（每增加1，则增加1.25秒时间）

参数3：nrsp:此次搜索最大搜索数量，如果给0。则此值会取255。

参数4：lap:BDADDR中LAP部分，Inquiry时这块值缺省为0X9E8B33.通常使用NULL。则自动设置。

参数5：ii:存放搜索到Bluetooth Device的地方。给一个存放inquiry\_info指针的地址，它会自动分配空间

。并把那个空间头地址放到其中。

参数6：flags:搜索flags.使用IREQ\_CACHE\_FLUSH，则会真正重新inquiry。否则可能会传回上次的结果。

返回值是这次Inquiry到的Bluetooth Device 数目。

注意：如果\*ii不是自己分配的，而是让hci\_inquiry()自己分配的，则需要调用bt\_free（）来帮它释放空

间。

3.2.2：得到指定BDAddr的reomte device Name:

int hci\_read\_remote\_name(int dd, const bdaddr\_t \*bdaddr, int len, char \*name, int to)

参数1：使用hci\_open\_dev（）打开的Socket。

参数2：对方BDAddr.

参数3：name 长度。

参数4：(out)放置name的位置。

参数5：等待时间。

3.2.3: 读取连接的信号强度：

int hci\_read\_rssi(int dd, uint16\_t handle, int8\_t \*rssi, int to)

注意，所有对连接的操作，都会有一个参数，handle.这个参数是连接的Handle。前面讲过如何得到连接

Handle的。

实战Linux Bluetooth编程（四） L2CAP层编程

（L2CAP协议简介，L2CAP在BlueZ中的实现以及L2CAP编程接口）

一：L2CAP协议简介：

Logical Link Control and Adaptation Protocol(L2CAP)

逻辑连接控制和适配协议 (L2CAP) 为上层协议提供面向连接和无连接的数据服务，并提供多协议功能和分

割重组操作。L2CAP 充许上层协议和应用软件传输和接收最大长度为 64K 的 L2CAP 数据包。

L2CAP 基于 通道(channel) 的概念。 通道 (Channel) 是位于基带 (baseband) 连接之上的逻辑连接

。每个通道以多对一的方式绑定一个单一协议 (single protocol)。多个通道可以绑定同一个协议，但一个

通道不可以绑定多个协议。 每个在通道里接收到的 L2CAP 数据包被传到相应的上层协议。 多个通道可共

享同一个基带连接。

L2CAP处于Bluetooth协议栈的位置如下：

也就是说，所有L2CAP数据均通过HCI传输到Remote Device。且上层协议的数据，大都也通过L2CAP来传送。

L2CAP可以发送Command。例如连接，断连等等。

下面看Command例子：Connection Request:

其中PSM比较需要注意，L2CAP 使用L2CAP连接请求（Connection Request ）命令中的PSM字段实现协议复用

。L2CAP可以复用发给上层协议的连接请求，这些上层协议包括服务发现协议SDP（PSM = 0x0001）、RFCOMM

（PSM = 0x0003）和电话控制（PSM = 0x0005）等。

Protocol PSM Reference  
SDP 0x0001 See Bluetooth Service Discovery Protocol (SDP), Bluetooth SIG.  
RFCOMM 0x0003 See RFCOMM with TS 07.10, Bluetooth SIG.  
TCS-BIN 0x0005 See Bluetooth Telephony Control Specification / TCS Binary, Bluetooth SIG.  
TCS-BIN-CORDLESS 0x0007 See Bluetooth Telephony Control Specification / TCS Binary, Bluetooth

SIG.  
BNEP 0x000F See Bluetooth Network Encapsulation Protocal, Bluetooth SIG.  
HID\_Control 0x0011 See Human Interface Device , Bluetooth SIG.  
HID\_Interrupt 0x0013 See Human Interface Device, Bluetooth SIG.  
UPnP 0x0015 See \[ESDP\] , Bluetooth SIG.  
AVCTP 0x0017 See Audio/Video Control Transport Protocol , Bluetooth SIG.  
AVDTP 0x0019 See Audio/Video Distribution Transport Protocol , Bluetooth SIG.  
AVCTP\_Browsing 0x001B See Audio/Video Remote Control Profile, Bluetooth SIG  
UDI\_C-Plane 0x001D See the Unrestricted Digital Information Profile \[UDI\], Bluetooth SIG

二：L2CAP编程方法：

L2CAP编程非常重要，它和HCI基本就是Linux Bluetooth编程的基础了。几乎所有协议的连接，断连，读写

都是用L2CAP连接来做的。

1.创建L2CAP Socket：

socket(PF\_BLUETOOTH, SOCK\_RAW, BTPROTO\_L2CAP);

domain=PF\_BLUETOOTH, type可以是多种类型。protocol=BTPROTO\_L2CAP.

2.绑定：

// Bind to local address  
 memset(&addr, 0, sizeof(addr));  
 addr.l2\_family = AF\_BLUETOOTH;  
 bacpy(&addr.l2\_bdaddr, &bdaddr); //bdaddr为本地Dongle BDAddr

if (bind(sk, (struct sockaddr \*) &addr, sizeof(addr)) < 0) \{  
  perror("Can't bind socket");  
  goto error;  
 \}

3.连接

memset(&addr, 0, sizeof(addr));  
addr.l2\_family = AF\_BLUETOOTH;  
bacpy(addr.l2\_bdaddr, src);

addr.l2\_psm = xxx;

if (connect(sk, (struct sockaddr \*) &addr, sizeof(addr)) < 0) \{  
  perror("Can't connect");  
  goto error;  
 \}

注意：

struct sockaddr\_l2 \{  
 sa\_family\_t l2\_family;  //必须为 AF\_BLUETOOTH  
 unsigned short l2\_psm;  //与前面PSM对应,这一项很重要  
 bdaddr\_t l2\_bdaddr;     //Remote Device BDADDR  
 unsigned short l2\_cid;  
\};

4. 发送数据到Remote Device：

send()或write()都可以。

5. 接收数据：

revc() 或read()

以下为实例：

注：在Bluetooth下，主动去连接的一端作为主机端。被动等别人连接的作为Client端。

背景知识1：Bluetooth设备的状态

之前HCI编程时，是用 ioctl(HCIGETDEVINFO)得到某个Device Info（hci\_dev\_info).其中flags当时解释的

很简单。其实它存放着Bluetooth Device（例如：USB Bluetooth Dongle）的当前状态：

其中，UP,Down状态表示此Device是否启动起来。可以使用ioctl(HCIDEVUP)等修改这些状态。

另外：就是Inquiry Scan, PAGE Scan这些状态：

Sam在刚开始自己做L2CAP层连接时，使用另一台Linux机器插USB Bluetooth Dongle作Remote Device。怎么

也没法使用inquiry扫描到remote设备，也没法连接remote设备,甚至无法使用l2ping ping到remote设备。

觉得非常奇怪，后来才发现Remote Device状态设置有问题。没有设置PSCAN和ISCAN。

Inquiry Scan状态表示设备可被inquiry. Page Scan状态表示设备可被连接。

\#hciconfig hci0 iscan

\#hciconfig hci0 pscan

或者：\#hciconfig hci0 piscan

就可以设置为PSCAN或者iSCAN状态了。

编程则可以使用ioctl(HCISETSCAN) . dev\_opt = SCAN\_INQUIRY;dr.dev\_opt = SCAN\_PAGE;dr.dev\_opt =

SCAN\_PAGE | SCAN\_INQUIRY;

则可以inquiry或者connect了。

实战Linux Bluetooth编程（五） Socket与Bluetooth

Linux下Bluetooth编程，借用了Socket体制。也就是说，BlueZ Kernel部分将Bluetooth协议栈以网络协议

的形式添加进网络协议栈，这样极大的方便了用户编程。下面Sam就结合Socket概念将Linux Bluetooth做个

研究。

1957年10月4日，星期五，苏联发射了人类历史上第一颗人造地球卫星--Sputnik.这标志着人类外太空时代

的开始。这颗卫星篮球大小，在发射98分钟后到达运转轨道，可以通过短波40.002MHz收听到它的声音。这

也标志着苏联在航天科技领域超过美国。但当时谁能想到，Sputnik的升空竟然促进了TCP/IP和Internel的

出现。(Sam：不知道朝鲜那个轨道高度几百米的卫星会促成什么出现，嘿嘿)。被Sputnik所刺激的美国总统

艾森豪威尔五星上将积极推动ARPA。又因为美国政府为了公平起见，每次采购计算机时都从不同设备制造商

处购买。大家很快发现，各个计算机无法兼容。1962年，Licklider提出：各个计算机高度自治，但他们也

应该能够相互通讯。这就是ARPA网，它成为Internel的前身。

一：理解Socket：

在使用手机与女朋友联系时，必须用手机拨她的号码，然后心情坎坷的等待她的应答。当双方通话时，就建

立了一个具有两个端点的通信线路。

Linux中的Socket与电话非常相似。具体问题，稍后再分析。

二：Socket域（domain），类型（type），协议（protoclo）以及Bluetooth中的具体使用：

Berkeley小组在构思BSD Socket时，TCP/IP协议也还处在发展之中，其他一些很有竞争力的协议如X.25等也

在发展，其它很多协议还在构思与研究阶段（Bluetooth还没出生）。为了使Socket可以应用于各种不同协

议，domain的作用就在于此。

domain指出想要使用的协议族。

不得不佩服Berkeley小组的前瞻力。他们考虑在指定Socket时，可能还需要进一步的细分类目：

1.某个协议族（Domain）中的一个或多个协议。

2.某个协议中的一个或多个地址格式。

这个规则在TCP/IP等协议栈时并不明显，因为某个协议族只有同一种地址格式。但在Bluetooth中则非常有

用。

protocol则用来指出在此协议族中的具体某个协议。

虽然在TCP/IP协议栈中，因为协议族中某个type的协议栈只有一种，所以此项为0，但Bluetooth中，这一项

则非常有用。

type用来指出此协议族中的具体协议的Socket类型为何种：

SOCK\_STREAM,SOCK\_DGRAM,SOCK\_SEQPACKET,SOCK\_RAW.

三：Socket地址：

每一种通信协议都对网络地址格式作了明确规定。协议族（Domain）+ 协议（protocol）的作用就是指明使

用哪种地址类型。

BSD Socket是在ANSI C 标准被采纳之前开发的，所以没有使用（void\*)数据类型来接收结构化的地址。BSD

的解决方案是定义了一个通用的地址结构：

struct sockaddr

sa\_family\_t sa\_family;  //地址族

char sa\_data\[14\];   //地址数据

\};

sa\_family长度2字节，用来存放地址族。

sa\_data长度14字节，用来存放具体的协议的地址数据。

如果是用AF\_INET(IPV4),则它的地址类型sockaddr\_in如下，刚好与struct sockaddr对应

struct sockaddr\_in

sa\_family\_t sin\_family;    //地址族

uint16\_t sip\_port;         //端口

struct in\_addr sin\_addr;   //Internel 地址

unsigned char sin\_zero\[8\]; //占位字节

\};

如果是用Bluetooth协议族（PF\_BLUETOOTH）中的协议l2cap（BTPROTO\_L2CAP),则地址格式如下：

struct sockaddr\_l2

\{  
 sa\_family\_t l2\_family;  //地址族  
 unsigned short l2\_psm;  //PSM  
 bdaddr\_t l2\_bdaddr;     //Bluetooth 地址  
 unsigned short l2\_cid;  
\};

四：Bluetooth Socket的建立和地址绑定：

int socket(int domain, int type, int protocol);

domain:使用 PF\_BLUETOOTH。

protocol:使用想要建立的Socket的protocol.如果想建立HCI Socket：BTPROTO\_HCI。

L2cap:BTPROTO\_L2CAP

type:SOCK\_SEQPACKET,以Packet为单位读取。SOCK\_SAW:原始Socket。

int bind(int sockfd, const struct sockaddr \*my\_addr, socklen\_t addrlen);

将socket与某个地址绑定。

嘿嘿，接着前面Socket与手机的话题，建立一个Socket。就相当于是一个手机，地址，则相当于手机号码。

一个手机想要别人打进来，就需要让别人知道电话号码。 而一个Bluetooth 设备想要别人能够连接，也需

要将Socket与Bluetooth地址绑定。

山寨机让我们知道了双卡双待，Bluetooth也可以实现这一点。建立一个Socket，只是一个手机，它可以与

多个bdaddr绑定。这就是hci0,hci1等等。

五：理解网络字序：

对于多字节数据，不同的CPU有不同的组织方式，最基本的字节序位：

小端（little-endian）: 将低序字节存储在起始位置。

大端（big-endian）:将高序字节存储在其实位置。

Intel CPU使用小端。Motorola等CPU使用大端，网络上传输数据的标准顺序为大端。

他们之间的转化：

htobs（）， htonl() 主机到网络

ntohl() , ntohs() 网络到主机。

实战Linux Bluetooth编程(六) L2CAP编程实例  
例一：发送Signaling Packet：

Signaling Command是2个Bluetooth实体之间的L2CAP层命令传输。所以得Signaling Command使用CID

0x0001.

多个Command可以在一个C-frame（control frame）中发送。

如果要直接发送Signaling Command.需要建立SOCK\_RAW类型的L2CAP连接Socket。这样才有机会自己填充

Command Code，Identifier等。

以下是一个发送signaling Command以及接收Response的简单例子：

int main(int argc, char\*\* argv)  
\{  
 int l2\_sck = 0;  
 int iRel  = 0;  
 struct sockaddr\_l2 local\_l2\_addr;  
 struct sockaddr\_l2 remote\_l2\_addr;  
 char str\[24\] =\{0\};  
 int len = 0;  
 int size = 50;  
 char\* send\_buf;  
 char\* recv\_buf;  
 int i = 0;  
 int id = 1; //不要为0  
   
 send\_buf = malloc(L2CAP\_CMD\_HDR\_SIZE + size);  
 recv\_buf = malloc(L2CAP\_CMD\_HDR\_SIZE + size);

if(argc < 2)  
 \{  
  printf("/n%s <bdaddr>/n", argv\[0\]);  
  exit(0);  
 \}

// create l2cap raw socket  
 l2\_sck = socket(PF\_BLUETOOTH, SOCK\_RAW, BTPROTO\_L2CAP); //创建L2CAP protocol的RAW Packet  
 if(l2\_sck < 0)  
 \{  
  perror("/nsocket:");  
  return -1;  
 \}

//bind  
 memset(&local\_l2\_addr, 0, sizeof(struct sockaddr\_l2));  
 local\_l2\_addr.l2\_family = PF\_BLUETOOTH;  
 bacpy(&local\_l2\_addr.l2\_bdaddr , BDADDR\_ANY);

iRel = bind(l2\_sck, (struct sockaddr\*) &local\_l2\_addr, sizeof(struct sockaddr\_l2));  
 if(iRel < 0)  
 \{  
  perror("/nbind()");  
  exit(0);  
 \}

//connect  
 memset(&remote\_l2\_addr, 0 , sizeof(struct sockaddr\_l2));  
 remote\_l2\_addr.l2\_family = PF\_BLUETOOTH;  
 //printf("/nConnect to %s/n", argv\[1\]);  
 str2ba(argv\[1\], &remote\_l2\_addr.l2\_bdaddr);

iRel = connect(l2\_sck, (struct sockaddr\*)&remote\_l2\_addr, sizeof(struct sockaddr\_l2));  
 if(iRel < 0)  
 \{  
  perror("/nconnect()");  
  exit(0);  
 \}

//get local bdaddr  
 len = sizeof(struct sockaddr\_l2);  
 memset(&local\_l2\_addr, 0, sizeof(struct sockaddr\_l2));

//注意，getsockname（）参数三是一个输入输出参数。输入时，为参数二的总体长度。输出时，

//为实际长度。  
 iRel = getsockname(l2\_sck, (struct sockaddr\*) &local\_l2\_addr, &len);  
 if(iRel < 0)  
 \{  
  perror("/ngetsockname()");  
  exit(0);  
 \}  
 ba2str(&(local\_l2\_addr.l2\_bdaddr), str);  
 //printf("/nLocal Socket bdaddr:\[%s\]/n", str);  
 printf("l2ping: \[%s\] from \[%s\](data size %d) .../n", argv\[1\], str, size);

for (i = 0; i < size; i++)  
  send\_buf\[L2CAP\_CMD\_HDR\_SIZE + i\] = 'A';

l2cap\_cmd\_hdr \*send\_cmd = (l2cap\_cmd\_hdr \*) send\_buf;  
 l2cap\_cmd\_hdr \*recv\_cmd = (l2cap\_cmd\_hdr \*) recv\_buf;

send\_cmd->ident = id;  //如上图所示，这一项为此Command Identifier  
 send\_cmd->len   = htobs(size);  
 send\_cmd->code = L2CAP\_ECHO\_REQ;  //如上图所示，此项为Command code.这项定为：

//Echo Request。对端会发送Response回来。code=L2CAP\_ECHO\_RSP

while(1)  
 \{  
  send\_cmd->ident = id;  
  if(send(l2\_sck, send\_buf, size + L2CAP\_CMD\_HDR\_SIZE, 0) <= 0)  
  \{  
   perror("/nsend():");  
  \}  
   
  while(1)  
  \{  
   if(recv(l2\_sck, recv\_buf, size + L2CAP\_CMD\_HDR\_SIZE, 0) <= 0)  
   \{  
    perror("/nrecv()");  
   \}  
    
   if (recv\_cmd->ident != id)  
    continue;

if( recv\_cmd->code == L2CAP\_ECHO\_RSP)  
   \{  
    //printf("/nReceive Response Packet./n");  
    printf("%d bytes from \[%s\] id %d/n", recv\_cmd->len, argv\[1\], recv\_cmd->ident);  
    break;  
   \}  
    
  \}  
  sleep(1);  
  id ++;  
   
 \}

close(l2\_sck);

return 0;  
\}

所以说，如果想要发送接收signaling Command。只需要建立l2cap RAW socket. 并按规则填充command id,

command code等。就可以接收发送了。

Command Code: 这个值放在l2cap.h中。

\#define L2CAP\_COMMAND\_REJ 0x01  
\#define L2CAP\_CONN\_REQ  0x02  
\#define L2CAP\_CONN\_RSP  0x03  
\#define L2CAP\_CONF\_REQ  0x04  
\#define L2CAP\_CONF\_RSP  0x05  
\#define L2CAP\_DISCONN\_REQ 0x06  
\#define L2CAP\_DISCONN\_RSP 0x07  
\#define L2CAP\_ECHO\_REQ  0x08  
\#define L2CAP\_ECHO\_RSP  0x09  
\#define L2CAP\_INFO\_REQ  0x0a  
\#define L2CAP\_INFO\_RSP  0x0b

例二：任意PSM的L2CAP连接间数据的传输：

此例子中：Server，client其实是使用网络的概念定义的。

server用来监听指定PSM的连接，并监听数据。同时，利用poll来查看peer是否断掉了。

Server：

\#include <stdio.h>  
\#include <sys/types.h>          
\#include <sys/socket.h>  
\#include <stdlib.h>  
\#include <poll.h>

\#include <bluetooth/bluetooth.h>  
\#include <bluetooth/hci.h>  
\#include <bluetooth/hci\_lib.h>  
\#include <bluetooth/l2cap.h>

void \* Read\_thread(void\* pSK);

int main(int argc, char\*\* argv)  
\{  
 int iRel = 0;  
 int sk = 0;  
 struct sockaddr\_l2 local\_addr;  
 struct sockaddr\_l2 remote\_addr;  
 int len;  
 int nsk = 0;  
 pthread\_t nth = 0;  
 struct l2cap\_options opts;  
 int optlen = 0;  
 int slen = 0;  
 char str\[16\] = \{0\};

if(argc < 2)  
 \{  
  printf("/nUsage:%s psm/n", argv\[0\]);  
  exit(0);  
 \}

// create l2cap socket  
 sk = socket(PF\_BLUETOOTH, SOCK\_SEQPACKET, BTPROTO\_L2CAP);  //发送数据，使用SOCK\_SEQPACKET为好  
 if(sk < 0)  
 \{  
  perror("/nsocket():");  
  exit(0);  
 \}

//bind  
 local\_addr.l2\_family = PF\_BLUETOOTH;  
 local\_addr.l2\_psm = htobs(atoi(argv\[argc -1\]));  //last psm  
 bacpy(&local\_addr.l2\_bdaddr, BDADDR\_ANY);  
 iRel = bind(sk, (struct sockaddr \*)&local\_addr, sizeof(struct sockaddr));  
 if(iRel < 0)  
 \{  
  perror("/nbind()");  
  exit(0);  
 \}

//get opts

// in mtu 和 out mtu.每个包的最大值  
 memset(&opts, 0, sizeof(opts));  
 optlen = sizeof(opts);  
 getsockopt(sk, SOL\_L2CAP, L2CAP\_OPTIONS, &opts, &optlen);  
 printf("/nomtu:\[%d\]. imtu:\[%d\]. flush\_to:\[%d\]. mode:\[%d\]/n", opts.omtu, opts.imtu,

opts.flush\_to, opts.mode);

//set opts. default value  
 opts.omtu = 0;  
 opts.imtu = 672;  
 if (setsockopt(sk, SOL\_L2CAP, L2CAP\_OPTIONS, &opts, sizeof(opts)) < 0)  
 \{  
  perror("/nsetsockopt():");  
  exit(0);  
 \}

//listen  
 iRel = listen(sk, 10);  
 if(iRel < 0)  
 \{  
  perror("/nlisten()");  
  exit(0);  
 \}

len = sizeof(struct sockaddr\_l2);  
 while(1)  
 \{  
  memset(&remote\_addr, 0, sizeof(struct sockaddr\_l2));  
  nsk = accept(sk, (struct sockaddr\*)(&remote\_addr), &len);  
  if(nsk < 0)  
  \{  
   perror("/naccept():");  
   continue;  
  \}  
  ba2str(&(remote\_addr.l2\_bdaddr), str);  
  printf("/npeer bdaddr:\[%s\]./n", str);  //得到peer的信息

iRel = pthread\_create(&nth, NULL, Read\_thread, &nsk);  
  if(iRel != 0)  
  \{  
   perror("pthread\_create():");  
   continue;  
  \}  
  pthread\_detach(nth);  // 分离之  
   
 \}

return 0;  
\}

void \* Read\_thread(void\* pSK)  
\{  
 //struct pollfd fds\[10\];  
 struct   pollfd   fds\[100\];  
 char buf\[1024\] = \{0\};  
 int iRel = 0;  
 int exit\_val = 0;

//fds\[0\].fd = \*(int\*)pSK;  
 //fds\[0\].events = POLLIN | POLLHUP;

fds\[0\].fd   =   (int)(\*(int\*)pSK);  
 fds\[0\].events   =   POLLIN   |   POLLHUP;

while(1)  
 \{  
  if(poll(fds, 1, -1) < 0)  
  \{  
   perror("/npoll():");  
  \}  
  if(fds\[0\].revents & POLLHUP)  
  \{  
   //hang up  
   printf("/n\[%d\] Hang up/n", \*(int\*)pSK);  
   close(\*(int\*)pSK);  
   pthread\_exit(&exit\_val);

break;  
  \}

if(fds\[0\].revents & POLLIN)  
  \{  
   memset(buf, 0 , 1024);  
   //read data  
   iRel = recv(\*(int\*)pSK, buf, 572, 0);  
   //printf("/nHandle\[%d\] Receive \[%d\] data:\[%s\]", \*(int\*)pSK, iRel, buf);  
  \}  
   
 \}

return 0;  
\}

client:

\#include <stdio.h>  
\#include <sys/types.h>          
\#include <sys/socket.h>  
\#include <unistd.h>

\#include <bluetooth/bluetooth.h>  
\#include <bluetooth/hci.h>  
\#include <bluetooth/hci\_lib.h>  
\#include <bluetooth/l2cap.h>

int main(int argc, char\*\* argv)  
\{  
 int sk;  
 int i = 0;  
 char buf\[24\] = "Sam is Good Guy!";  
 struct sockaddr\_l2 local\_addr;  
 struct sockaddr\_l2 remote\_addr;  
 int iRel = 0;

if(argc < 3)  
 \{  
  printf("/nUsage:%s <bdaddr> <PSM>/n", argv\[0\]);  
  exit(0);  
 \}

sk = socket(PF\_BLUETOOTH, SOCK\_SEQPACKET, BTPROTO\_L2CAP);  
 if(sk < 0)  
 \{  
  perror("/nsocket():");  
  exit(0);  
 \}

//bind. bluetooth好像不许有无名Socket  
 local\_addr.l2\_family = PF\_BLUETOOTH;  
 bacpy(&local\_addr.l2\_bdaddr, BDADDR\_ANY);  
 iRel = bind(sk, (struct sockaddr \*)&local\_addr, sizeof(struct sockaddr));  
 if(iRel < 0)  
 \{  
  perror("/nbind()");  
  exit(0);  
 \}

memset(&remote\_addr, 0, sizeof(struct sockaddr\_l2));  
 remote\_addr.l2\_family = PF\_BLUETOOTH;  
 str2ba(argv\[1\], &remote\_addr.l2\_bdaddr);  
 remote\_addr.l2\_psm = htobs(atoi(argv\[argc -1\]));  
   
 connect(sk, (struct sockaddr\*)&remote\_addr, sizeof(struct sockaddr\_l2));

for(i = 0; i < 60; i++)  
 \{  
  iRel = send(sk, buf, strlen(buf)+1, 0);  
  printf("Send \[%d\] data/n", strlen(buf)+1);  
  sleep(1);  
 \}

close(sk);  
 return 0;  
\}

注意：

1. 在Linux 网络编程中,主动发起连接方，因为不关心地址具体是什么，所以可以作为无名socket,也就是

说可以不bind. 但Bluetooth则不可以，一定需要bind.

2. poll可以查出连接断连，但需要注意：断开的revent值为：11001B。也就是说：POLLIN | POLLERR

|POLLHUP。

3. 被连接一方，一定要指定PSM。

战Linux Bluetooth编程 (七) SDP协议

Service Discovery Protocol(SDP)提供一种能力，让应用程序有方法发现哪种服务可用以及这种服务的特

性。

服务发现协议(SDP或Bluetooth SDP)在蓝牙协议栈中对蓝牙环境中的应用程序有特殊的含意，发现哪个服务

是可用的和确定这些可用服务的特征。SDP定义了bluetooth client发现可用bluetooth server服务和它们

的特征的方法。这个协议定义了客户如何能够寻找基于特定属性的服务而不让客户知道可用服务的任何知识

。SDP提供发现新服务的方法，在当客户登录到正在操作的蓝牙服务器的一个区域时是可用的时。

Service discovery机制提供client应用程序侦测server应用程序提供的服务的能力，并且能够得到服务的

特性。服务的品质包含服务type或服务class.

SDP也提供SDP server与SDP client之间的通讯。SDP server维护着一个服务条目(service record)列表.每

个服务条目描述一个单独的服务属性。 SDP client可以通过发送SDP request来得到服务条目。

如果一个client或者依附于client之上的应用程序决定使用某个service. 它创建一个单独的连接到service

提供者。 SDP 只提供侦测Service的机制，但不提供如何利用这些Service的机制。Sam觉得，这里其实是说

：SDP只提供侦测Service的办法，但如何用，SDP不管。

每个Bluetooth Device最多只能拥有一个SDP Server。如果一个Bluetooth Device只担任Client，那它不需

要SDP Server。但一个Bluetooth Device可以同时担当SDP Server和SDP client.

Service Record(Service 条目)：

一个service是一个实体为另一个实体提供信息，执行动作或控制资源。一个service可以由软件，硬件或软

硬件结合提供。

所有的Service信息都包含于一个Service Record内。一个Service Record 包含一个Service attribute

(Service属性) list.

在一个SDP Server内，每个Service Record拥有一个32-bit的唯一性数据。通常，这个唯一性只是在每个

SDP Server内部。 如果SDP Server S1 和SDP Server S2拥有同样的一个Service Record。那他们在不同

SDP Sever内的独特数值并不一定相同。

SDP在SDP Server增加或减少Service Record时，并不会通知SDP client.

Service Attribute(Service 属性)：

每个Service属性描述servcie的特性.一个Service Attribute由2部分：

Attribute ID + Attribute Value。

Attribute ID：16-bit无符号整数，用于区别一个Service Record内的其它属性。

Attribute Value：Attribute值。

Service Class：

每个Service 都是某个Service Class的实例. Service Class定义了Service Record中包含的Service 属性

。属性ID，属性值都被定义好了。

每个Service Class也有一个独特ID。这个Service Class标识符包含在属性值ServiceClassIDList属性中。

并描绘为UUID。自从Service Record中的属性格式以及含义依赖于Service Class后，ServiceClassIDList

属性变得非常重要。

Searching For Service:

Service Search transaction(事务？)允许client得到Service Record Handle。一旦SDP Client得到

Service Record Handle，它就可以请求这个Record内具体属性的值。

如果某个属性值UUID，则可以通过查找UUID查到这个属性。

UUID： universally unique identifier.(唯一性标识符)

SDP协议栈使用request/response模式工作，每个传输过程包括一个request protocol data unit(PDU)和一

个response PDU. SDP使用L2CAP连接传输数据。在发送Request PDU但未收到Response PDU之前，不能向同

一个server再发送Request PDU。

PDU：protocol Data unit

PDU ID：用来识别PDU。

TransactionID:

用来识别Request PUD以及Response PUD。并用来对比某个Response PUD是否对应着Request PUD。

[http_blog.chinaunix.net_u3_104073_showart_2081838.html]: http://blog.chinaunix.net/u3/104073/showart_2081838.html

实战Linux Bluetooth编程

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Bluetooth简介

相关 Android Bluetooth蓝牙开发：Bluetooth蓝牙设备配对Paired Bluetooth Devices（2）

相关 Android Bluetooth蓝牙开发：发现Bluetooth蓝牙设备（1）

相关 Linux Shell 编程实战技巧

相关实战Linux Bluetooth编程

相关实战Linux Bluetooth编程

相关 Linux下librtmp使用及编程实战

相关 Android Bluetooth 总结

相关 fatal error: bluetooth/bluetooth.h: No such file or directory

相关 Bluetooth® Low Energy Beacons