def to_c(self):
info = driver.ble_gap_enc_info_t()
info.ltk = util.list_to_uint8_array(self.ltk).cast()
info.lesc = self.lesc
info.auth = self.auth
info.ltk_len = len(self.ltk)
return info
def ble_gap_device_name_set(self, name):
if isinstance(name, str):
name = name.encode("utf8")
write_perm = BLEGapSecMode(0, 0).to_c()
length = len(name)
data = util.list_to_uint8_array(name).cast()
return driver.sd_ble_gap_device_name_set(self.rpc_adapter, write_perm, data, length)
def to_c(self):
self.__data_array = util.list_to_uint8_array(self.value)
params = driver.ble_gatts_value_t()
params.offset = self.offset
params.len = len(self.value)
params.p_value = self.__data_array.cast()
return params
def ble_gap_auth_key_reply(self, conn_handle, key_type, key):
if key is not None:
key_buf = util.list_to_uint8_array(key).cast()
else:
key_buf = None
return driver.sd_ble_gap_auth_key_reply(self.rpc_adapter, conn_handle,
key_type, key_buf)
def to_c(self):
data_list = self.to_list()
data_len = len(data_list)
if data_len == 0:
return data_len, None
else:
self.__data_array = util.list_to_uint8_array(data_list)
return data_len, self.__data_array.cast()
def ble_gatts_sys_attr_set(self, conn_handle, sys_attr_data, flags=0):
if sys_attr_data is not None:
data = util.list_to_uint8_array(sys_attr_data).cast()
length = len(sys_attr_data)
else:
data = None
length = 0
return driver.sd_ble_gatts_sys_attr_set(self.rpc_adapter, conn_handle, data, length, flags)
def to_c(self):
params = driver.ble_gatts_authorize_params_t()
params.gatt_status = self.gatt_status.value
params.update = int(self.update)
params.offset = self.offset
self.__data_array = util.list_to_uint8_array(self.data)
params.p_data = self.__data_array.cast()
params.len = len(self.data)
return params
def get_device_name_cfg(self):
config = driver.ble_cfg_t()
cfg = config.gap_cfg.device_name_cfg
cfg.current_len = len(self.device_name)
cfg.max_len = cfg.current_len
cfg.p_value = util.list_to_uint8_array(self.device_name).cast()
cfg.write_perm.sm = 0
cfg.write_perm.lv = 0
cfg.vloc = driver.BLE_GATTS_VLOC_USER
return driver.BLE_GAP_CFG_DEVICE_NAME, config
def to_c(self):
self.__data_array = util.list_to_uint8_array(self.data)
write_params = driver.ble_gattc_write_params_t()
write_params.p_value = self.__data_array.cast()
write_params.flags = self.flags.value
write_params.handle = self.handle
write_params.offset = self.offset
write_params.len = len(self.data)
write_params.write_op = self.write_op.value
return write_params
def to_c(self):
irk_key = driver.ble_gap_id_key_t()
irk = driver.ble_gap_irk_t()
irk.irk = util.list_to_uint8_array(self.irk).cast()
irk_key.id_info = irk
if self.peer_addr:
addr = self.peer_addr.to_c()
irk_key.id_addr_info = addr
return irk_key
def to_c(self):
self.__data__array = util.list_to_uint8_array(self.value)
params = driver.ble_gatts_attr_t()
params.p_uuid = self.uuid.to_c()
params.p_attr_md = self.attribute_metadata.to_c()
params.max_len = self.max_len
# TODO
if self.value:
params.init_len = len(self.value)
params.init_offs = 0
params.p_value = self.__data__array.cast()
return params
def ble_gap_encrypt(self, conn_handle, ediv, rand, ltk, lesc, auth):
# TODO: Clean up
# assert isinstance(sec_params, (BLEGapSecParams, NoneType)), 'Invalid argument type'
# assert isinstance(sec_keyset, BLEGapSecKeyset), 'Invalid argument type'
# print 'ediv %r' % master_id.ediv
# print 'rand %r' % util.uint8_array_to_list(master_id.rand, 8)
# print 'ltk %r' % util.uint8_array_to_list(enc_info.ltk, enc_info.ltk_len)
# print 'len %r' % enc_info.ltk_len
# print 'lesc %r' % enc_info.lesc
# print 'auth %r' % enc_info.auth
rand_arr = util.list_to_uint8_array(rand)
ltk_arr = util.list_to_uint8_array(ltk)
master_id = driver.ble_gap_master_id_t()
master_id.ediv = ediv
master_id.rand = rand_arr.cast()
enc_info = driver.ble_gap_enc_info_t()
enc_info.ltk_len = len(ltk)
enc_info.ltk = ltk_arr.cast()
enc_info.lesc = lesc
enc_info.auth = auth
return driver.sd_ble_gap_encrypt(self.rpc_adapter, conn_handle,
master_id, enc_info)
def to_c(self):
params = driver.ble_gatts_hvx_params_t()
self._len_ptr = driver.new_uint16()
if self.data:
self.__data_array = util.list_to_uint8_array(self.data)
params.p_data = self.__data_array.cast()
driver.uint16_assign(self._len_ptr, len(self.data))
else:
driver.uint16_assign(self._len_ptr, 0)
params.handle = self.handle
params.type = self.type.value
params.offset = self.offset
params.p_len = self._len_ptr # TODO: Not sure if this works
return params
def to_c(self):
params = driver.ble_gatts_char_md_t()
params.char_props = self.char_props.to_c()
params.char_ext_props = self.extended_props.to_c()
if self.cccd_metadata:
params.p_cccd_md = self.cccd_metadata.to_c()
if self.sccd_metadata:
params.p_sccd_md = self.sccd_metadata.to_c()
if self.presentation_format:
params.p_char_pf = self.presentation_format.to_c()
if self.user_desc_metadata:
params.p_user_desc_md = self.user_desc_metadata.to_c()
self.__user_desc_array = util.list_to_uint8_array(self.user_description)
params.p_char_user_desc = self.__user_desc_array.cast()
params.char_user_desc_size = len(self.user_description)
params.char_user_desc_max_size = max(self.user_description_max_len, len(self.user_description))
return params
def ble_gap_auth_key_reply(self, conn_handle, key_type, key):
key_buf = util.list_to_uint8_array(key)
return driver.sd_ble_gap_auth_key_reply(self.rpc_adapter, conn_handle,
key_type, key_buf.cast())
def to_c(self):
lsb_list = self.base[::-1]
self.__array = util.list_to_uint8_array(lsb_list)
uuid = driver.ble_uuid128_t()
uuid.uuid128 = self.__array.cast()
return uuid
def to_c(self):
addr_array = util.list_to_uint8_array(self.addr[::-1])
addr = driver.ble_gap_addr_t()
addr.addr_type = self.addr_type.value
addr.addr = addr_array.cast()
return addr
def to_c(self):
rand_array = util.list_to_uint8_array(self.rand)
master_id = driver.ble_gap_master_id_t()
master_id.ediv = self.ediv
master_id.rand = rand_array.cast()
return master_id
def to_c(self):
key = driver.ble_gap_lesc_p256_pk_t()
key.pk = util.list_to_uint8_array(self.key).cast()
return key
def to_c(self):
key = driver.ble_gap_sign_info_t()
key.csrk = util.list_to_uint8_array(self.key).cast()
return key
def to_c(self):
key = driver.ble_gap_lesc_dhkey_t()
key.key = util.list_to_uint8_array(self.key).cast()
return key
