示例#1
0
 def _register_messages(self):
     cool_set_point_status = StandardReceive.template(
         address=self._address,
         commandtuple=COMMAND_THERMOSTAT_COOL_SET_POINT_STATUS_0X71_NONE,
         flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE, False),
     )
     self._message_callbacks.add(cool_set_point_status,
                                 self._status_message_received)
     ext_status_recd = ExtendedReceive.template(
         commandtuple=COMMAND_EXTENDED_GET_SET_0X2E_0X00,
         cmd2=0x02,
         userdata=Userdata.template({"d1": 0x01}),
     )
     self._message_callbacks.add(ext_status_recd, self._ext_status_received)
示例#2
0
    def _register_messages(self):
        temp_msg = StandardReceive.template(
            commandtuple=COMMAND_THERMOSTAT_TEMPERATURE_STATUS_0X6E_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE, None),
        )

        self._message_callbacks.add(temp_msg, self._temp_received)
        ext_status_recd = ExtendedReceive.template(
            commandtuple=COMMAND_EXTENDED_GET_SET_0X2E_0X00,
            cmd2=0x02,
            userdata=Userdata.template({"d1": 0x01}),
        )
        self._message_callbacks.add(ext_status_recd, self._ext_status_received)
示例#3
0
    def run_test(loop):
        """Asyncio coroutine to actually run the test."""
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = bytearray([0x00, 0x00, 0x01])
        cmd2 = 0x01

        cat = 0x10
        subcat = 0x00
        product_key = 0x00
        description = 'Generic Security, Heath and Safety Device'
        model = ''

        callbacks = MockCallbacks()

        device = SecurityHealthSafety(plm, address, cat, subcat,
                                      product_key, description, model)
        plm.devices[address] = device
        device.states[0x01].register_updates(callbacks.callbackmethod1)
        msg = StandardReceive(
            address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=cmd2,
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == cmd2

        device = SecurityHealthSafety(plm, address, cat, subcat,
                                      product_key, description, model)
        device.states[0x01].register_updates(callbacks.callbackmethod1)
        msg = StandardReceive(
            address, target, COMMAND_LIGHT_OFF_0X13_0X00,
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0x00
    def run_test(loop):
        """Asyncio test to run."""
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'
        cat = 0x01
        subcat = 0x04
        product_key = None
        description = 'SwitchLinc Dimmer (1000W)'
        model = '2476DH'

        device = DimmableLightingControl(plm, address, cat, subcat,
                                         product_key, description, model)

        assert device.address.hex == address
        assert device.cat == cat
        assert device.subcat == subcat
        assert device.product_key == 0x00  # Product key should not be None
        assert device.description == description
        assert device.model == model
        assert device.id == address
        plm.devices[device.address.hex] = device

        callbacks = MockCallbacks()
        device.states[0x01].register_updates(callbacks.callbackmethod1)

        device.async_refresh_state()
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x08,
                                          'cmd2': 0x27
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0x27
    def run_test(loop):
        """Asyncio test."""
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'

        cat = 0x01
        subcat = 0x2e
        product_key = 0x00
        description = 'FanLinc Dual Band'
        model = '2475F'

        device = DimmableLightingControl_2475F(plm, address, cat, subcat,
                                               product_key, description, model)

        plm.devices[device.address.hex] = device
        callbacks = MockCallbacks()
        device.states[0x02].register_updates(callbacks.callbackmethod1)

        device.states[0x02].async_refresh_state()
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_STATUS_REQUEST_0X19_NONE,
                                   cmd2=0x03,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x08,
                                          'cmd2': 0x27
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address,
                               COMMAND_LIGHT_STATUS_REQUEST_0X19_NONE,
                               cmd2=0x03)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0x27
示例#6
0
    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
示例#7
0
    def __init__(self, address, target, commandtuple, userdata, cmd2=None, flags=0x10):
        """Init 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)
示例#8
0
    def __init__(self, address, commandtuple, cmd2=None,
                 flags=0x00, acknak=None):
        """Init 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)
示例#9
0
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
示例#10
0
    def template(cls,
                 address=None,
                 target=None,
                 commandtuple={},
                 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)

        cmd1 = commandtuple.get('cmd1')
        cmd2out = commandtuple.get('cmd2')

        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
示例#11
0
    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
示例#12
0
    def run_test(loop):
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'
        cmd2 = 0x04

        cat = 0x10
        subcat = 0x00
        product_key = 0x00
        description = 'Generic Security, Heath and Safety Device'
        model = ''

        callbacks = MockCallbacks()

        device = SecurityHealthSafety_2982_222(plm, address, cat, subcat,
                                               product_key, description, model)
        plm.devices[address] = device
        device.states[0x01].register_updates(callbacks.callbackmethod1)
        msg = StandardReceive(
            address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=cmd2,
            flags=MessageFlags.create(MESSAGE_FLAG_BROADCAST_0X80, 0, 0, 0))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0x6f
    async def run_test(loop):
        """Asyncio test method."""
        plm = MockPLM(loop)
        callbacks = MockCallbacks()

        address = '1a2b3c'
        target = '4d5e6f'
        cat = 0x02
        subcat = 0x0d
        product_key = None
        description = 'ToggleLinc Relay'
        model = '2466S'

        device = SwitchedLightingControl_2663_222(plm, address, cat, subcat,
                                                  product_key, description,
                                                  model)
        plm.devices[address] = device
        assert device.address.hex == address
        assert device.cat == cat
        assert device.subcat == subcat
        assert device.product_key == 0x00  # Product key should not be None
        assert device.description == description
        assert device.model == model
        assert device.id == address

        device.states[0x01].register_updates(callbacks.callbackmethod1)
        device.states[0x02].register_updates(callbacks.callbackmethod2)

        device.states[0x01].on()
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
        assert plm.sentmessage == sentmsg.hex
        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_ON_0X11_NONE,
                                   cmd2=0xff,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x09,
                                          'cmd2': 0xff
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0xff

        device.states[0x02].on()
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = ExtendedSend(address,
                                   COMMAND_LIGHT_ON_0X11_NONE, {'d1': 0x02},
                                   cmd2=0xff,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x09,
                                          'cmd2': 0xff
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        sentmsg = ExtendedSend(address,
                               COMMAND_LIGHT_ON_0X11_NONE, {'d1': 0x02},
                               cmd2=0xff)
        sentmsg.set_checksum()
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue2 == 0xff

        device.states[0x01].off()
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00)
        assert plm.sentmessage == sentmsg.hex
        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_OFF_0X13_0X00,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x09,
                                          'cmd2': 0x00
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0x00

        device.states[0x02].off()
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = ExtendedSend(address,
                                   COMMAND_LIGHT_OFF_0X13_0X00, {'d1': 0x02},
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target, {
                                          'cmd1': 0x09,
                                          'cmd2': 0x00
                                      },
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        sentmsg = ExtendedSend(address, COMMAND_LIGHT_OFF_0X13_0X00,
                               {'d1': 0x02})
        sentmsg.set_checksum()
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue2 == 0x00
示例#14
0
def test_extended():
    """Test the extended flag."""
    assert MessageFlags(0x10).extended == 1
    assert MessageFlags(0x10).isExtended
示例#15
0
    def _register_messages(self):
        template_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_on_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_off_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_instant_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)

        self._message_callbacks.add(template_on_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_on_fast_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_off_fast_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_instant_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_on_broadcast,
                                    self._manual_change_received)
示例#16
0
    def __init__(self,
                 address,
                 statename,
                 group,
                 send_message_method,
                 message_callbacks,
                 defaultvalue=None):
        """Initalize the DimmableSwitch Class."""
        super().__init__(address, statename, group, send_message_method,
                         message_callbacks, defaultvalue)

        self._updatemethod = self._send_status_request

        self.log.debug('Registering callbacks for DimmableSwitch device %s',
                       self._address.human)
        template_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))
        template_on_fast_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))
        template_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)
        template_off_fast_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)
        template_manual_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)
        template_instant_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)
        template_manual_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)
        template_manual_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=None)

        template_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_on_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_off_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_instant_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)

        self._message_callbacks.add(template_on_cleanup,
                                    self._on_message_received)
        self._message_callbacks.add(template_on_fast_cleanup,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_cleanup,
                                    self._off_message_received)
        self._message_callbacks.add(template_off_fast_cleanup,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_instant_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_on_cleanup,
                                    self._manual_change_received)

        self._message_callbacks.add(template_on_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_on_fast_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_off_fast_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_instant_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_on_broadcast,
                                    self._manual_change_received)
示例#17
0
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)
示例#18
0
    def _run_test(loop):
        """Test on/off sensor."""
        plm = MockPLM(loop)

        address = '1a2b3c'
        cat = 0x10
        subcat = 0x00
        product_key = 0x00
        description = 'Generic Security, Heath and Safety Device'
        model = ''

        callbacks = MockCallbacks()

        device = SecurityHealthSafety_2852_222(plm, address, cat, subcat,
                                               product_key, description, model)
        plm.devices[address] = device
        device.states[0x01].register_updates(callbacks.callbackmethod1)
        device.states[0x02].register_updates(callbacks.callbackmethod2)
        device.states[0x04].register_updates(callbacks.callbackmethod4)

        # Test Dry message received
        msg = StandardReceive(
            address=address,
            target=bytearray([0x00, 0x00, 0x01]),
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x01,
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 1
        assert callbacks.callbackvalue2 == 0
        assert callbacks.callbackvalue4 == 0x11

        # Test wet message received
        msg = StandardReceive(
            address=address,
            target=bytearray([0x00, 0x00, 0x02]),
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x02,
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0
        assert callbacks.callbackvalue2 == 1
        assert callbacks.callbackvalue4 == 0x13

        # Test dry heartbeat received
        msg = StandardReceive(
            address=address,
            target=bytearray([0x00, 0x00, 0x04]),
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x04,
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 1
        assert callbacks.callbackvalue2 == 0

        # Test wet heartbeat received
        msg = StandardReceive(
            address=address,
            target=bytearray([0x00, 0x00, 0x04]),
            commandtuple={'cmd1': 0x13, 'cmd2': 0x04},
            flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
                                      0, 3, 3))
        plm.message_received(msg)
        yield from asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0
        assert callbacks.callbackvalue2 == 1
        assert callbacks.callbackvalue4 == 0x13
示例#19
0
    def _register_messages(self):
        """Register messages to listen for."""
        template_on_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_fast_on_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
        template_off_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_fast_off_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_on_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)
        template_manual_off_group = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None)

        template_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)
        template_fast_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)
        template_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)
        template_fast_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)
        template_manual_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)
        template_manual_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group)

        self._message_callbacks.add(template_on_group,
                                    self._on_message_received)
        self._message_callbacks.add(template_fast_on_group,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_group,
                                    self._off_message_received)
        self._message_callbacks.add(template_fast_off_group,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_on_group,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_group,
                                    self._manual_change_received)

        self._message_callbacks.add(template_on_cleanup,
                                    self._on_message_received)
        self._message_callbacks.add(template_fast_on_cleanup,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_cleanup,
                                    self._off_message_received)
        self._message_callbacks.add(template_fast_off_cleanup,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_on_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_cleanup,
                                    self._manual_change_received)
    async def run_test(loop):
        """Asyncio test method."""
        plm = MockPLM(loop)
        callbacks = MockCallbacks()

        address = '1a2b3c'
        cat = 0x02
        subcat = 0x0d
        product_key = None
        description = 'ToggleLinc Relay'
        model = '2466S'

        device = SwitchedLightingControl_2663_222(plm, address, cat, subcat,
                                                  product_key, description,
                                                  model)
        plm.devices[address] = device
        assert device.address.hex == address
        assert device.cat == cat
        assert device.subcat == subcat
        assert device.product_key == 0x00  # Product key should not be None
        assert device.description == description
        assert device.model == model
        assert device.id == address

        device.states[0x01].register_updates(callbacks.callbackmethod1)
        device.states[0x02].register_updates(callbacks.callbackmethod2)

        receivedmsg = StandardReceive(address,
                                      '000001',
                                      COMMAND_LIGHT_ON_0X11_NONE,
                                      cmd2=0x66,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0xff

        receivedmsg = StandardReceive(address,
                                      '000001',
                                      COMMAND_LIGHT_OFF_0X13_0X00,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue1 == 0x00

        receivedmsg = StandardReceive(address,
                                      '000002',
                                      COMMAND_LIGHT_ON_0X11_NONE,
                                      cmd2=0x66,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue2 == 0xff

        receivedmsg = StandardReceive(address,
                                      '000002',
                                      COMMAND_LIGHT_OFF_0X13_0X00,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
                                          2, 3))
        plm.message_received(receivedmsg)
        await asyncio.sleep(.1, loop=loop)
        assert callbacks.callbackvalue2 == 0x00
    async def run_test(loop):
        """Asyncio test."""
        class fanLincStatus():
            """Callback class to capture sensor changes."""

            lightOnLevel = None
            fanOnLevel = None

            # pylint: disable=unused-argument
            def device_status_callback1(self, device_id, state, value):
                """Callback method to capture light changes."""
                self.lightOnLevel = value

            # pylint: disable=unused-argument
            def device_status_callback2(self, device_id, state, value):
                """Callback method to capture fan changes."""
                self.fanOnLevel = value

        mockPLM = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'

        cat = 0x01
        subcat = 0x2e
        product_key = 0x00
        description = 'FanLinc Dual Band'
        model = '2475F'

        callbacks = fanLincStatus()

        device = DimmableLightingControl_2475F(mockPLM, address, cat, subcat,
                                               product_key, description, model)

        mockPLM.devices[device.address.hex] = device

        assert device.states[0x01].name == 'lightOnLevel'
        assert device.states[0x02].name == 'fanOnLevel'

        device.states[0x01].register_updates(callbacks.device_status_callback1)
        device.states[0x02].register_updates(callbacks.device_status_callback2)

        device.states[0x01].async_refresh_state()
        await asyncio.sleep(.1, loop=loop)
        ackmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
                              acknak=MESSAGE_ACK)
        statusmsg = StandardReceive(
            address, target, {'cmd1': 0xdf, 'cmd2': 0x55},
            flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
                                      0, 2, 3))
        mockPLM.message_received(ackmsg)
        await asyncio.sleep(.1, loop=loop)
        mockPLM.message_received(statusmsg)
        await asyncio.sleep(.1, loop=loop)

        assert callbacks.lightOnLevel == 0x55

        device.states[0x02].async_refresh_state()
        await asyncio.sleep(.1, loop=loop)
        ackmsg = StandardSend(address, {'cmd1': 0x19, 'cmd2': 0x03},
                              flags=0x00, acknak=MESSAGE_ACK)
        statusmsg = StandardReceive(
            address, target, {'cmd1': 0xab, 'cmd2': 0x77},
            flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
                                      0, 2, 3))
        mockPLM.message_received(ackmsg)
        await asyncio.sleep(.1, loop=loop)
        mockPLM.message_received(statusmsg)
        await asyncio.sleep(.1, loop=loop)

        assert callbacks.lightOnLevel == 0x55
        assert callbacks.fanOnLevel == 0x77
示例#22
0
    def run_test(loop):
        """Asyncio test run."""
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'

        cat = 0x07
        subcat = 0x00
        product_key = 0x00
        description = 'I/O Linc'
        model = '2450'

        callbacks = MockCallbacks()

        device = SensorsActuators_2450(plm, address, cat, subcat, product_key,
                                       description, model)
        plm.devices[address] = device
        assert device.states[0x01].name == 'openClosedRelay'
        assert device.states[0x02].name == 'openClosedSensor'

        device.states[0x01].register_updates(callbacks.callbackmethod1)
        device.states[0x02].register_updates(callbacks.callbackmethod2)

        device.async_refresh_state()
        yield from asyncio.sleep(.1, loop=loop)

        # First state
        sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
        assert plm.sentmessage == sentmsg.hex

        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target,
                                      COMMAND_LIGHT_ON_0X11_NONE,
                                      cmd2=0x55,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0))
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.3, loop=loop)
        assert callbacks.callbackvalue1 == 0xff

        # Second state
        receivedmsg = StandardSend(address,
                                   COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01,
                                   acknak=MESSAGE_ACK)
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)
        receivedmsg = StandardReceive(address,
                                      target,
                                      COMMAND_LIGHT_ON_0X11_NONE,
                                      cmd2=0x33,
                                      flags=MessageFlags.create(
                                          MESSAGE_TYPE_BROADCAST_MESSAGE, 0))
        plm.message_received(receivedmsg)
        yield from asyncio.sleep(.1, loop=loop)

        sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0xff
        assert callbacks.callbackvalue2 == 1
示例#23
0
    def __init__(self,
                 address,
                 statename,
                 group,
                 send_message_method,
                 message_callbacks,
                 defaultvalue=None):
        """Initialize the LeakSensorDry state."""
        super().__init__(address, statename, group, send_message_method,
                         message_callbacks, defaultvalue)

        self._dry_wet_callbacks = []

        template_dry_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            cmd2=self._group,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None))

        template_wet_broadcast = StandardReceive.template(
            commandtuple={
                'cmd1': 0x13,
                'cmd2': self._group
            },
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None))

        template_dry_all_link = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            cmd2=self._group,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))

        template_wet_all_link = StandardReceive.template(
            commandtuple={
                'cmd1': 0x13,
                'cmd2': self._group
            },
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))

        template_dry_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            cmd2=self._group,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))

        template_wet_cleanup = StandardReceive.template(
            commandtuple={
                'cmd1': 0x13,
                'cmd2': self._group
            },
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))

        self._message_callbacks.add(template_dry_broadcast,
                                    self._dry_message_received)
        self._message_callbacks.add(template_wet_broadcast,
                                    self._wet_message_received)
        self._message_callbacks.add(template_dry_all_link,
                                    self._dry_message_received)
        self._message_callbacks.add(template_wet_all_link,
                                    self._wet_message_received)
        self._message_callbacks.add(template_dry_cleanup,
                                    self._dry_message_received)
        self._message_callbacks.add(template_wet_cleanup,
                                    self._wet_message_received)
    async def run_test(loop):
        """Asyncio test to run."""
        plm = MockPLM(loop)
        address = '1a2b3c'
        target = '4d5e6f'
        cat = 0x01
        subcat = 0x04
        product_key = None
        description = 'SwitchLinc Dimmer (1000W)'
        model = '2476DH'
        device = DimmableLightingControl(plm, address, cat, subcat,
                                         product_key, description, model)

        assert device.address.hex == address
        assert device.cat == cat
        assert device.subcat == subcat
        assert device.product_key == 0x00  # Product key should not be None
        assert device.description == description
        assert device.model == model
        assert device.id == address

        plm.devices[device.address.hex] = device

        callbacks = MockCallbacks()
        device.states[0x01].register_updates(callbacks.callbackmethod1)

        device.states[0x01].on()
        await asyncio.sleep(.1, loop=loop)
        plm.message_received(StandardSend(
            address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
            acknak=MESSAGE_ACK))
        await asyncio.sleep(.1, loop=loop)
        plm.message_received(StandardReceive(
            address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
            flags=MessageFlags.create(
                MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0, 2, 3)))
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0xff

        device.states[0x01].off()
        await asyncio.sleep(.1, loop=loop)
        recievedmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00,
                                   acknak=MESSAGE_ACK)
        plm.message_received(recievedmsg)
        await asyncio.sleep(.1, loop=loop)
        recievedmsg = StandardReceive(
            address, target, COMMAND_LIGHT_OFF_0X13_0X00,
            flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
                                      0, 2, 3))
        plm.message_received(recievedmsg)
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0x00

        device.states[0x01].set_level(0x55)
        await asyncio.sleep(.1, loop=loop)
        recievedmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
                                   cmd2=0x55, acknak=MESSAGE_ACK)
        plm.message_received(recievedmsg)
        await asyncio.sleep(.1, loop=loop)
        recievedmsg = StandardReceive(
            address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x55,
            flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
                                      0, 2, 3))
        plm.message_received(recievedmsg)
        await asyncio.sleep(.1, loop=loop)
        sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
                               cmd2=0x55)
        assert plm.sentmessage == sentmsg.hex
        assert callbacks.callbackvalue1 == 0x55
示例#25
0
    def _register_messages(self):
        _LOGGER.debug("Registering callbacks for DimmableSwitch device %s",
                      self._address.human)
        template_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_on_fast_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_off_fast_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_manual_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_instant_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_manual_off_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )
        template_manual_on_cleanup = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
            cmd2=self._group,
        )

        template_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
        )
        template_on_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
        )
        template_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )
        template_off_fast_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )
        template_manual_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )
        template_instant_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )
        template_manual_off_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_OFF_0X22_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )
        template_manual_on_broadcast = StandardReceive.template(
            commandtuple=COMMAND_LIGHT_MANUALLY_TURNED_ON_0X23_0X00,
            address=self._address,
            target=bytearray([0x00, 0x00, self._group]),
            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
            cmd2=None,
        )

        self._message_callbacks.add(template_on_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_on_fast_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_off_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_off_fast_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_instant_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_cleanup,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_on_cleanup,
                                    self._manual_change_received)

        self._message_callbacks.add(template_on_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_on_fast_broadcast,
                                    self._on_message_received)
        self._message_callbacks.add(template_off_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_off_fast_broadcast,
                                    self._off_message_received)
        self._message_callbacks.add(template_manual_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_instant_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_off_broadcast,
                                    self._manual_change_received)
        self._message_callbacks.add(template_manual_on_broadcast,
                                    self._manual_change_received)