2.19 haas506 2.0开发教程 - bluetooth - 蓝牙通信（仅支持2.2以上版本）

智云服

已于 2023-11-01 15:53:15 修改

阅读量1k

点赞数 1

分类专栏： haas506-M601/M320-2.2更新接口 haas506-M601/M320-2.0教程集合文章标签：嵌入式硬件 haas506 2.0 物联网 python

于 2022-07-22 15:30:32 首次发布

本文链接：https://blog.csdn.net/w_hizyf_m/article/details/125917654

版权

haas506-M601/M320-2.0教程集合同时被 2 个专栏收录

67 篇文章 7 订阅

订阅专栏

haas506-M601/M320-2.2更新接口

15 篇文章 0 订阅

订阅专栏

蓝牙

蓝牙技术是一种无线数据和语音通信开放的全球规范，它是基于低成本的近距离无线连接，为固定和移动设备建立通信环境的一种特殊的近距离无线技术连接。

案例说明

1.本案例分为主机和从机两部分进行测试,为了调试方便使用手机调试软件验证蓝牙功能
2.主机功能 : 通过搜索设备名称与UUID进行连接,连接成功后每隔固定时间向从机发送信号,并随时接收从机信息
3.从机功能 : 被主机连接后不断向主机发送消息,并随时接收主机发送的消息

从机测试(支持601与320)

1. 蓝牙调试工具

手机下载nRF connect作为主机连接开发板(手机浏览器搜索名字自行下载)
此软件是非常好用的蓝牙操控app，可以将多个软件连接上蓝牙并且还能极速上传，让你更有效率的完成超多的软件的配置，并且还能来智能的检测蓝牙和数据
在这里插入图片描述
软件打开后界面如下:
请添加图片描述

2. 设备端开发

将以下代码烧录进开发板

注意:

UUID必须使用128字节
设备名称可以自行更改,方便手机查找

mian.py

import bluetooth
from bluetooth import BLE
from bluetooth import UUID
import ustruct
import utime as time
from micropython import const

_ble_rx = None

#adv
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_APPEARANCE = const(0x19)

#从机UUID,UUID必须是128位字节,即16进制32位.
_UART_UUID = bluetooth.UUID("211e1c1a-1816-1412-0f0d-0b0907050301")
_UART_TX = (
    bluetooth.UUID("211e1c1a-1816-1412-0f0d-0b0907050301"),
    _FLAG_READ | _FLAG_WRITE ,
)
_UART_RX = (
    bluetooth.UUID("211e1c1a-1816-1412-0f0d-0b0907050301"),
    _FLAG_READ | _FLAG_NOTIFY,
)

_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)

# Generate a payload to be passed to gap_advertise(adv_data=...).
def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
    payload = bytearray()

    def _append(adv_type, value):
        nonlocal payload
        payload += ustruct.pack("BB", len(value) + 1, adv_type) + value

    _append(
        _ADV_TYPE_FLAGS,
        ustruct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
    )

    if name:
        _append(_ADV_TYPE_NAME, name)

    if services:
        for uuid in services:
            b = bytes(uuid)
            if len(b) == 2:
                _append(_ADV_TYPE_UUID16_COMPLETE, b)
            elif len(b) == 4:
                _append(_ADV_TYPE_UUID32_COMPLETE, b)
            elif len(b) == 16:
                _append(_ADV_TYPE_UUID128_COMPLETE, b)
 
    # See org.bluetooth.characteristic.gap.appearance.xml
    if appearance:
        _append(_ADV_TYPE_APPEARANCE, ustruct.pack("<h", appearance))

    return payload

class BLESimplePeripheral:
############################################################################################
    def __init__(self, ble, name="name"):      #从机设备名称,更改名字便于寻找
############################################################################################
        self._ble = ble
        self._payload = advertising_payload(name=name, services=[_UART_UUID])
        self._ble.active(True)
        self._ble.irq(self._irq)
        self._connections = set()
        self._write_callback = None
        ((self._handle_tx, self._handle_rx,),) = self._ble.gatts_register_services((_UART_SERVICE,))
        self._advertise()

    def _irq(self, event, data):
        global _ble_msg
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            print('connect')
        elif event == _IRQ_CENTRAL_DISCONNECT:
            print('disconnect')
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            buffer = self._ble.gatts_read(_ble_rx)
            print('recv data:',buffer)


    def send(self, data):
        #for conn_handle in self._connections:
        self._ble.gatts_notify(0, 0, data)

    def is_connected(self):
        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):
        self._write_callback = callback

def demo():
    ble = bluetooth.BLE()
    p = BLESimplePeripheral(ble)

    i = 0
    while True:
        if 1:
            for _ in range(3):
                data = str(i) + "_"
                p.send(data)
                i += 1
        time.sleep_ms(1000)

if __name__ == "__main__":
    demo()

3. 功能测试

开发板程序运行后,打开软件

在SCANNER界面可以看到所有可搜索蓝牙设备,找到开发板对应的蓝牙名字,点击连接

连接后自动跳转,点击Unknown Service

 1,向开发板发送消息
 2,当前开发板发送过来的消息

在这里插入图片描述

发送消息具体操作,点开1中向上箭头

在这里插入图片描述
开发板串口工具接受内容

查看手机详细接收内容

筛选消息中的log等级,选择不同等级可以看到相应等级的消息

主机测试(仅支持320)

将手机作为从机,使用开发板来连接手机.方便查看主从机之间的数据通信.
需要再下载一个软件

nRF connect 模拟从机数据
BLE调试助手进行数据传输

1. 模拟从机数据

将刚才调试好的从机信息clone到手机,以手机作为从机,方便调试.
断开与从机的连接,搜索蓝牙,找到从机设备克隆信息,clone好了之后会在手机保存从机的信息.
在这里插入图片描述

最后将从机蓝牙设备名字改成name,确保名字相同,方便主机连接

clone好了之后,手机就可以代替刚才的开发板作为从机使用.

2.BLE调试助手

为了方便看到从机的数据收发,需要再下载一个手机软件
在这里插入图片描述
进入软件之后界面,左上角切换到设备模式,打开广播
这样一个从机就设置好了

nRF connect 模拟从机数据
BLE调试助手进行数据传输

3. 主机设备端开发

烧录下列代码
注意:

修改需要连接的从机UUID,代码中有备注
修改需要连接的从机名name

mian.py

import bluetooth
from bluetooth import BLE
from bluetooth import UUID
import ustruct
import utime as time
from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)
_IRQ_GATTS_READ_REQUEST = const(4)
_IRQ_SCAN_RESULT = const(5)
_IRQ_SCAN_DONE = const(6)
_IRQ_PERIPHERAL_CONNECT = const(7)
_IRQ_PERIPHERAL_DISCONNECT = const(8)
_IRQ_GATTC_SERVICE_RESULT = const(9)
_IRQ_GATTC_SERVICE_DONE = const(10)
_IRQ_GATTC_CHARACTERISTIC_RESULT = const(11)
_IRQ_GATTC_CHARACTERISTIC_DONE = const(12)
_IRQ_GATTC_DESCRIPTOR_RESULT = const(13)
_IRQ_GATTC_DESCRIPTOR_DONE = const(14)
_IRQ_GATTC_READ_RESULT = const(15)
_IRQ_GATTC_READ_DONE = const(16)
_IRQ_GATTC_WRITE_DONE = const(17)
_IRQ_GATTC_NOTIFY = const(18)
_IRQ_GATTC_INDICATE = const(19)

_ADV_IND = const(0x00)
_ADV_DIRECT_IND = const(0x01)
_ADV_SCAN_IND = const(0x02)
_ADV_NONCONN_IND = const(0x03)

#########################################################################################################
_ENV_SENSE_UUID = bluetooth.UUID("211e1c1a-1816-1412-0f0d-0b0907050301")   #从机UUID
#########################################################################################################
print('_ENV_SENSE_UUID:',_ENV_SENSE_UUID)
# org.bluetooth.characteristic.temperature
_TEMP_UUID = bluetooth.UUID(0x2A6E)
_TEMP_CHAR = (
    _TEMP_UUID,
    bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
)
_ENV_SENSE_SERVICE = (
    _ENV_SENSE_UUID,
    (_TEMP_CHAR,),
)

_UART_SERVICE_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA77")
_UART_RX_CHAR_UUID = bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA77")
_UART_TX_CHAR_UUID = bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA77")

_MY_SERVICE_UUID = bluetooth.UUID(0x181A)

# org.bluetooth.characteristic.gap.appearance.xml
_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)

_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)

def decode_field(payload, adv_type):
    i = 0
    result = []
    while i + 1 < len(payload):
        if payload[i + 1] == adv_type:
            result.append(payload[i + 2 : i + payload[i] + 1])
        i += 1 + payload[i]
    return result
    
def decode_name(payload):
    n = decode_field(payload, _ADV_TYPE_NAME)
    return str(n[0], "utf-8") if n else ""

def decode_services(payload):
    services = []
    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
        services.append(bluetooth.UUID(ustruct.unpack("<h", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
        services.append(bluetooth.UUID(ustruct.unpack("<d", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
        services.append(bluetooth.UUID(u))
    return services

class BLETemperatureCentral:
    def __init__(self, ble):
        self._ble = ble
#############################################################################################################
        self._ble.gap_scan_name('name')   #从机设备名
#############################################################################################################
        self._ble.gattc_set_uuids(0xFFF2, 0xFFF1)
        self._ble.active(True)
        time.sleep_ms(3000)
        self._ble.irq(self._irq)
        self._reset()

    def _reset(self):
        # Cached name and address from a successful scan.
        self._name = None
        self._addr_type = None
        self._addr = None

        # Cached value (if we have one)
        self._value = None

        # Callbacks for completion of various operations.
        # These reset back to None after being invoked.
        self._scan_callback = None
        self._conn_callback = None
        self._read_callback = None

        # Persistent callback for when new data is notified from the device.
        self._notify_callback = None

        # Connected device.
        self._conn_handle = None
        self._start_handle = None
        self._end_handle = None
        self._value_handle = None

    def _irq(self, event, data):
        if event == _IRQ_SCAN_RESULT:
            addr_type, addr, adv_type, rssi, adv_data = data
            if adv_type in (_ADV_IND, _ADV_DIRECT_IND) and _ENV_SENSE_UUID in decode_services(adv_data):
                # Found a potential device, remember it and stop scanning.
                self._addr_type = addr_type
                self._addr = bytes(addr)  # Note: addr buffer is owned by caller so need to copy it.
                self._name = decode_name(adv_data) or "?"
                
        elif event == _IRQ_SCAN_DONE:
            time.sleep_ms(1000)
            self._ble.gap_scan(None)
            val = 1
            if self._scan_callback:
                if self._addr:
                    # Found a device during the scan (and the scan was explicitly stopped).
                    self._scan_callback(self._addr_type, self._addr, self._name)
                    self._scan_callback = None
                else:
                    # Scan timed out.
                    self._scan_callback(None, None, None)

        elif event == _IRQ_PERIPHERAL_CONNECT:
            print('connect')

        elif event == _IRQ_PERIPHERAL_DISCONNECT:
            print('disconnect')

        elif event == _IRQ_GATTC_SERVICE_RESULT:
            # Connected device returned a service.
            conn_handle, start_handle, end_handle, uuid = data
            if conn_handle == self._conn_handle and uuid == _ENV_SENSE_UUID:
                self._start_handle, self._end_handle = start_handle, end_handle

        elif event == _IRQ_GATTC_SERVICE_DONE:
            # Service query complete.
            if self._start_handle and self._end_handle:
                self._ble.gattc_discover_characteristics(
                    self._conn_handle, self._start_handle, self._end_handle
                )
            else:
                print("Failed to find environmental sensing service.")

        elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
            # Connected device returned a characteristic.
            conn_handle, def_handle, value_handle, properties, uuid = data
            if conn_handle == self._conn_handle and uuid == _TEMP_UUID:
                self._value_handle = value_handle

        elif event == _IRQ_GATTC_CHARACTERISTIC_DONE:
            # Characteristic query complete.
            if self._value_handle:
                # We've finished connecting and discovering device, fire the connect callback.
                if self._conn_callback:
                    self._conn_callback()
            else:
                print("Failed to find temperature characteristic.")

        elif event == _IRQ_GATTC_READ_RESULT:
            buffer = self._ble.gattc_read(0,0)
            print('recv data:',buffer)

        elif event == _IRQ_GATTC_READ_DONE:
            # Read completed (no-op).
            conn_handle, value_handle, status = data

        elif event == _IRQ_GATTC_NOTIFY:
            # The ble_temperature.py demo periodically notifies its value.
            conn_handle, value_handle, notify_data = data
            if conn_handle == self._conn_handle and value_handle == self._value_handle:
                self._update_value(notify_data)
                if self._notify_callback:
                    self._notify_callback(self._value)
        elif event == _IRQ_GATTC_WRITE_DONE:
            conn_handle, value_handle, status = data
            print("TX complete")

    # Returns true if we've successfully connected and discovered characteristics.
    def is_connected(self):
        return self._conn_handle is not None and self._value_handle is not None

    # Find a device advertising the environmental sensor service.
    def scan(self, callback=None):
        self._addr_type = None
        self._addr = None
        self._scan_callback = callback
        self._ble.gap_scan(20000, 30000, 30000)

    # Connect to the specified device (otherwise use cached address from a scan).
    def connect(self, addr_type=None, addr=None, callback=None):
        self._addr_type = addr_type or self._addr_type
        self._addr = addr or self._addr
        self._conn_callback = callback
        if self._addr_type is None or self._addr is None:
            return False
        self._ble.gap_connect(self._addr_type, self._addr)
        return True

    # Disconnect from current device.
    def disconnect(self):
        if not self._conn_handle:
            return
        self._ble.gap_disconnect(self._conn_handle)
        self._reset()

    # Issues an (asynchronous) read, will invoke callback with data.
    def read(self, callback):
        if not self.is_connected():
            return
        self._read_callback = callback
        self._ble.gattc_read(self._conn_handle, self._value_handle)

    # Sets a callback to be invoked when the device notifies us.
    def on_notify(self, callback):
        self._notify_callback = callback

    def _update_value(self, data):
        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
        self._value = ustruct.unpack("<h", data)[0] / 100
        return self._value

    def value(self):
        return self._value

    def write(self, v, response=False):
        # if not self.is_connected():
        #     return
        self._ble.gattc_write(0, 0, v, 1 if response else 0)
        print("data_send:", v)
v = 0
def demo():
    time.sleep_ms(2000)
    ble = bluetooth.BLE()
    central = BLETemperatureCentral(ble)
    time.sleep_ms(2000)
    not_found = False
    
    def on_scan(addr_type, addr, name):
        if addr_type is not None:
            print("Found sensor:", addr_type, addr, name)
            global v
            v = 1
        else:
            nonlocal not_found
            not_found = True
            print("No sensor found.")

    central.scan(callback=on_scan)
    global v
    while True:
        print('whit connect  -----------')
        if v ==1:
            central.connect()
            break
        time.sleep_ms(10)

    while True:
        ble.gattc_notify(1, 1)
        central.write('123', False)
        time.sleep_ms(1000)

if __name__ == "__main__":
    demo()

4.功能调试

代码下载好之后log如下
在这里插入图片描述
手机端显示连接,并能接收到数据

发送数据测试
在这里插入图片描述
电脑端接收到数据

class - bluetooth

active	irq	gap_advertise	gap_scan	gap_connect	gatts_register_services	gatts_read	gatts_write	gattc_read	gattc_write	gap_scan_name	gattc_set_uuids	gattc_notify
更改BLE射频的活动状态	事件处理	开启或关闭BLE广播	BLE扫描	连接BLE外围设备	注册GATT服务	读取本地值	写入本地值	GATT远程读操作	GATT远程写操作	扫描从设备蓝牙	设置特征值	通报使能

bluetooth - 蓝牙

模块功能:

该模块为板上的蓝牙控制器提供接口。目前支持低功耗蓝牙 (BLE)的Central（中央）, Peripheral（外设）, Broadcaster（广播者）, 和Observer （观察者）角色，以及 GATT 的服务器（Server）和客户端（Client）。

注意事项:

当前该模块只支持低功耗蓝牙（BLE）

bluetooth.BLE

类功能：

该类为低功耗蓝牙（BLE），是bluetooth模块中主要的类。

BLE - 创建BLE对象

函数功能:

创建BLE对象。

函数原型:

ble = bluetooth.BLE()

参数说明: 无

返回值:

BLE对象成功，返回单例的BLE对象；BLE对象创建失败，返回None

active - 更改BLE射频的活动状态

函数功能:

更改 BLE 射频的活动状态，并返回当前状态。

注意事项:

在使用此类上的任何其他方法之前，必须使射频处于活动状态。

函数原型：

BLE.active(active)

参数说明:

参数	类型	必选参数？	说明
active	布尔型	是	True：激活BLE射频; False: 关闭BLE射频

返回值:

irq - 事件处理

函数功能:

注册一个BLE协议栈的事件回调。回调函数带两个参数: event - 事件码和 data - 事件值的元组类型。

注意事项:

在元组中的addr， adv_data，char_data，notify_data，和uuid 是只读的，指向bluetooth的内部ringbuffer，并且仅在IRQ处理函数的调用期间有效。如果程序需要保存这些值，以在 IRQ 处理程序返回后访问（例如，通过将其保存在类实例或全局变量中），那么它需要通过使用bytes() 或bluetooth.UUID()等方式获取数据的副本，像这样：
```
  connected_addr = bytes(addr) # equivalently: adv_data, char_data, or notify_data matched_uuid = bluetooth.UUID(uuid)
```
例如，扫描结果的 IRQ 处理程序可能会检查adv_data 以决定它是否是正确的设备，然后才复制地址数据以在程序的其他地方使用。并且需要从 IRQ 处理程序中打印数据 print(bytes(addr))。

函数原型：

BLE.irq(handler)

参数说明：

参数	类型	必选参数？	说明
handler	函数型	是	函数带两个输入参数event和data

返回值:

gap_advertise - 开启或关闭BLE广播

函数功能:

设置一个特定的广播间隔（单位是微秒）开启BLE广播，此间隔最低为625us。关闭BLE广播时，将广播间隔参数（interval_us）设为None。

注意事项：

广播者角色时使用

函数原型：

BLE.gap_advertise(interval_us, adv_data=None, *, resp_data=None, connectable=True)

参数说明:

参数	类型	必选参数？	说明
interval_us	整型	是	广播间隔，为None时关闭广播
adv_data	string	否	adv_data可指向实现缓冲协议的任何类型（例如bytes，bytearray，str），为None时则使用上一次调用时候的值
resp_data	string	否	resp_data可指向实现缓冲协议的任何类型（例如bytes，bytearray，str），为None时则使用上一次调用时候的值
connectable	布尔型	否	表示是否可连接

返回值:

gap_scan - BLE扫描

函数功能:

以一个特定的间隔（interval_us）和窗口（window_us）执行BLE扫描操作; 扫描器将每interval_us微秒运行window_us 微秒，总共持续duration_ms毫秒。默认间隔和窗口分别为 1.28 秒和 11.25 毫秒（后台扫描）

注意事项:

对于每个扫描结果，将触发_IRQ_SCAN_RESULT事件，并带有事件数据(addr_type, addr, adv_type, rssi, adv_data)。当扫描停止时（由于持续时间完成或明确停止），将触发_IRQ_SCAN_DONE事件。观察者角色时使用。

addr_type 值表示公共或随机地址：

0x00 - 公共 0x01 - RANDOM（静态、RPA 或 NRPA，类型在地址本身中编码）

adv_type 值对应于蓝牙规范：

0x00 - ADV_IND - 可连接和可扫描的无向广告 0x01 - ADV_DIRECT_IND - 可连接的定向广告 0x02 - ADV_SCAN_IND - 可扫描的无向广告 0x03 - ADV_NONCONN_IND - 不可连接的无向广告 0x04 - SCAN_RSP - 扫描响应

函数原型:

BLE.gap_scan( duration_ms , interval_us, window_us, active=False )

参数说明:

参数	类型	必选参数？	说明
duration_ms	整型	是	扫描持续时间，单位为毫秒，当设为0时，无限期扫描；当设为None时停止扫描
interval_us	整型	否	扫描间隔时间，单位为微秒
window_us	整型	否	扫描窗口时间，单位为微秒
active	布尔型	否	设为True时，表示要在结果中接受扫描响应（scan_rsp）,默认为False

返回值:

gap_connect - 连接BLE外围设备

函数功能:

连接BLE外围设备

注意事项:

中央设备（Central）以观察者角色通过gap_scan方法获得外围设备信息，或者已知外围设备地址, 之后可通过设备信息触发BLE连接请求。成功后，将触发_IRQ_PERIPHERAL_CONNECT事件，该事件data中带有连接句柄。

函数原型：

BLE.gap_connect( addr_type , addr , scan_duration_ms=2000 , min_conn_interval_us=None , max_conn_interval_us=None )

参数说明:

参数	类型	必选参数？	说明
addr_type	枚举型	是	0x00 - 公共地址；0x01 - 随机地址
addr	string	是	要连接的设备地址
scan_duration_ms	整型	否	设备将等待最多scan_duration_ms以从设备接收广播负载
min_conn_interval_us	整型	否	连接间隔的最小值，单位为微秒
max_conn_interval_us	整型	否	连接间隔的最大值，单位为微秒

返回值:

gatts_register_services - 注册GATT服务

一个 GATT 服务器有一组注册服务。每个服务可能包含一个或多个特性，每个特性都有一个值。特征还可以包含描述符，描述符本身也具有值。这些值存储在本地，并由服务注册期间生成的“值句柄”访问。它们也可以从远程客户端设备读取或写入。此外，服务器可以通过连接句柄主动向连接的客户端“通知”特征。在大多数情况下，外围设备充当GATT 服务器。

函数功能:

使用指定的服务配置服务器

注意事项：

在注册服务之前必须停BLE广播。

每个服务都是一个两个元素的元组，其中一个是UUID，另一个是特征值的列表。每个特征值都是一个两个或三个元素的元组，包含一个UUID, 一个标示值，另一个可选的描述符列表；每个描述符都一个两个元素的元组，包含一个UUID, 一个标示值。这些标示值是由下面定义的标示按位或的组合，他们设置了特征或者描述符的行为及安全和隐私要求。

from micropython import const
_FLAG_BROADCAST = const(0x0001)
_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)
_FLAG_INDICATE = const(0x0020)
_FLAG_AUTHENTICATED_SIGNED_WRITE = const(0x0040)

_FLAG_AUX_WRITE = const(0x0100)
_FLAG_READ_ENCRYPTED = const(0x0200)
_FLAG_READ_AUTHENTICATED = const(0x0400)
_FLAG_READ_AUTHORIZED = const(0x0800)
_FLAG_WRITE_ENCRYPTED = const(0x1000)
_FLAG_WRITE_AUTHENTICATED = const(0x2000)
_FLAG_WRITE_AUTHORIZED = const(0x4000)

函数原型：

BLE.gatts_register_services( services_definition )

参数说明:

参数	类型	必选参数？	说明
services_definition	列表	是	服务列表

返回值:

一个元组列表, 每个元组代表一个服务，元组中的每个元素对应一个值句柄，特征和描述符句柄按照定义的顺序平展为同一个元组。以下示例注册了两个服务（HR 和 UART），这三个值句柄（hr, tx, rx）可用于gatts_read, gatts_write, gatts_notify和gatts_indicate。

gatts_read - 读取本地值

函数功能:

读取本地GATT服务中的特征值

注意事项：

这个值可能是通过本地gatts_write写入的，也可能是通过远程客户端写入的。

函数原型：

BLE.gatts_read(0)

返回值:

gatts_write - 写入本地值

函数功能:

写入本地GATT服务中的特征值

注意事项：

写入后，客户端可以读取该值。

函数原型：

BLE.gatts_write( 0, data , send_update=False )

参数说明:

参数	类型	必选参数？	说明
data	string	是	写入数据
send_update	布尔型	否	为True时，任何订阅此值的此客户端都将收到该特征值写入的通知

返回值:

gattc_read - GATT远程读操作

函数功能:

向连接的服务器发出远程读取

注意事项：

当值可用时，将触发 _IRQ_GATTC_READ_RESULT 事件，里面带有读取的结果。此外，读取完毕将触发_IRQ_GATTC_READ_DONE 事件。

函数原型：

BLE.gattc_read( conn_handle , 0)

参数说明:

参数	类型	必选参数？	说明
conn_handle	整型	是	连接句柄

返回值:

gattc_write - GATT远程写操作

函数功能:

向连接的服务器发出远程写

注意事项：

如果收到来自远程服务器的响应，将触发 _IRQ_GATTC_WRITE_DONE 事件。

函数原型：

BLE.gattc_write( conn_handle , 0, data , mode=0 )

参数说明:

参数	类型	必选参数？	说明
conn_handle	整型	是	连接句柄
mode	整型	是	mode=0（默认值），是无响应写入，对方不返回确认，也不会触发任何事件； mode=1是 write-with-response，远程服务器发送它收到数据的响应/确认

返回值: