def __init__(self,
address,
commandtuple,
cmd2=None,
flags=0x00,
acknak=None):
"""Initialize the StandardSend message class."""
if commandtuple.get('cmd1', None) is not None:
cmd1 = commandtuple['cmd1']
cmd2out = commandtuple['cmd2']
else:
raise ValueError
if cmd2 is not None:
cmd2out = cmd2
if cmd2out is None:
raise ValueError
self._address = Address(address)
self._messageFlags = MessageFlags(flags)
self._messageFlags.extended = 0
self._cmd1 = cmd1
self._cmd2 = cmd2out
self._acknak = self._setacknak(acknak)
def __init__(self,
address,
commandtuple,
userdata,
cmd2=None,
flags=0x10,
acknak=None):
"""Init the ExtendedSend message class."""
if commandtuple.get("cmd1", None) is not None:
cmd1 = commandtuple["cmd1"]
cmd2out = commandtuple["cmd2"]
else:
raise ValueError
if cmd2 is not None:
cmd2out = cmd2
if cmd2out is None:
raise ValueError
self._address = Address(address)
self._messageFlags = MessageFlags(flags)
self._messageFlags.extended = 1
self._cmd1 = cmd1
self._cmd2 = cmd2out
self._userdata = Userdata(userdata)
self._acknak = self._setacknak(acknak)
def template(cls,
address=None,
target=None,
commandtuple=None,
cmd2=-1,
flags=None):
"""Create a message template used for callbacks."""
msgraw = bytearray([0x02, cls._code])
msgraw.extend(bytes(cls._receivedSize))
msg = StandardReceive.from_raw_message(msgraw)
if commandtuple:
cmd1 = commandtuple.get('cmd1')
cmd2out = commandtuple.get('cmd2')
else:
cmd1 = None
cmd2out = None
if cmd2 is not -1:
cmd2out = cmd2
msg._address = Address(address)
msg._target = Address(target)
msg._messageFlags = MessageFlags(flags)
msg._cmd1 = cmd1
msg._cmd2 = cmd2out
return msg
def template(
cls,
address=None,
commandtuple=None,
userdata=None,
cmd2=-1,
flags=None,
acknak=None,
):
"""Create a message template used for callbacks."""
msgraw = bytearray([0x02, cls._code])
msgraw.extend(bytes(cls._receivedSize))
msg = ExtendedSend.from_raw_message(msgraw)
if commandtuple:
cmd1 = commandtuple.get("cmd1")
cmd2out = commandtuple.get("cmd2")
else:
cmd1 = None
cmd2out = None
if cmd2 is not -1:
cmd2out = cmd2
msg._address = Address(address)
msg._messageFlags = MessageFlags(flags)
msg._messageFlags.extended = 1
msg._cmd1 = cmd1
msg._cmd2 = cmd2out
msg._userdata = Userdata.template(userdata)
msg._acknak = acknak
return msg
def template(
cls,
address=None,
target=None,
commandtuple=None,
userdata=None,
cmd2=-1,
flags=None,
):
"""Create message template for callbacks."""
msgraw = bytearray([0x02, cls._code])
msgraw.extend(bytes(cls._receivedSize))
msg = ExtendedReceive.from_raw_message(msgraw)
if commandtuple:
cmd1 = commandtuple.get("cmd1")
cmd2out = commandtuple.get("cmd2")
else:
cmd1 = None
cmd2out = None
if cmd2 is not -1:
cmd2out = cmd2
msg._address = Address(address)
msg._target = Address(target)
msg._messageFlags = MessageFlags(flags)
msg._cmd1 = cmd1
msg._cmd2 = cmd2out
msg._userdata = Userdata.create_pattern(userdata)
return msg
def __init__(self,
address,
target,
commandtuple,
userdata,
cmd2=None,
flags=0x10):
"""Initialize the ExtendedRecieve message class."""
if commandtuple.get('cmd1', None) is not None:
cmd1 = commandtuple['cmd1']
cmd2out = commandtuple['cmd2']
else:
raise ValueError
if cmd2 is not None:
cmd2out = cmd2
if cmd2out is None:
raise ValueError
self._address = Address(address)
self._target = Address(target)
self._messageFlags = MessageFlags(flags)
# self._messageFlags.extended = 1
self._cmd1 = cmd1
self._cmd2 = cmd2out
self._userdata = Userdata(userdata)
def __init__(self, address, target, commandtuple, cmd2=None, flags=0x00):
"""Init the StandardReceive message class."""
if commandtuple.get('cmd1') is not None:
cmd1 = commandtuple['cmd1']
cmd2out = commandtuple['cmd2']
else:
raise ValueError
if cmd2 is not None:
cmd2out = cmd2
if cmd2out is None:
raise ValueError
self._address = Address(address)
self._target = Address(target)
self._messageFlags = MessageFlags(flags)
# self._messageFlags.extended = 0
self._cmd1 = cmd1
self._cmd2 = cmd2out
def test_messageType():
"""Test message flags match the expected message type."""
direct = MessageFlags(MESSAGE_TYPE_DIRECT_MESSAGE << 5)
direct_ack = MessageFlags(MESSAGE_TYPE_DIRECT_MESSAGE_ACK << 5)
all_link_cleanup = MessageFlags(MESSAGE_TYPE_ALL_LINK_CLEANUP << 5)
all_link_cleanup_ack = MessageFlags(MESSAGE_TYPE_ALL_LINK_CLEANUP_ACK << 5)
broadcast = MessageFlags(MESSAGE_TYPE_BROADCAST_MESSAGE << 5)
direct_nak = MessageFlags(MESSAGE_TYPE_DIRECT_MESSAGE_NAK << 5)
all_link_broadcast = MessageFlags(MESSAGE_TYPE_ALL_LINK_BROADCAST << 5)
all_link_cleanup_nak = MessageFlags(MESSAGE_TYPE_ALL_LINK_CLEANUP_NAK << 5)
assert direct.messageType == MESSAGE_TYPE_DIRECT_MESSAGE
assert direct.isDirect
assert direct_ack.messageType == MESSAGE_TYPE_DIRECT_MESSAGE_ACK
assert direct_ack.isDirectACK
assert all_link_cleanup.messageType == MESSAGE_TYPE_ALL_LINK_CLEANUP
assert all_link_cleanup.isAllLinkCleanup
assert (
all_link_cleanup_ack.messageType == MESSAGE_TYPE_ALL_LINK_CLEANUP_ACK)
assert all_link_cleanup_ack.isAllLinkCleanupACK
assert broadcast.messageType == MESSAGE_TYPE_BROADCAST_MESSAGE
assert broadcast.isBroadcast
assert direct_nak.messageType == MESSAGE_TYPE_DIRECT_MESSAGE_NAK
assert direct_nak.isDirectNAK
assert all_link_broadcast.messageType == MESSAGE_TYPE_ALL_LINK_BROADCAST
assert all_link_broadcast.isAllLinkBroadcast
assert (
all_link_cleanup_nak.messageType == MESSAGE_TYPE_ALL_LINK_CLEANUP_NAK)
assert all_link_cleanup_nak.isAllLinkCleanupNAK
def template(cls,
address=None,
commandtuple={},
cmd2=-1,
flags=None,
acknak=None):
"""Create a message template for use in callbacks."""
msgraw = bytearray([0x02, cls._code])
msgraw.extend(bytes(cls._receivedSize))
msg = StandardSend.from_raw_message(msgraw)
cmd1 = commandtuple.get('cmd1', None)
cmd2out = commandtuple.get('cmd2', None)
if cmd2 is not -1:
cmd2out = cmd2
msg._address = Address(address)
msg._messageFlags = MessageFlags(flags)
msg._cmd1 = cmd1
msg._cmd2 = cmd2out
msg._acknak = acknak
return msg
def test_eq():
"""Test comarision for equality."""
flag1 = MessageFlags(0x80)
flag2 = MessageFlags(0x25)
flag3 = MessageFlags(0x27)
flag4 = MessageFlags(0x16)
flag5 = MessageFlags(0x37)
flag6 = MessageFlags(0x6f)
pattern1 = MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, 0)
pattern2 = MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None)
pattern3 = MessageFlags.template(None, 0)
pattern4 = MessageFlags.template(None, 1)
pattern5 = MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0)
pattern6 = MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 1)
pattern7 = MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK, None)
assert flag1.matches_pattern(pattern1)
assert not flag2.matches_pattern(pattern1)
assert not flag3.matches_pattern(pattern1)
assert not flag4.matches_pattern(pattern1)
assert not flag5.matches_pattern(pattern1)
assert not flag6.matches_pattern(pattern1)
assert flag1.matches_pattern(pattern2)
assert not flag2.matches_pattern(pattern2)
assert not flag3.matches_pattern(pattern2)
assert not flag4.matches_pattern(pattern2)
assert not flag5.matches_pattern(pattern2)
assert not flag6.matches_pattern(pattern2)
assert flag1.matches_pattern(pattern3)
assert flag2.matches_pattern(pattern3)
assert flag3.matches_pattern(pattern3)
assert not flag4.matches_pattern(pattern3)
assert not flag5.matches_pattern(pattern3)
assert flag6.matches_pattern(pattern3)
assert not flag1.matches_pattern(pattern4)
assert not flag2.matches_pattern(pattern4)
assert not flag3.matches_pattern(pattern4)
assert flag4.matches_pattern(pattern4)
assert flag5.matches_pattern(pattern4)
assert not flag6.matches_pattern(pattern4)
assert not flag1.matches_pattern(pattern5)
assert flag2.matches_pattern(pattern5)
assert flag3.matches_pattern(pattern5)
assert not flag4.matches_pattern(pattern5)
assert not flag5.matches_pattern(pattern5)
assert not flag6.matches_pattern(pattern5)
assert not flag1.matches_pattern(pattern6)
assert not flag2.matches_pattern(pattern6)
assert not flag3.matches_pattern(pattern6)
assert not flag4.matches_pattern(pattern6)
assert flag5.matches_pattern(pattern6)
assert not flag6.matches_pattern(pattern6)
assert not flag1.matches_pattern(pattern7)
assert flag2.matches_pattern(pattern7)
assert flag3.matches_pattern(pattern7)
assert not flag4.matches_pattern(pattern7)
assert flag5.matches_pattern(pattern7)
assert not flag6.matches_pattern(pattern7)
def test_extended():
"""Test the extended flag."""
assert MessageFlags(0x10).extended == 1
assert MessageFlags(0x10).isExtended