def l2cap_conn(bd_addr, bd_addr_type, psm, mtu=0, num=1, ecfc=0, hold_credit=0):
logging.debug("%s %r %r %r", l2cap_conn.__name__, bd_addr, bd_addr_type,
psm)
iutctl = get_iut()
gap_wait_for_connection()
if isinstance(psm, str):
psm = int(psm, 16)
bd_addr = pts_addr_get(bd_addr)
bd_addr_type = pts_addr_type_get(bd_addr_type)
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba = bytearray(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(struct.pack('H', psm))
data_ba.extend(struct.pack('H', mtu))
data_ba.extend(struct.pack('B', num))
opts = 0
if ecfc:
opts |= defs.L2CAP_CONNECT_OPT_ECFC
if hold_credit:
opts |= defs.L2CAP_CONNECT_OPT_HOLD_CREDIT
data_ba.extend(struct.pack('B', opts))
iutctl.btp_socket.send(*L2CAP['connect'], data=data_ba)
chan_ids = l2cap_conn_rsp()
logging.debug("id %r", chan_ids)
def set_filter_accept_list(address_list=None):
""" Send tuples (address, address_type) to IUT
and save them to the filter accept list.
If address_list=None PTS's (address,type) will be sent.
Arguments:
address_list -- addrs and their types as tuples:
address_list = [('DB:F5:72:56:C9:EF', 0), ('DB:F5:72:56:C9:EF', 0)]
"""
logging.debug("%s %s", set_filter_accept_list.__name__, address_list)
iutctl = get_iut()
data_ba = bytearray()
if not address_list:
address_list = [(pts_addr_get(None), pts_addr_type_get(None))]
addr_cnt_ba = chr(len(address_list)).encode('utf-8')
data_ba.extend(addr_cnt_ba)
for addr, type in address_list:
bd_addr_ba = addr2btp_ba(addr)
bd_addr_type_ba = chr(type).encode('utf-8')
data_ba.extend(bd_addr_type_ba)
data_ba.extend(bd_addr_ba)
iutctl.btp_socket.send(*GAP['set_filter_accept_list'], data=data_ba)
gap_command_rsp_succ()
def gattc_cfg_indicate(bd_addr_type, bd_addr, enable, ccc_hdl):
logging.debug("%s %r %r, %r, %r", gattc_cfg_indicate.__name__,
bd_addr_type, bd_addr, enable, ccc_hdl)
gap_wait_for_connection()
if isinstance(ccc_hdl, str):
ccc_hdl = int(ccc_hdl, 16)
iutctl = get_iut()
bd_addr_ba = addr2btp_ba(bd_addr)
ccc_hdl_ba = struct.pack('H', ccc_hdl)
data_ba = bytearray()
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(enable).encode('utf-8'))
data_ba.extend(ccc_hdl_ba)
iutctl.btp_socket.send(*GATTC['cfg_indicate'], data=data_ba)
tuple_hdr, tuple_data = iutctl.btp_socket.read()
logging.debug("%s received %r %r", gattc_cfg_indicate.__name__, tuple_hdr,
tuple_data)
btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT, defs.GATT_CFG_INDICATE)
def gattc_disc_all_desc(bd_addr_type, bd_addr, start_hdl, stop_hdl):
logging.debug("%s %r %r %r %r", gattc_disc_all_desc.__name__, bd_addr_type,
bd_addr, start_hdl, stop_hdl)
iutctl = get_iut()
gap_wait_for_connection()
if isinstance(start_hdl, str):
start_hdl = int(start_hdl, 16)
if isinstance(stop_hdl, str):
stop_hdl = int(stop_hdl, 16)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
start_hdl_ba = struct.pack('H', start_hdl)
stop_hdl_ba = struct.pack('H', stop_hdl)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(start_hdl_ba)
data_ba.extend(stop_hdl_ba)
iutctl.btp_socket.send(*GATTC['disc_all_desc'], data=data_ba)
def gap_direct_adv_on(addr, addr_type, high_duty=0, peer_rpa=0):
logging.debug("%s %r %r", gap_direct_adv_on.__name__, addr, high_duty)
stack = get_stack()
if stack.gap.current_settings_get(
gap_settings_btp2txt[defs.GAP_SETTINGS_ADVERTISING]):
return
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(addr)
data_ba.extend(chr(addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
opts = 0
if high_duty:
opts |= defs.GAP_START_DIRECT_ADV_HD
if peer_rpa:
opts |= defs.GAP_START_DIRECT_ADV_PEER_RPA
data_ba.extend(struct.pack('H', opts))
iutctl.btp_socket.send(*GAP['start_direct_adv'], data=data_ba)
tuple_data = gap_command_rsp_succ(defs.GAP_START_DIRECT_ADV)
__gap_current_settings_update(tuple_data)
def gattc_write(bd_addr_type, bd_addr, hdl, val, val_mtp=None):
logging.debug("%s %r %r %r %r %r", gattc_write.__name__, bd_addr_type,
bd_addr, hdl, val, val_mtp)
iutctl = get_iut()
gap_wait_for_connection()
if isinstance(hdl, str):
hdl = int(hdl, 16)
if val_mtp:
val *= int(val_mtp)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
hdl_ba = struct.pack('H', hdl)
val_ba = binascii.unhexlify(val)
val_len_ba = struct.pack('H', len(val_ba))
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(hdl_ba)
data_ba.extend(val_len_ba)
data_ba.extend(val_ba)
iutctl.btp_socket.send(*GATTC['write'], data=data_ba)
def gattc_read_long(bd_addr_type, bd_addr, hdl, off, modif_off=None):
logging.debug("%s %r %r %r %r %r", gattc_read_long.__name__, bd_addr_type,
bd_addr, hdl, off, modif_off)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
if isinstance(off, str):
off = int(off, 16)
if modif_off:
off += modif_off
if isinstance(hdl, str):
hdl = int(hdl, 16)
bd_addr_ba = addr2btp_ba(bd_addr)
hdl_ba = struct.pack('H', hdl)
off_ba = struct.pack('H', off)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(hdl_ba)
data_ba.extend(off_ba)
iutctl.btp_socket.send(*GATTC['read_long'], data=data_ba)
def gatts_get_attr_val(bd_addr_type, bd_addr, handle):
logging.debug("%s %r", gatts_get_attr_val.__name__, handle)
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
if isinstance(handle, str):
handle = int(handle, 16)
hdl_ba = struct.pack('H', handle)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(hdl_ba)
iutctl.btp_socket.send(*GATTS['get_attr_val'], data=data_ba)
tuple_hdr, tuple_data = iutctl.btp_socket.read()
logging.debug("received %r %r", tuple_hdr, tuple_data)
btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT,
defs.GATT_GET_ATTRIBUTE_VALUE)
hdr = '<BH'
hdr_len = struct.calcsize(hdr)
data_len = tuple_hdr.data_len - hdr_len
return struct.unpack(hdr + '%ds' % data_len, tuple_data[0])
def gattc_read_uuid(bd_addr_type, bd_addr, start_hdl, end_hdl, uuid):
logging.debug("%s %r %r %r %r %r", gattc_read_uuid.__name__, bd_addr_type,
bd_addr, start_hdl, end_hdl, uuid)
iutctl = get_iut()
gap_wait_for_connection()
if isinstance(start_hdl, str):
start_hdl = int(start_hdl, 16)
if isinstance(end_hdl, str):
end_hdl = int(end_hdl, 16)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
start_hdl_ba = struct.pack('H', start_hdl)
end_hdl_ba = struct.pack('H', end_hdl)
if "-" in uuid:
uuid = uuid.replace("-", "")
if uuid.startswith("0x"):
uuid = uuid.replace("0x", "")
uuid_ba = binascii.unhexlify(uuid)[::-1]
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(start_hdl_ba)
data_ba.extend(end_hdl_ba)
data_ba.extend(chr(len(uuid_ba)).encode('utf-8'))
data_ba.extend(uuid_ba)
iutctl.btp_socket.send(*GATTC['read_uuid'], data=data_ba)
def gattc_write_long(bd_addr_type, bd_addr, hdl, off, val, length=None):
logging.debug("%s %r %r %r %r %r", gattc_write_long.__name__, bd_addr_type,
hdl, off, val, length)
gap_wait_for_connection()
if isinstance(hdl, str):
hdl = int(hdl, 16) # convert string in hex format to int
if isinstance(off, str):
off = int(off, 16)
if length:
val *= int(length)
iutctl = get_iut()
bd_addr_ba = addr2btp_ba(bd_addr)
hdl_ba = struct.pack('H', hdl)
off_ba = struct.pack('H', off)
val_ba = bytes.fromhex(val)
val_len_ba = struct.pack('H', len(val_ba))
data_ba = bytearray()
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(hdl_ba)
data_ba.extend(off_ba)
data_ba.extend(val_len_ba)
data_ba.extend(val_ba)
iutctl.btp_socket.send(*GATTC['write_long'], data=data_ba)
def gap_conn_param_update(bd_addr, bd_addr_type, conn_itvl_min, conn_itvl_max,
conn_latency, supervision_timeout):
logging.debug("%s %r %r", gap_conn_param_update.__name__, bd_addr,
bd_addr_type)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr))
data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8'))
data_ba.extend(bd_addr_ba)
conn_itvl_min_ba = struct.pack('H', conn_itvl_min)
conn_itvl_max_ba = struct.pack('H', conn_itvl_max)
conn_latency_ba = struct.pack('H', conn_latency)
supervision_timeout_ba = struct.pack('H', supervision_timeout)
data_ba.extend(conn_itvl_min_ba)
data_ba.extend(conn_itvl_max_ba)
data_ba.extend(conn_latency_ba)
data_ba.extend(supervision_timeout_ba)
iutctl.btp_socket.send(*GAP['conn_param_update'], data=data_ba)
# Expected result
gap_command_rsp_succ()
def __bytes__(self):
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(self.addr)
data_ba.extend([self.addr_type])
data_ba.extend(bd_addr_ba)
return data_ba
def gap_unpair(bd_addr=None, bd_addr_type=None):
logging.debug("%s %r %r", gap_unpair.__name__, bd_addr, bd_addr_type)
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr))
data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8'))
data_ba.extend(bd_addr_ba)
iutctl.btp_socket.send(*GAP['unpair'], data=data_ba)
# Expected result
gap_command_rsp_succ(defs.GAP_UNPAIR)
def gattc_disc_all_prim(bd_addr_type, bd_addr):
logging.debug("%s %r %r", gattc_disc_all_prim.__name__, bd_addr_type,
bd_addr)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
iutctl.btp_socket.send(*GATTC['disc_all_prim'], data=data_ba)
def gap_conn(bd_addr=None,
bd_addr_type=None,
own_addr_type=OwnAddrType.le_identity_address):
logging.debug("%s %r %r", gap_conn.__name__, bd_addr, bd_addr_type)
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr))
data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(own_addr_type).encode('utf-8'))
iutctl.btp_socket.send(*GAP['conn'], data=data_ba)
gap_command_rsp_succ()
def gattc_exchange_mtu(bd_addr_type, bd_addr):
logging.debug("%s %r %r", gattc_exchange_mtu.__name__, bd_addr_type,
bd_addr)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
iutctl.btp_socket.send(*GATTC['exchange_mtu'], data=data_ba)
gatt_command_rsp_succ()
def l2cap_disconn_eatt_chans(bd_addr, bd_addr_type, channel_count):
logging.debug("%s %r", l2cap_disconn_eatt_chans.__name__, channel_count)
iutctl = get_iut()
bd_addr = pts_addr_get(bd_addr)
bd_addr_type = pts_addr_type_get(bd_addr_type)
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba = bytearray(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(bytearray(chr(channel_count).encode('utf-8')))
iutctl.btp_socket.send(*L2CAP['disconnect_eatt_chans'], data=data_ba)
l2cap_command_rsp_succ(defs.L2CAP_DISCONNECT_EATT_CHANS)
def gap_disconn(bd_addr=None, bd_addr_type=None):
logging.debug("%s %r %r", gap_disconn.__name__, bd_addr, bd_addr_type)
iutctl = get_iut()
stack = get_stack()
if not stack.gap.is_connected():
return
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr))
data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8'))
data_ba.extend(bd_addr_ba)
iutctl.btp_socket.send(*GAP['disconn'], data=data_ba)
gap_command_rsp_succ()
def gattc_disc_prim_uuid(bd_addr_type, bd_addr, uuid):
logging.debug("%s %r %r %r", gattc_disc_prim_uuid.__name__, bd_addr_type,
bd_addr, uuid)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
uuid_ba = bytes.fromhex(uuid.replace("-", ""))
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(len(uuid_ba)).encode('utf-8'))
data_ba.extend(uuid_ba)
iutctl.btp_socket.send(*GATTC['disc_prim_uuid'], data=data_ba)
def gattc_disc_all_chrc(bd_addr_type, bd_addr, start_hdl, stop_hdl, svc=None):
logging.debug("%s %r %r %r %r %r", gattc_disc_all_chrc.__name__,
bd_addr_type, bd_addr, start_hdl, stop_hdl, svc)
iutctl = get_iut()
gap_wait_for_connection()
if svc:
svc_nb = svc[1]
for s in GATT_SVCS:
if not ((svc[0][0] and svc[0][0] != s[0]) and
(svc[0][1] and svc[0][1] != s[1]) and
(svc[0][2] and svc[0][2] != s[2])):
# To take n-th service
svc_nb -= 1
if svc_nb != 0:
continue
start_hdl = s[0]
stop_hdl = s[1]
logging.debug("Got requested service!")
break
if isinstance(start_hdl, str):
start_hdl = int(start_hdl, 16)
if isinstance(stop_hdl, str):
stop_hdl = int(stop_hdl, 16)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
start_hdl_ba = struct.pack('H', start_hdl)
stop_hdl_ba = struct.pack('H', stop_hdl)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(start_hdl_ba)
data_ba.extend(stop_hdl_ba)
iutctl.btp_socket.send(*GATTC['disc_all_chrc'], data=data_ba)
def gattc_read(bd_addr_type, bd_addr, hdl):
logging.debug("%s %r %r %r", gattc_read.__name__, bd_addr_type, bd_addr,
hdl)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
if isinstance(hdl, str):
hdl = int(hdl, 16)
hdl_ba = struct.pack('H', hdl)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(hdl_ba)
iutctl.btp_socket.send(*GATTC['read'], data=data_ba)
def l2cap_reconfigure(bd_addr, bd_addr_type, mtu, channels):
logging.debug("%s %r %r %r %r", l2cap_reconfigure.__name__, bd_addr,
bd_addr_type, mtu, channels)
iutctl = get_iut()
bd_addr = pts_addr_get(bd_addr)
bd_addr_type = pts_addr_type_get(bd_addr_type)
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba = bytearray(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(struct.pack('H', mtu))
data_ba.extend(struct.pack('B', len(channels)))
for chan in channels:
data_ba.extend(struct.pack('B', chan))
iutctl.btp_socket.send(*L2CAP['reconfigure'], data=data_ba)
l2cap_command_rsp_succ(defs.L2CAP_RECONFIGURE)
def gap_passkey_entry_rsp(bd_addr, bd_addr_type, passkey):
logging.debug("%s %r %r", gap_passkey_entry_rsp.__name__, bd_addr,
bd_addr_type)
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
if isinstance(passkey, str):
passkey = int(passkey, 32)
passkey_ba = struct.pack('I', passkey)
data_ba.extend(passkey_ba)
iutctl.btp_socket.send(*GAP['passkey_entry_rsp'], data=data_ba)
gap_command_rsp_succ()
def gattc_notification_ev(bd_addr, bd_addr_type, ev_type):
logging.debug("%s %r %r %r", gattc_notification_ev.__name__, bd_addr,
bd_addr_type, ev_type)
iutctl = get_iut()
tuple_hdr, tuple_data = iutctl.btp_socket.read()
logging.debug("received %r %r", tuple_hdr, tuple_data)
btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT,
defs.GATT_EV_NOTIFICATION)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(ev_type).encode('utf-8'))
if tuple_data[0][0:len(data_ba)] != data_ba:
raise BTPError("Error in notification event data")
def gap_passkey_confirm_rsp(bd_addr, bd_addr_type, passkey):
logging.debug("%s %r %r", gap_passkey_confirm_rsp.__name__, bd_addr,
bd_addr_type)
iutctl = get_iut()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
if isinstance(passkey, str):
passkey = int(passkey)
match = int(passkey == int(get_stack().gap.get_passkey()))
data_ba.extend(chr(match).encode('utf-8'))
iutctl.btp_socket.send(*GAP['passkey_confirm_rsp'], data=data_ba)
gap_command_rsp_succ()
def l2cap_conn(bd_addr, bd_addr_type, psm, mtu=0, num=1):
logging.debug("%s %r %r %r", l2cap_conn.__name__, bd_addr, bd_addr_type,
psm)
iutctl = get_iut()
gap_wait_for_connection()
if isinstance(psm, str):
psm = int(psm, 16)
bd_addr = pts_addr_get(bd_addr)
bd_addr_type = pts_addr_type_get(bd_addr_type)
bd_addr_ba = addr2btp_ba(bd_addr)
data_ba = bytearray(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(struct.pack('H', psm))
data_ba.extend(struct.pack('H', mtu))
data_ba.extend(struct.pack('B', num))
iutctl.btp_socket.send(*L2CAP['connect'], data=data_ba)
chan_ids = l2cap_conn_rsp()
logging.debug("id %r", chan_ids)
def _gattc_find_included_req(bd_addr_type, bd_addr, start_hdl, end_hdl):
logging.debug("%s %r %r %r %r", _gattc_find_included_req.__name__,
bd_addr_type, bd_addr, start_hdl, end_hdl)
iutctl = get_iut()
if isinstance(end_hdl, str):
end_hdl = int(end_hdl, 16)
if isinstance(start_hdl, str):
start_hdl = int(start_hdl, 16)
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
start_hdl_ba = struct.pack('H', start_hdl)
end_hdl_ba = struct.pack('H', end_hdl)
data_ba.extend(chr(bd_addr_type).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(start_hdl_ba)
data_ba.extend(end_hdl_ba)
iutctl.btp_socket.send(*GATTC['find_included'], data=data_ba)
def gattc_read_multiple_var(bd_addr_type, bd_addr, *hdls):
logging.debug("%s %r %r %r", gattc_read_multiple_var.__name__,
bd_addr_type, bd_addr, hdls)
iutctl = get_iut()
gap_wait_for_connection()
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(bd_addr)
hdls_j = ''.join(hdl for hdl in hdls)
hdls_byte_table = [hdls_j[i:i + 2] for i in range(0, len(hdls_j), 2)]
hdls_swp = ''.join([
c[1] + c[0] for c in zip(hdls_byte_table[::2], hdls_byte_table[1::2])
])
hdls_ba = binascii.unhexlify(bytearray(hdls_swp))
data_ba.extend(chr(bd_addr_type))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(len(hdls)))
data_ba.extend(hdls_ba)
iutctl.btp_socket.send(*GATTC['read_multiple_var'], data=data_ba)
def gap_rpa_conn(description, own_addr_type=OwnAddrType.le_identity_address):
"""Initiate connection with PTS using RPA address provided
in MMI description. Function returns True.
Arguments:
description -- description provided in PTS MMI.
"""
logging.debug("%s %s", gap_conn.__name__, description)
iutctl = get_iut()
bd_addr = re.search("[a-fA-F0-9]{12}", description).group(0)
bd_addr_type = Addr.le_random
data_ba = bytearray()
bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr))
data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8'))
data_ba.extend(bd_addr_ba)
data_ba.extend(chr(own_addr_type).encode('utf-8'))
iutctl.btp_socket.send(*GAP['conn'], data=data_ba)
gap_command_rsp_succ()
return True
