精华内容
下载资源
问答
  • Android 蓝牙架构概述

    2020-11-20 10:43:01
    Android 提供支持经典蓝牙蓝牙低功耗的默认蓝牙堆栈。借助蓝牙Android 设备可以创建个人区域网络,以便通过附近的蓝牙设备发送和接收数据。 在 Android 4.3 及更高版本中,Android 蓝牙堆栈可提供实现蓝牙低...

    Android 提供支持经典蓝牙和蓝牙低功耗的默认蓝牙堆栈。借助蓝牙,Android 设备可以创建个人区域网络,以便通过附近的蓝牙设备发送和接收数据。

    在 Android 4.3 及更高版本中,Android 蓝牙堆栈可提供实现蓝牙低功耗 (BLE) 的功能。要充分利用 BLE API,请遵循 Android 蓝牙 HCI 要求

    具有合格芯片组的 Android 设备可以实现经典蓝牙或同时实现经典蓝牙和 BLE。BLE 不能向后兼容较旧版本的蓝牙芯片组。

    在 Android 8.0 中,原生蓝牙堆栈完全符合蓝牙 5 的要求。要使用可用的蓝牙 5 功能,该设备需要具有符合蓝牙 5 要求的芯片组。

    注意与之前的版本相比,Android 8.0 在原生蓝牙堆栈方面的最大变化是使用了 Treble。Android 8.0 中的供应商实现必须使用 HIDL 而不是 libbt-vendor

    一.Android 8.0 架构

    应用框架:处于应用框架级别的是应用代码,它使用 android.bluetooth(位于frameworks/base/core/java/android/bluetooth/) API 与蓝牙硬件进行交互。此代码在内部通过 Binder IPC 机制调用蓝牙进程。

    蓝牙系统服务:位于 packages/apps/Bluetooth 中,被打包为 Android 应用,并在 Android 框架层实现蓝牙服务和配置文件。此应用通过 JNI 调用原生蓝牙堆栈。

    JNI:与 android.bluetooth 相关联的 JNI 代码位于 packages/apps/Bluetooth/jni 中。当发生特定蓝牙操作时(例如发现设备时),JNI 代码会调用蓝牙堆栈。

    蓝牙堆栈:Android系统在 AOSP 中提供了默认蓝牙堆栈,它位于 system/bt 中。该堆栈会实现常规蓝牙 HAL,并通过扩展程序和更改配置对其进行自定义。

    供应商实现:供应商设备使用硬件接口设计语言 (HIDL) 与蓝牙堆栈交互。

    HIDL:HIDL 定义了蓝牙堆栈和供应商实现之间的接口。要生成蓝牙 HIDL 文件,请将蓝牙接口文件传递到 HIDL 生成工具中。接口文件位于 hardware/interfaces/bluetooth 中。

    蓝牙堆栈开发:Android 8.0 蓝牙堆栈是一个完全限定的蓝牙堆栈。限定列表位于蓝牙 SIG 网站上的 QDID 97584 下。核心蓝牙堆栈位于 system/bt 中。

    二.Android 7.x 及更早版本的架构

    应用框架:处于应用框架级别的是应用代码,它利用 android.bluetooth API 与蓝牙硬件进行交互。此代码在内部通过 Binder IPC 机制调用蓝牙进程。

    蓝牙系统服务:位于 packages/apps/Bluetooth 中,被打包为 Android 应用,并在 Android 框架层实现蓝牙服务和配置文件。该应用通过 JNI 调用 HAL 层。

    JNI:与 android.bluetooth 相关联的 JNI 代码位于 packages/apps/Bluetooth/jni 中。当发生特定蓝牙操作时(例如发现设备时),JNI 代码会调用 HAL 层并从 HAL 接收回调。

    HAL硬件抽象层:定义了 android.bluetooth API 和蓝牙进程会调用的标准接口,并且必须实现该接口才能使蓝牙硬件正常工作。 蓝牙 HAL 的头文件是 hardware/libhardware/include/hardware/bluetooth.h。

    另外,请查看所有 hardware/libhardware/include/hardware/bt_*.h 文件。

    蓝牙堆栈:Android系统提供了默认蓝牙堆栈(位于 system/bt 中)。该堆栈会实现常规蓝牙 HAL,并通过扩展程序和更改配置对其进行自定义。

    供应商扩展:要添加自定义扩展程序和用于跟踪的 HCI 层,可以创建一个 libbt-vendor 模块并指定这些组件。

    实现HAL:蓝牙 HAL 位于 /hardware/libhardware/include/hardware/bluetooth.h 中。 bluetooth.h 文件包含蓝牙堆栈的基本接口,而且您必须实现其功能。

    三、Android源码分析

     

    一、BluetoothAdapter类的初始化

    frameworks/base/core/java/android/bluetooth/BluetoothAdapter.java

    public static synchronized BluetoothAdapter getDefaultAdapter() {

        if (sAdapter == null) {

            IBinder b = ServiceManager.getService(BLUETOOTH_MANAGER_SERVICE); //1

            if (b != null) {

                IBluetoothManager managerService = IBluetoothManager.Stub.asInterface(b);//2

                sAdapter = new BluetoothAdapter(managerService); //3

            else {

                Log.e(TAG, "Bluetooth binder is null");

            }

        }

        return sAdapter;

    }

    1.获取蓝牙管理服务,SystemServer进程中创建:mSystemServiceManager.startService(BluetoothService.class);

    2.使用Binder获取到BluetoothManagerService对象

    3.创建BluetoothAdapter对象,单例模式

     

    BluetoothAdapter(IBluetoothManager managerService) {

     

        if (managerService == null) {

            throw new IllegalArgumentException("bluetooth manager service is null");

        }

        try {

            mServiceLock.writeLock().lock();

            mService = managerService.registerAdapter(mManagerCallback); //1

        catch (RemoteException e) {

            Log.e(TAG, "", e);

        finally {

            mServiceLock.writeLock().unlock();

        }

        mManagerService = managerService;

        mLeScanClients = new HashMap<LeScanCallback, ScanCallback>();

        mToken = new Binder();

    }

    1.向BluetoothManagerService类注册回调函数

    frameworks/base/services/core/java/com/android/server/BluetoothManagerService.java

    public IBluetooth registerAdapter(IBluetoothManagerCallback callback) {

        if (callback == null) {

            Slog.w(TAG, "Callback is null in registerAdapter");

            return null;

        }

        Message msg = mHandler.obtainMessage(MESSAGE_REGISTER_ADAPTER); //1

        msg.obj = callback;

        mHandler.sendMessage(msg);

     

        return mBluetooth;

    }

    1.注册监听,将接口保存到RemoteCallbackList<IBluetoothManagerCallback> mCallbacks;

    二、Bluetooth Profiles的使用

    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    mBluetoothAdapter.getProfileProxy(mService, new A2dpServiceListener(),BluetoothProfile.A2DP);

    frameworks/base/core/java/android/bluetooth/BluetoothAdapter.java

    public boolean getProfileProxy(Context context, BluetoothProfile.ServiceListener listener,

            int profile) {

        if (context == null || listener == null) {

            return false;

        }

     

        if (profile == BluetoothProfile.HEADSET) {

            BluetoothHeadset headset = new BluetoothHeadset(context, listener);

            return true;

        else if (profile == BluetoothProfile.A2DP) {

            BluetoothA2dp a2dp = new BluetoothA2dp(context, listener);

            return true;

        else if (profile == BluetoothProfile.A2DP_SINK) {

            BluetoothA2dpSink a2dpSink = new BluetoothA2dpSink(context, listener);

            return true;

        else if (profile == BluetoothProfile.AVRCP_CONTROLLER) {

            BluetoothAvrcpController avrcp = new BluetoothAvrcpController(context, listener);

            return true;

        else if (profile == BluetoothProfile.HID_HOST) {

            BluetoothHidHost iDev = new BluetoothHidHost(context, listener);

            return true;

        else if (profile == BluetoothProfile.PAN) {

            BluetoothPan pan = new BluetoothPan(context, listener);

            return true;

        else if (profile == BluetoothProfile.HEALTH) {

            BluetoothHealth health = new BluetoothHealth(context, listener);

            return true;

        else if (profile == BluetoothProfile.MAP) {

            BluetoothMap map = new BluetoothMap(context, listener);

            return true;

        else if (profile == BluetoothProfile.HEADSET_CLIENT) {

            BluetoothHeadsetClient headsetClient = new BluetoothHeadsetClient(context, listener);

            return true;

        else if (profile == BluetoothProfile.SAP) {

            BluetoothSap sap = new BluetoothSap(context, listener);

            return true;

        else if (profile == BluetoothProfile.PBAP_CLIENT) {

            BluetoothPbapClient pbapClient = new BluetoothPbapClient(context, listener);

            return true;

        else if (profile == BluetoothProfile.MAP_CLIENT) {

            BluetoothMapClient mapClient = new BluetoothMapClient(context, listener);

            return true;

        else if (profile == BluetoothProfile.HID_DEVICE) {

            BluetoothHidDevice hidDevice = new BluetoothHidDevice(context, listener);

            return true;

        else if (profile == BluetoothProfile.HEARING_AID) {

            BluetoothHearingAid hearingAid = new BluetoothHearingAid(context, listener);

            return true;

        else {

            return false;

        }

    frameworks/base/core/java/android/bluetooth/BluetoothA2dp.java

     /*package*/ BluetoothA2dp(Context context, ServiceListener l) {

        mContext = context;

        mServiceListener = l;

        mAdapter = BluetoothAdapter.getDefaultAdapter(); 

        IBluetoothManager mgr = mAdapter.getBluetoothManager();//1

        if (mgr != null) {

            try {

                mgr.registerStateChangeCallback(mBluetoothStateChangeCallback);//2

            catch (RemoteException e) {

                Log.e(TAG, "", e);

            }

        }

     

        doBind();//3

    }

    1.从BluetoothAdapter类中获取到蓝牙管理服务对象

    2.注册A2DP状态回调接口

    3.绑定蓝牙A2DP Service

     

    boolean doBind() {

        Intent intent = new Intent(IBluetoothA2dp.class.getName());  //1

        ComponentName comp = intent.resolveSystemService(mContext.getPackageManager(), 0);

        intent.setComponent(comp);

        if (comp == null || !mContext.bindServiceAsUser(intent, mConnection, 0,

                mContext.getUser())) {

            Log.e(TAG, "Could not bind to Bluetooth A2DP Service with " + intent);

            return false;

        }

        return true;

    }

    1.绑定A2dpService(位于packages/apps/Bluetooth/src/com/android/bluetooth/a2dp/),实现与Bluetooth进程通信

    展开全文
  • Bluetooth API:android蓝牙接口,对应用层暴露蓝牙常用的接口,例如打开/关闭蓝牙。 Bluetooth APP:package/app/Bluetooth.apk,最终是运行在android.uid.bluetooth进程的APP 。 Fluoride Stack:Android蓝牙...

    一、Bluetooth OverView

    Bluetooth API:android蓝牙接口,对应用层暴露蓝牙常用的接口,例如打开/关闭蓝牙。

    Bluetooth APP:package/app/Bluetooth.apk,最终是运行在android.uid.bluetooth进程的APP 。

    Fluoride Stack:Android蓝牙协议栈,与Bluetooth通过JNI接通。

    二、子模块静态图

    展开全文
  • Android平台蓝牙架构

    千次阅读 2019-01-12 14:10:45
    Android 4.3 及更高版本中,Android 蓝牙堆栈可提供实现蓝牙低功耗 (BLE) 的功能。要充分利用 BLE API,请遵循 Android 蓝牙 HCI 要求。具有合格芯片组的 Android 设备可以实现经典蓝牙或同时实现经典蓝牙和 BLE...

    蓝牙

    在 Android 4.3 及更高版本中,Android 蓝牙堆栈可提供实现蓝牙低功耗 (BLE) 的功能。要充分利用 BLE API,请遵循 Android 蓝牙 HCI 要求。具有合格芯片组的 Android 设备可以实现经典蓝牙或同时实现经典蓝牙和 BLE。BLE 不能向后兼容较旧版本的蓝牙芯片组。

    在 Android 8.0 中,原生蓝牙堆栈完全符合蓝牙 5 的要求。要使用可用的蓝牙 5 功能,该设备需要具有符合蓝牙 5 要求的芯片组。

    Android 8.0 及以前版本之间的原生蓝牙堆栈的最大变化是使用高音。Android 8.0 中的供应商实现必须使用 HIDL 而不是 libbt-vendor。

    Android 8.0 架构

    蓝牙应用通过 Binder 与蓝牙进程进行通信。蓝牙进程使用 JNI 与蓝牙堆栈通信,并向开发者提供对各种蓝牙配置文件的访问权限。下图显示了蓝牙堆栈的常规结构:

    在这里插入图片描述

    应用框架

    处于应用框架级别的是应用代码,它使用 android.bluetooth API 与蓝牙硬件进行交互。此代码在内部通过 Binder IPC 机制调用蓝牙进程。

    蓝牙系统服务

    蓝牙系统服务(位于 packages/apps/Bluetooth 中)被打包为 Android 应用,并在 Android 框架层实现蓝牙服务和配置文件。此应用通过 JNI 调用原生蓝牙堆栈。

    JNI

    与 android.bluetooth 相关联的 JNI 代码位于 packages/apps/Bluetooth/jni 中。当发生特定蓝牙操作时(例如发现设备时),JNI 代码会调用蓝牙堆栈。

    蓝牙堆栈

    系统在 AOSP 中提供了默认蓝牙堆栈,它位于 system/bt 中。该堆栈会实现常规蓝牙 HAL,并通过扩展程序和更改配置对其进行自定义。

    供应商实现

    供应商设备使用硬件接口设计语言 (HIDL) 与蓝牙堆栈交互。

    HIDL

    HIDL 定义了蓝牙堆栈和供应商实现之间的接口。要生成蓝牙 HIDL 文件,请将蓝牙接口文件传递到 HIDL 生成工具中。接口文件位于 hardware/interfaces/bluetooth 下。

    Android 7.x 及更早版本的架构

    在这里插入图片描述

    HAL

    硬件抽象层定义了 android.bluetooth API 和蓝牙进程会调用的标准接口,并且您必须实现该接口才能使蓝牙硬件正常工作。蓝牙 HAL 的头文件是 hardware/libhardware/include/hardware/bluetooth.h。 另外,请查看所有 hardware/libhardware/include/hardware/bt_*.h 文件。


    Bluedroid下的蓝牙开发具体流程

    image

    展开全文
  • Android Bluetooth Architecture蓝牙代码架构部分(google 官方蓝牙框架)

    原文出处:http://blog.csdn.net/xubin341719/article/details/38519739

    感谢本文作者xubin341719的技术分享。

    一、Android Bluetooth Architecture蓝牙代码架构部分(google 官方蓝牙框架)


    Android的蓝牙系统,自下而上包括以下一些内容如上图所示:
    1、串口驱动
    Linux的内核的蓝牙驱动程、Linux的内核的蓝牙协议的层
    2、BlueZ的适配器
    BlueZ的(蓝牙在用户空间的函式库)

    bluez代码结构
    Bluetooth协议栈BlueZ分为两部分:内核代码和用户态程序及工具集。
    (1)、内核代码:由BlueZ核心协议和驱动程序组成
    Bluetooth协议实现在内核源代码 kernel/net/bluetooth中。包括hci,l2cap,hid,rfcomm,sco,SDP,BNEP等协议的实现。
    (2)、驱动程序:kernel/driver/bluetooth中,包含Linuxkernel对各种接口的
    Bluetooth device的驱动,如:USB接口,串口等。
    (3)、用户态程序及工具集:
    包括应用程序接口和BlueZ工具集。BlueZ提供函数库以及应用程序接口,便于程序员开发bluetooth应用程序。BlueZ utils是主要工具集,实现对bluetooth设备的初始化和控制。

    3、蓝牙相关的应用程序接口
    Android.buletooth包中的各个Class(蓝牙在框架层的内容-----java)

    类名

    作用

    BluetoothAdapter

    本地蓝牙设备的适配类,所有的蓝牙操作都要通过该类完成

    BluetoothClass

    用于描述远端设备的类型,特点等信息

    BluetoothDevice

    蓝牙设备类,代表了蓝牙通讯过程中的远端设备

    BluetoothServerSocket

    蓝牙设备服务端,类似ServerSocket

    BluetoothSocket

    蓝牙设备客户端,类似Socket

    BluetoothClass.Device

    蓝牙关于设备信息

    BluetoothClass.Device.Major

    蓝牙设备管理

    BluetoothClass.Service

    蓝牙相关服务

    同样下图也是一张比较经典的蓝牙代码架构图(google官方提供)


    二、蓝牙通过Hciattach启动串口流程:
    1、hciattach总体流程


    2、展讯hciattach代码实现流程:

    三、具体代码分析
    1、initrc中定义

    idh.code\device\sprd\sp8830ec_nwcn\init.sc8830.rc

    [html]  view plain  copy
    1. service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark  
    2.     socket bluetooth stream 660 bluetooth bluetooth  
    3.     user bluetooth  
    4.     group wifi bluetooth net_bt_admin net_bt inet net_raw net_admin system  
    5.     disabled  
    6. oneshot  

    adb 下/dev/ttybt0(不同平台有所不同)

    PS 进程中:hicattch

    2、/system/bin/hciattach 执行的Main函数
    idh.code\external\bluetooth\bluez\tools\hciattach.c
    service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark
    传进两个参数,/dev/sttybt0 和 sprd_shark

    [html]  view plain  copy
    1. nt main(int argc, char *argv[])  
    2. {  
    3. ………………  
    4.     for (n = 0; optind < argc; n++, optind++) {  
    5.         char *opt;  
    6.   
    7.         opt = argv[optind];  
    8.   
    9.         switch(n) {  
    10.         case 0://(1)、解析驱动的位置;  
    11.             dev[0] = 0;  
    12.             if (!strchr(opt, '/'))  
    13.                 strcpy(dev, "/dev/");  
    14.             strcat(dev, opt);  
    15.             break;  
    16.   
    17.         case 1://(2)、解析串口的配置相关参数;  
    18.             if (strchr(argv[optind], ',')) {  
    19.                 int m_id, p_id;  
    20.                 sscanf(argv[optind], "%x,%x", &m_id, &p_id);  
    21.                 u = get_by_id(m_id, p_id);  
    22.             } else {  
    23.                 u = get_by_type(opt);  
    24.             }  
    25.   
    26.             if (!u) {  
    27.                 fprintf(stderr, "Unknown device type or id\n");  
    28.                 exit(1);  
    29.             }  
    30.   
    31.             break;  
    32.   
    33.         case 2://(3)、通过对前面参数的解析,把uart[i]中的数值初始化;  
    34.             u->speed = atoi(argv[optind]);  
    35.             break;  
    36.   
    37.         case 3:  
    38.             if (!strcmp("flow", argv[optind]))  
    39.                 u->flags |=  FLOW_CTL;  
    40.             else  
    41.                 u->flags &= ~FLOW_CTL;  
    42.             break;  
    43.   
    44.         case 4:  
    45.             if (!strcmp("sleep", argv[optind]))  
    46.                 u->pm = ENABLE_PM;  
    47.             else  
    48.                 u->pm = DISABLE_PM;  
    49.             break;  
    50.   
    51.         case 5:  
    52.             u->bdaddr = argv[optind];  
    53.             break;  
    54.         }  
    55.     }  
    56.   
    57. ………………  
    58.     if (init_speed)//初始化串口速率;  
    59.         u->init_speed = init_speed;  
    60. ………………  
    61.     n = init_uart(dev, u, send_break, raw);//(4)、初始化串口;  
    62. ………………  
    63.   
    64.     return 0;  
    65. }  

    (1)、解析驱动的位置;

    [html]  view plain  copy
    1.             if (!strchr(opt, '/'))  
    2.                 strcpy(dev, "/dev/");  
    3. service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark  
    4. dev = /dev/ttyb0  

    (2)、解析串口的配置相关参数;获取参数对应的结构体;

    [html]  view plain  copy
    1.     u = get_by_id(m_id, p_id);  
    2. static struct uart_t * get_by_id(int m_id, int p_id)  
    3. {  
    4.     int i;  
    5.     for (i = 0; uart[i].type; i++) {  
    6.         if (uart[i].m_id == m_id && uart[i].p_id == p_id)  
    7.             return &uart[i];  
    8.     }  
    9.     return NULL;  
    10. }  

    这个函数比较简单,通过循环对比,如传进了的参数sprd_shark和uart结构体中的对比,找到对应的数组。如果是其他蓝牙芯片,如博通、RDA、BEKN等着到其相对应的初始化配置函数。

    [html]  view plain  copy
    1. struct uart_t uart[] = {  
    2.     { "any",        0x0000, 0x0000, HCI_UART_H4,   115200, 115200,  
    3.                 FLOW_CTL, DISABLE_PM, NULL, NULL     },  
    4.     { "sprd_shark",        0x0000, 0x0000, HCI_UART_H4,   115200, 115200,  
    5.                 FLOW_CTL, DISABLE_PM, NULL, init_sprd_config     },  
    6.   
    7.     { "ericsson",   0x0000, 0x0000, HCI_UART_H4,   57600,  115200,  
    8.                 FLOW_CTL, DISABLE_PM, NULL, ericsson },  
    9.   
    10. ………………  
    11.     { "bk3211",    0x0000, 0x0000, HCI_UART_BCSP,   115200, 921600, 0, DISABLE_PM,   NULL, beken_init, NULL},  
    12.     { NULL, 0 }  
    13. };  

    注意:init_sprd_config这个函数在uart_init中用到,这个函数其实对我们具体芯片的初始化配置。
    注释:HCI_UART_H4和HCI_UART_BCSP的区别如下图。

    (3)、通过对前面参数的解析,把uart[i]中的数值初始化;

    [html]  view plain  copy
    1. u->speed = atoi(argv[optind]);  
    2. break;  

    (4)、初始化串口;

    [html]  view plain  copy
    1. n = init_uart(dev, u, send_break, raw);  
    2. idh.code\external\bluetooth\bluez\tools\hciattach.c  
    3. /* Initialize UART driver */  
    4. int init_uart(char *dev, struct uart_t *u, int send_break)  
    5. {  
    6.  struct termios ti;  
    7.  int  fd, i;  
    8.  fd = open(dev, O_RDWR | O_NOCTTY);//打开串口设备,其中标志  
    9. //O_RDWR,可以对此设备进行读写操作;  
    10. //O_NOCTTY:告诉Unix这个程序不想成为“控制终端”控制的程序,不说明这个标志的话,任何输入都会影响你的程序。  
    11. //O_NDELAY:告诉Unix这个程序不关心DCD信号线状态,即其他端口是否运行,不说明这个标志的话,该程序就会在DCD信号线为低电平时停止。  
    12. //但是不要以控制 tty 的模式,因为我们并不希望在发送 Ctrl-C  
    13.  后结束此进程  
    14.  if (fd < 0) {  
    15.   perror(“Can’t open serial port”);  
    16.   return -1;  
    17.  }  
    18.  //drop fd’s data;  
    19.  tcflush(fd, TCIOFLUSH);//清空数据线  
    20.  if (tcgetattr(fd, &ti) < 0) {  
    21.   perror(“Can’t get port settings”);  
    22.   return -1;  
    23.  }  
    24.  cfmakeraw(&ti);  
    25. cfmakeraw sets the terminal attributes as follows://此函数设置串口终端的以下这些属性,  
    26. termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP  
    27. |INLCR|IGNCR|ICRNL|IXON);  
    28. termios_p->c_oflag &= ~OPOST;  
    29. termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);  
    30. termios_p->c_cflag &= ~(CSIZE|PARENB) ;  
    31. termios_p->c_cflag |=CS8;  
    32.  ti.c_cflag |= CLOCAL;//本地连接,无调制解调器控制  
    33.  if (u->flags & FLOW_CTL)  
    34.   ti.c_cflag |= CRTSCTS;//输出硬件流控  
    35.  else  
    36.   ti.c_cflag &= ~CRTSCTS;  
    37.  if (tcsetattr(fd, TCSANOW, &ti) < 0) {//启动新的串口设置  
    38.   perror(“Can’t set port settings”);  
    39.   return -1;  
    40.  }  
    41.  /* Set initial baudrate */  
    42.  if (set_speed(fd, &ti, u->init_speed) < 0) {//设置串口的传输速率bps, 也可以使  
    43. //用 cfsetispeed 和 cfsetospeed 来设置  
    44.   perror(“Can’t set initial baud rate”);  
    45.   return -1;  
    46.  }  
    47.  tcflush(fd, TCIOFLUSH);//清空数据线  
    48.  if (send_break)  
    49.   tcsendbreak(fd, 0);  
    50. //int tcsendbreak ( int fd, int duration );Sends a break for  
    51. //the given time.在串口线上发送0值,至少维持0.25秒。  
    52. //If duration is 0, it transmits zero-valued bits for at least 0.25 seconds, and  
    53. //not more than 0.5seconds.  
    54.  //where place register u’s init function;  
    55.  if (u->init && u->init(fd, u, &ti) < 0)  
    56. //所有bluez支持的蓝牙串口设备类型构成了一个uart结构数组,通过  
    57. //查找对应的uart类型,这个uart的init成员显示了它的init调用方法;  
    58. struct uart_t uart[] = {  
    59. { "any", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,FLOW_CTL, DISABLE_PM, NULL, NULL     },  
    60. { "sprd_shark", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,FLOW_CTL, DISABLE_PM, NULL, init_sprd_config     },  
    61.   
    62. { "ericsson", 0x0000, 0x0000, HCI_UART_H4,   57600,  115200,FLOW_CTL, DISABLE_PM, NULL, ericsson },  
    63. ………………  
    64.     { "bk3211",    0x0000, 0x0000, HCI_UART_BCSP,   115200, 921600, 0, DISABLE_PM,   NULL, beken_init, NULL},  
    65.     { NULL, 0的init函数名为bcsp,定义在本文件中**;  
    66.   return -1;  
    67.  tcflush(fd, TCIOFLUSH);//清空数据线  
    68.  /* Set actual baudrate */  
    69.  if (set_speed(fd, &ti, u->speed) < 0) {  
    70.   perror(“Can’t set baud rate”);  
    71.   return -1;  
    72.  }  
    73.  /* Set TTY to N_HCI line discipline */  
    74.  i = N_HCI;  
    75.  if (ioctl(fd, TIOCSETD, &i) < 0) {//  
    76. TIOCSETD int *ldisc//改变到 i 行规,即hci行规  
    77. Change to the new line discipline pointed to by ldisc. The available line disciplines are listed in   
    78. /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */  
    79. /* line disciplines */  
    80. #define N_TTY  0  
    81. ……  
    82. #define N_HCI  15  /* Bluetooth HCI UART */  
    83.   
    84.   perror(“Can’t set line discipline”);  
    85.   return -1;  
    86.  }  
    87.  if (ioctl(fd, HCIUARTSETPROTO, u->proto) < 0) {  
    88. //设置hci设备的proto操作函数集为hci_uart操作集;  
    89.   perror(“Can’t set device”);  
    90.   return -1;  
    91.  }  
    92.  return fd;  
    93. }  

    这里一个重要的部分是:u->init指向init_sprd_config
    4、uart具体到芯片的初始化init_sprd_config(这部分根据不同的芯片,对应进入其相应初始化部分)
    idh.code\external\bluetooth\bluez\tools\hciattach_sprd.c

    [html]  view plain  copy
    1. int sprd_config_init(int fd, char *bdaddr, struct termios *ti)  
    2. {  
    3.     int i,psk_fd,fd_btaddr,ret = 0,r,size=0,read_btmac=0;  
    4.     unsigned char resp[30];  
    5.     BT_PSKEY_CONFIG_T bt_para_tmp;  
    6.     char bt_mac[30] = {0};  
    7.     char bt_mac_tmp[20] = {0};  
    8.     uint8 bt_mac_bin[32]     = {0};  
    9.   
    10.     fprintf(stderr,"init_sprd_config in \n");  
    11. //(1)、这部分检查bt_mac,如果存在,从文件中读取,如果不存在,随机生成,并写入相应文件;  
    12.     if(access(BT_MAC_FILE, F_OK) == 0) {//这部分检查bt_mac  
    13.         LOGD("%s: %s exists",__FUNCTION__, BT_MAC_FILE);  
    14.         fd_btaddr = open(BT_MAC_FILE, O_RDWR);// #define BT_MAC_FILE        "/productinfo/btmac.txt"  
    15.         if(fd_btaddr>=0) {  
    16.             size = read(fd_btaddr, bt_mac, sizeof(bt_mac));//读取BT_MAC_FILE中的地址;  
    17.             LOGD("%s: read %s %s, size=%d",__FUNCTION__, BT_MAC_FILE, bt_mac, size);  
    18.             if(size == BT_RAND_MAC_LENGTH){  
    19.                         LOGD("bt mac already exists, no need to random it");  
    20.                         fprintf(stderr, "read btmac ok \n");  
    21.                         read_btmac=1;  
    22.             }  
    23. …………  
    24.     }else{//如果不存在,就随机生成一个bt_mac地址,写入/productinfo/btmac.txt  
    25.         fprintf(stderr, "btmac.txt not exsit!\n");  
    26.         read_btmac=0;  
    27.         mac_rand(bt_mac);  
    28.         LOGD("bt random mac=%s",bt_mac);  
    29.         printf("bt_mac=%s\n",bt_mac);  
    30.         write_btmac2file(bt_mac);  
    31.   
    32.         fd_btaddr = open(BT_MAC_FILE, O_RDWR);  
    33.         if(fd_btaddr>=0) {  
    34.             size = read(fd_btaddr, bt_mac, sizeof(bt_mac));  
    35.             LOGD("%s: read %s %s, size=%d",__FUNCTION__, BT_MAC_FILE, bt_mac, size);  
    36.             if(size == BT_RAND_MAC_LENGTH){  
    37.                         LOGD("bt mac already exists, no need to random it");  
    38.                         fprintf(stderr, "read btmac ok \n");  
    39.                         read_btmac=1;  
    40.             }  
    41.             close(fd_btaddr);  
    42. …………  
    43.     }  
    44.   
    45.     /* Reset the BT Chip */  
    46.   
    47.     memset(resp, 0, sizeof(resp));  
    48.     memset(&bt_para_tmp, 0, sizeof(BT_PSKEY_CONFIG_T) );  
    49.     ret = getPskeyFromFile(  (void *)(&bt_para_tmp) );//ret = get_pskey_from_file(&bt_para_tmp);//(2)、PSKey参数、射频参数的设定;  
    50.        if(ret != 0){//参数失败处理  
    51.             fprintf(stderr, "get_pskey_from_file faill \n");  
    52.             /* Send command from hciattach*/  
    53.             if(read_btmac == 1){  
    54.                 memcpy(bt_para_setting.device_addr, bt_mac_bin, sizeof(bt_para_setting.device_addr));// (3)、读取失败,把bt_para_setting中defaut参数写入;  
    55.             }  
    56.             if (write(fd, (char *)&bt_para_setting, sizeof(BT_PSKEY_CONFIG_T)) != sizeof(BT_PSKEY_CONFIG_T)) {  
    57.                 fprintf(stderr, "Failed to write reset command\n");  
    58.                 return -1;  
    59.             }  
    60.         }else{//getpskey成功处理  
    61.             /* Send command from pskey_bt.txt*/  
    62.             if(read_btmac == 1){  
    63.                 memcpy(bt_para_tmp.device_addr, bt_mac_bin, sizeof(bt_para_tmp.device_addr));  
    64.             }  
    65. …………  
    66.     return 0;  
    67. }  

    (1)、这部分检查bt_mac,如果存在,从文件中读取,如果不存在,随机生成,并写入相应文件/productinfo/btmac.txt
    (2)、PSKey参数、射频参数的设定;
    get_pskey_from_file(&bt_para_tmp);这个函数后面分析;
    (3)、读取失败,把bt_para_setting中defaut参数写入;频率、主从设备设定等……

    [html]  view plain  copy
    1. // pskey file structure default value  
    2. BT_PSKEY_CONFIG_T bt_para_setting={  
    3. 5,  
    4. 0,  
    5. 0,  
    6. 0,  
    7. 0,  
    8. 0x18cba80,  
    9. 0x001f00,  
    10. 0x1e,  
    11. {0x7a00,0x7600,0x7200,0x5200,0x2300,0x0300},  
    12. …………  
    13. };  

    5、get_pskey_from_file 解析相关射频参数
    idh.code\external\bluetooth\bluez\tools\pskey_get.c

    [html]  view plain  copy
    1. int getPskeyFromFile(void *pData)  
    2. {  
    3. …………  
    4.         char *BOARD_TYPE_PATH = "/dev/board_type";//(1)、判断PCB的版本;  
    5.         int fd_board_type;  
    6.         char board_type_str[MAX_BOARD_TYPE_LEN] = {0};  
    7.         int board_type;  
    8.         char *CFG_2351_PATH_2 = "/productinfo/2351_connectivity_configure.ini";//(2)、最终生成ini文件存储的位置;  
    9.         char *CFG_2351_PATH[MAX_BOARD_TYPE];  
    10.         (3)、针对不同PCB版本,不同的ini配置文件;  
    11.         CFG_2351_PATH[0] = "/system/etc/wifi/2351_connectivity_configure_hw100.ini";  
    12.         CFG_2351_PATH[1] = "/system/etc/wifi/2351_connectivity_configure_hw102.ini";  
    13.         CFG_2351_PATH[2] = "/system/etc/wifi/2351_connectivity_configure_hw104.ini";  

    (4)、下面函数就不做具体分析,大致意识是,根据/dev/board_type中,读取的PCB类型,设置不同的ini文件。   

    [html]  view plain  copy
    1. ………………  
    2.     ret = chmod(CFG_2351_PATH_2, 0644);  
    3.     ALOGE("chmod 0664 %s ret:%d\n", CFG_2351_PATH_2, ret);    
    4.     if(pBuf == pBuf2)  
    5.         free(pBuf1);  
    6. ………………  
    7. }  

    (1)、判断PCB的版本;
    char *BOARD_TYPE_PATH = "/dev/board_type";

    (2)、最终生成ini文件存储的位置,就是系统运行时读取ini文件的地方;
    char *CFG_2351_PATH_2 ="/productinfo/2351_connectivity_configure.ini";
    (3)、针对不同PCB版本,不同的ini配置文件;

    [html]  view plain  copy
    1. CFG_2351_PATH[0] = "/system/etc/wifi/2351_connectivity_configure_hw100.ini";  
    2. CFG_2351_PATH[1] = "/system/etc/wifi/2351_connectivity_configure_hw102.ini";  
    3. CFG_2351_PATH[2] = "/system/etc/wifi/2351_connectivity_configure_hw104.ini";  

    (4)、下面函数就不做具体分析,大致意识是,根据/dev/board_type中,读取的PCB类型,设置不同的ini文件。         覆盖到(2)中的文件。
    四、HCI_UART_H4和H4层的加入

    uart->hci_uart->Uart-H4->hci:从uart开始分析,介绍整个驱动层数据流(涉及tty_uart中断,   线路层ldisc_bcsp、tasklet、work queue、skb_buffer的等)

    这是数据的流动过程,最底层的也就是和硬件打交道的是uart层了,它的存在和起作用是通过串口驱动来保证的,这个请参阅附录,但是其它的层我们都不知道什么时候work的,下面来看。

    1、idh.code\kernel\drivers\bluetooth\hci_ldisc.c

    [html]  view plain  copy
    1. static int __init hci_uart_init(void)  
    2. {  
    3.     static struct tty_ldisc_ops hci_uart_ldisc;  
    4.     int err;  
    5.     /* Register the tty discipline */  
    6.   
    7.     memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));  
    8.     hci_uart_ldisc.magic        = TTY_LDISC_MAGIC;  
    9.     hci_uart_ldisc.name     = "n_hci";  
    10.     hci_uart_ldisc.open     = hci_uart_tty_open;  
    11.     hci_uart_ldisc.close        = hci_uart_tty_close;  
    12.     hci_uart_ldisc.read     = hci_uart_tty_read;  
    13.     hci_uart_ldisc.write        = hci_uart_tty_write;  
    14.     hci_uart_ldisc.ioctl        = hci_uart_tty_ioctl;  
    15.     hci_uart_ldisc.poll     = hci_uart_tty_poll;  
    16.     hci_uart_ldisc.receive_buf  = hci_uart_tty_receive;  
    17.     hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;  
    18.     hci_uart_ldisc.owner        = THIS_MODULE;  
    19.   
    20.     if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {//(1)、这部分完成ldisc的注册;  
    21.         BT_ERR("HCI line discipline registration failed. (%d)", err);  
    22.         return err;  
    23.     }  
    24.   
    25. #ifdef CONFIG_BT_HCIUART_H4  
    26.     h4_init();//(2)、我们蓝牙芯片用的是H4,这部分完成H4的注册;  
    27. #endif  
    28. #ifdef CONFIG_BT_HCIUART_BCSP  
    29.     bcsp_init();  
    30. #endif  
    31. ………………  
    32.     return 0;  
    33. }  

    (1)、这部分完成ldisc的注册;
    tty_register_ldisc(N_HCI,&hci_uart_ldisc)
    注册了一个ldisc,这是通过把新的ldisc放在一个ldisc的数组里面实现的,tty_ldiscs是一个全局的ldisc数组里面会根据序号对应一个ldisc,这个序号就是上层通过ioctl来指定的,比如我们在前面已经看到的:
    i = N_HCI;
    ioctl(fd, TIOCSETD, &i) < 0
    可以看到这里指定的N_HCI刚好就是这里注册的这个号码15;
    (2)、蓝牙芯片用的是H4,这部分完成H4的注册;
             h4_init();
    hci_uart_proto结构体的初始化:

    idh.code\kernel\drivers\bluetooth\hci_h4.c

    [html]  view plain  copy
    1. static struct hci_uart_proto h4p = {  
    2.     .id     = HCI_UART_H4,  
    3.     .open       = h4_open,  
    4.     .close      = h4_close,  
    5.     .recv       = h4_recv,  
    6.     .enqueue    = h4_enqueue,  
    7.     .dequeue    = h4_dequeue,  
    8.     .flush      = h4_flush,  
    9. };  

    H4的注册:
    idh.code\kernel\drivers\bluetooth\hci_h4.c

    [html]  view plain  copy
    1. int __init h4_init(void)  
    2. {  
    3.     int err = hci_uart_register_proto(&h4p);  
    4.   
    5.     if (!err)  
    6.         BT_INFO("HCI H4 protocol initialized");  
    7.     else  
    8.         BT_ERR("HCI H4 protocol registration failed");  
    9.   
    10.     return err;  
    11. }  

    这是通过hci_uart_register_proto(&bcsp)来完成的,这个函数非常简单,本质如下:
    hup[p->id]= p;其中static struct hci_uart_proto*hup[HCI_UART_MAX_PROTO];也就是说把对应于协议p的id和协议p连接起来,这样设计的好处是hci uart层本身可以支持不同的协议,包括h4、bcsp等,通过这个数组连接这些协议,等以后有数据的时候调用对应的协议来处理,这里比较关键的是h4里面的这些函数。
    五、HCI层的加入
    hci的加入是通过hci_register_dev函数来做的,这时候用户通过hciconfig就可以看到有一个接口了,通过这个接口用户可以访问底层的信息了,hci0已经生成;至于它在何时被加入的,我们再看看hciattach在内核里面的处理过程;

    1、TIOCSEATD的处理流程

    Ioctl的作用是设置一个新的ldisc;
    2、HCIUARTSETPROTO的处理流程:

    这部分比较重要,注册生成hci0, 初始化3个工作队列,hci_rx_work、hci_tx_work、hci_cmd_work;完成hci部分数据、命令的接收、发送。
    六、数据在驱动的传递流程
    1、uart数据接收
             这部分流程比较简单,其实就是注册一个tty驱动程序和相对应的函数,注册相应的open\close\ioctl等方法,通过应用open /dev/ttyS*操作,注册中断接收函数,接收处理蓝牙模块触发中断的数据。

    在这个中断函数里面会接受到来自于蓝牙模块的数据;在中断函数里面会先读取串口的状态寄存器判断是否是data准备好,如果准备好就调用serial_sprd_rx_chars函数来接收数据,下面看看这个函数是如何处理的:

    那就是把数据一个个的加入到uart层的缓冲区,直到底层不处于dataready状态,或者读了maxcount个数,当读完后就调用tty层的接口把数据传递给tty层,tty层则把数据交给了ldisc,于是控制权也就交给了hci_uart层;

    七、Hci_uart的数据接收
    它基本上就是要个二传手,通过:

    [html]  view plain  copy
    1. spin_lock(&hu->rx_lock);  
    2. hu->proto->recv(hu,(void *) data, count);  
    3. hu->hdev->stat.byte_rx+= count;  
    4. spin_unlock(&hu->rx_lock);  
    把数据交给了在它之上的协议层,对于我们的设置来说实际上就交给了h4层;
    八、H4层处理
    这层主要是通过函数h4_recv来处理的,根据协议处理包头、CRC等,然后调用更上层的hci_recv_frame来处理已经剥去h4包头的数据;

    如图:

    九、HCI以上的处理

    这里的hci_rx_work前面已经看到它了,它是一个工作队列用来处理hci层的数据接收的;先看是否有进程打开hci的socket用来监听数据,如果有的话,就把数据的一个copy发送给它,然后根据包的类型调用不同的处理函数,分别对应于event、acl、sco处理;
    hci_event_packet是对于事件的处理,里面包含有包括扫描,信号,授权,pin码,总之基本上上层所能收到的事件,基本都是在这里处理的,它的很多信息都是先存起来,等待上层的查询然后才告诉上层;
    hci_acldata_packet是一个经常的情况,也就是说上层通常都是使用的是l2cap的接口,而l2cap就是基于这个的,如下图所示:

    到这里如果有基于BTPROTO_L2CAP的socket,那么这个socket就可以收到数据了;再看看BTPROTO_RFCOMM的流程:

    十、 数据流程的总结
    简单总结一下,数据的流程,
    |基本上是:
    1, uart口取得蓝牙模块的数据;
    2, uart口通过ldisc传给hci_uart;
    3, hci_uart传给在其上的h4;
    4, h4传给hci层;
    5, hci层传给l2cap层
    6, l2cap层再传给rfcomm;

    展开全文
  • 一、Android Bluetooth Architecture蓝牙代码架构部分(google 官方蓝牙框架) Android蓝牙系统,自下而上包括以下一些内容如上图所示: 1、串口驱动 Linux的内核的蓝牙驱动程、Linux的内核的蓝牙协议的...
  • 看官们,在明白了BLE开发的基本概念后,我们还需要介绍Android中的蓝牙架构,这样才能更加全面地了解蓝牙。下面是官方提供的架构图: 从图可以看到Android对蓝牙的整体设计,最下层是蓝牙协议栈和芯片厂商自己的...
  • ESP32 蓝牙开发资料,用于了解ESP32内部的蓝牙实现。本⼿册为 ESP32 的蓝⽛架构简介,主要分三个章节介绍了蓝⽛、经典蓝⽛和蓝⽛低功耗⽅⾯的整体架构。注意,本⼿册仅针对 ESP-IDF V2.1 及以下版本。⽬录1. 蓝⽛ 1 ...
  • 蓝牙通讯机制建立在socket上; 要在两台设备上创建连接,需要实现服务器端和客户端机制 一般通讯过程: 在服务端等待客户端的连接请求, 有连接请求后连接, 连接成功后有一个socket(也即套接字), 通过socket套接...
  • Android ----蓝牙架构

    千次阅读 2017-01-22 10:40:14
    蓝牙: 1、fromwork 2、service 3、driver Bluetooth.apkbluedroid(芯片厂家) fromwork到service直接调用 service到driver利用service调用 fromwork到driver利用AIDL通信 相关...
  • Android4.2蓝牙基础架构学习

    万次阅读 2013-10-13 23:58:14
    接下来就要进入到真正的Android4.2蓝牙系统的学习了,Are you ready? 概述 本文不会涉及任何代码,主要对整个Android蓝牙结构进行一个...整个蓝牙的关系架构如下图所示: 下面逐一进行讲解: Applications:Andro
  • Android4.2蓝牙基础架构学习 分类: Jellybean Bluetooth Bluetooth 2013-10-13 23:58 863人阅读 评论(3) 收藏 举报 androidbluedroidjellybean蓝牙应用程序 接下来就要进入到真正的Android4.2蓝牙系统的学习...
  • android 蓝牙分析(一) ...一,android蓝牙架构 查看android 官网,可以获得架构相关的知识,如下图 二,从上到下的源码分析第一步Settings 应用 从架构图中,先找到蓝牙架构的应用app,然后逐渐往下。首先是
  • 蓝牙架构实现方案有哪几种?我们一般把整个蓝牙实现方案叫做蓝牙协议栈,因此这个问题也可以这么阐述:蓝牙协议栈有哪些具体的架构方案?在蓝牙协议栈中,host是什么?controller是什么?HCI又是什么?大家都知道,...
  • 不同的蓝牙架构可以用在不同的场景中。从而协议帧的架构方案也会不同。 转载自:https://www.cnblogs.com/schips/p/12293141.html 《三种蓝牙架构实现方案(蓝牙协议栈方案)》 蓝牙架构实现方案有哪几种?我们...
  • 第一篇:蓝牙综合介绍 ,主要介绍蓝牙的一些概念,产生背景,发展轨迹,市面蓝牙介绍,以及蓝牙开发板介绍。 第二篇:Transport层介绍,主要介绍蓝牙协议栈跟蓝牙芯片之前的硬件传输协议,比如基于UART的H4,H5,BCSP,...
  • 蓝牙Android 提供支持经典蓝牙蓝牙低功耗的默认蓝牙堆栈。借助蓝牙Android 设备可以创建个人区域网络,以便通过附近的蓝牙设备发送和接收数据。在 Android 4.3 及更高版本中,Android 蓝牙堆栈可提供实现蓝牙低...
  • Android 蓝牙驱动开发Android蓝牙驱动开发总结Android 蓝牙驱动开发一 Bluetooth 基本概念 1二 Android Bluetooth 架构 12.1 Bluetooth 架构图 12.2 Bluetooth 代码层次结构 3三 Bluetooth 协议栈分析 43.1 蓝牙...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,186
精华内容 3,674
关键字:

安卓蓝牙架构