async def send_dev(self, destination: int, net_index: int, opcode: int,
params: MessageDescription):
"""
Send a message using a device key.
`destination` determines which device key is going to be used. For
local destinations, the key is always known, but if `destination` is a
remote node, the caller must first import its device key using
:func:`~bluetooth_mesh.application.Application.import_remote_node`.
Unlike application keys, device keys are bound to all subnets, so
you need to explicitly provide `net_index`.
See :py:func:`send_app`
:param destination: Destination address
:param net_index: Index of the network key
:param opcode: Message opcode.
:param params: Message parameters.
"""
remote = True
data = AccessMessage.build(dict(opcode=opcode, params=params))
message = AccessMessage.parse(data)
self.logger.debug(
"Sending: %s -> %04x [remote %s, net_index %d] %r",
self.element.path,
destination,
remote,
net_index,
message,
)
await self._send_dev(destination, remote, net_index, data)
async def send_app(
self, destination: int, app_index: int, opcode: int, params: MessageDescription
):
"""
Send a message using an application key.
:param destination: Destination address
:param app_index: Index of the application key
:param opcode: Message opcode.
:param params: Message parameters.
"""
data = AccessMessage.build(dict(opcode=opcode, params=params))
message = AccessMessage.parse(data)
self.logger.debug(
"Sending: %s -> %04x [app_index %d] %s %r",
self.element.path,
destination,
app_index,
message["opcode"],
message["params"],
)
await self._send_app(destination, app_index, data)
def test_parse_capnproto(encoded, capnproto):
logging.info("MESH[%i] %s", len(encoded), encoded.hex())
decoded = AccessMessage.parse(encoded)
logging.info("CONSTRUCT %r", decoded)
params = CaseConverter.to_camelcase(decoded)
logging.info("CAPNP INPUT[%i] %s", len(json.dumps(params)), json.dumps(params))
message = capnproto.AccessMessage.new_message(**params)
logging.info("CAPNP %r", message)
packed = message.to_bytes_packed()
logging.info("PACKED[%i] %s", len(packed), packed.hex())
unpacked = capnproto.AccessMessage.from_bytes_packed(packed)
logging.info("UNPACKED %r", unpacked)
params = CaseConverter.to_snakecase(unpacked.to_dict())
logging.info("CONSTRUCT INPUT %s", params)
assert AccessMessage.build(params) == encoded
def test_build(encoded, decoded):
result = AccessMessage.build(obj=decoded)
# print(result)
assert result == encoded