def _register_messages(self):
# The actual group number is 0x01 for the IOLinc sensor so this
# is hard coded in these template messages
template_close_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
cmd2=0x01)
template_open_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
cmd2=0x01)
template_close_group = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
target=bytearray([0x00, 0x00, 0x01]),
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
template_open_group = StandardReceive.template(
commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
address=self._address,
target=bytearray([0x00, 0x00, 0x01]),
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None),
cmd2=None)
self._message_callbacks.add(template_open_cleanup,
self._open_message_received)
self._message_callbacks.add(template_close_cleanup,
self._close_message_received)
self._message_callbacks.add(template_open_group,
self._open_message_received)
self._message_callbacks.add(template_close_group,
self._close_message_received)
def _onOffSenorTest(onOffClass, loop):
"""Test on/off sensor."""
plm = MockPLM(loop=loop)
address = '1a2b3c'
target = bytearray([0x00, 0x00, 0x01])
cat = 0x10
subcat = 0x00
product_key = 0x00
description = 'Generic Security, Heath and Safety Device'
model = ''
callbacks = MockCallbacks()
device = onOffClass(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=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
device = onOffClass(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 == 0
def __init__(
self,
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue=None,
):
"""Init the State state."""
super().__init__(
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue,
)
self._is_responder = False
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_BROADCAST_MESSAGE, None),
cmd2=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_BROADCAST_MESSAGE, None),
cmd2=None,
)
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),
cmd2=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,
)
self._message_callbacks.add(template_on_broadcast,
self._sensor_on_command_received)
self._message_callbacks.add(template_off_broadcast,
self._sensor_off_command_received)
self._message_callbacks.add(template_on_group,
self._sensor_on_command_received)
self._message_callbacks.add(template_off_group,
self._sensor_off_command_received)
def _register_messages(self):
mode_status_msg = StandardReceive.template(
commandtuple=COMMAND_THERMOSTAT_MODE_STATUS_0X70_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE, None),
)
mode_change_fan_on_ack = StandardReceive.template(
commandtuple=COMMAND_THERMOSTAT_CONTROL_ON_FAN_0X6B_0X07,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK),
)
mode_change_fan_auto_ack = StandardReceive.template(
commandtuple=COMMAND_THERMOSTAT_CONTROL_OFF_FAN_0X6B_0X08,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK),
)
mode_change_off_ack = StandardReceive.template(
commandtuple=COMMAND_THERMOSTAT_CONTROL_OFF_ALL_0X6B_0X09,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE_ACK),
)
ext_status_recd = ExtendedReceive.template(
commandtuple=COMMAND_EXTENDED_GET_SET_0X2E_0X00,
cmd2=0x02,
userdata=Userdata.template({"d1": 0x01}),
)
self._message_callbacks.add(mode_status_msg, self._status_received)
self._message_callbacks.add(mode_change_fan_on_ack,
self._mode_change_ack)
self._message_callbacks.add(mode_change_fan_auto_ack,
self._mode_change_ack)
self._message_callbacks.add(mode_change_off_ack, self._mode_change_ack)
self._message_callbacks.add(ext_status_recd, self._ext_status_received)
def __init__(self,
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue=None):
"""Initialize the State state."""
super().__init__(address, statename, group, send_message_method,
message_callbacks, defaultvalue)
template_broadcast = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None))
template_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))
template_group = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, None))
self._message_callbacks.add(template_broadcast,
self._sensor_state_received)
self._message_callbacks.add(template_cleanup,
self._sensor_state_received)
self._message_callbacks.add(template_group,
self._sensor_state_received)
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
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)
yield from 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)
yield from 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)
yield from 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)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue2 == 0x00
def run_test(loop):
"""Asyncio test method."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x02
subcat = 0x0d
product_key = None
description = 'ToggleLinc Relay'
model = '2466S'
device = SwitchedLightingControl(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
callbacks = MockCallbacks()
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x01].on()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff, acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
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_ON_0X11_NONE, cmd2=0xff)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0xff
device.states[0x01].off()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_OFF_0X13_0X00,
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_OFF_0X13_0X00)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x00
def __init__(
self,
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue=None,
dry_wet=None,
):
"""Init the LeakSensorDry state."""
super().__init__(
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue,
)
self._dry_wet_type = dry_wet
self._dry_wet_callbacks = []
template_broadcast = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
target=bytearray([0x00, 0x00, self._group]),
flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None),
)
template_all_link = 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_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
target=bytearray([0x00, 0x00, self._group]),
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
)
self._message_callbacks.add(template_broadcast,
self._dry_wet_message_received)
self._message_callbacks.add(template_all_link,
self._dry_wet_message_received)
self._message_callbacks.add(template_cleanup,
self._dry_wet_message_received)
def run_test(loop):
"""Asyncio coroutine to actually run the test."""
class sensorState(object):
"""Callback class to caputure sensor value changes."""
sensor = None
def sensor_status_callback(self, device_id, state, value):
"""Callback method to update sensor value."""
self.sensor = value
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):
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
def test_messagecallback_basic():
"""Test messagecallback basic."""
callbacks = MessageCallback()
callbacktest1 = "test callback 1"
msg_template = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE, flags=0x80)
callbacks[msg_template] = callbacktest1
msg = StandardReceive('1a2b3c', '4d5e6f', COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff, flags=0x80)
callback1 = callbacks.get_callbacks_from_message(msg)
assert len(callback1) == 1
assert callback1[0] == callbacktest1
async def run_test(loop):
"""Asyncio test method."""
class lightStatus():
"""Callback class to capture state changes."""
lightOnLevel1 = None
lightOnLevel2 = None
# pylint: disable=unused-argument
def device_status_callback1(self, device_id, state, value):
"""Callback method to capture upper outlet changes."""
self.lightOnLevel1 = value
# pylint: disable=unused-argument
def device_status_callback2(self, device_id, state, value):
"""Callback method to capture lower outlet changes."""
self.lightOnLevel2 = value
mockPLM = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x02
subcat = 0x0d
product_key = None
description = 'ToggleLinc Relay'
model = '2466S'
callbacks = lightStatus()
device = SwitchedLightingControl_2663_222(mockPLM, address, cat,
subcat, product_key,
description, model)
mockPLM.devices[address] = device
assert device.states[0x01].name == 'outletTopOnOff'
assert device.states[0x02].name == 'outletBottomOnOff'
device.states[0x01].register_updates(callbacks.device_status_callback1)
device.states[0x02].register_updates(callbacks.device_status_callback2)
device.states[0x02].async_refresh_state()
await asyncio.sleep(.1, loop)
ackmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01,
acknak=MESSAGE_ACK)
statusmsg = StandardReceive(address,
target, {
'cmd1': 0x03,
'cmd2': 0x01
},
flags=MessageFlags.create(
MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0, 2,
3))
mockPLM.message_received(ackmsg)
await asyncio.sleep(.1, loop)
mockPLM.message_received(statusmsg)
await asyncio.sleep(.1, loop)
assert callbacks.lightOnLevel2 == 0x00
def run_test(loop):
"""Asyncio test method."""
plm = MockPLM(loop)
address = '1a2b3c'
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)
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)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x66
receivedmsg = StandardReceive(address,
'000001',
COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(
MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x00
def test_messagecallback_msg():
"""Test messagecallback msg."""
callbacks = MessageCallback()
callbacktest = "test callback"
address = '1a2b3c'
target = '4d5e6f'
template_on = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE)
callbacks.add(template_on, callbacktest)
msg1 = StandardReceive(address, target, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0x00)
msg2 = StandardReceive(address, target, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff)
callback1 = callbacks.get_callbacks_from_message(msg1)
callback2 = callbacks.get_callbacks_from_message(msg2)
assert callback1[0] == callbacktest
assert callback2[0] == callbacktest
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)
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)
def __init__(self,
address,
statename,
group,
send_message_method,
message_callbacks,
defaultvalue=None):
"""Initialize the IoLinkSensor."""
super().__init__(address, statename, group, send_message_method,
message_callbacks, defaultvalue)
self._updatemethod = self._send_status_request
template_open_broadcast = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None))
template_close_broadcast = StandardReceive.template(
commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_BROADCAST_MESSAGE, None),
cmd2=None)
template_open_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None))
template_close_cleanup = StandardReceive.template(
commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
address=self._address,
flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
cmd2=None)
template_open_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),
cmd2=self._group)
template_close_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=self._group)
self._message_callbacks.add(template_open_broadcast,
self._open_message_received)
self._message_callbacks.add(template_close_broadcast,
self._close_message_received)
self._message_callbacks.add(template_open_cleanup,
self._open_message_received)
self._message_callbacks.add(template_close_cleanup,
self._close_message_received)
self._message_callbacks.add(template_open_group,
self._open_message_received)
self._message_callbacks.add(template_close_group,
self._close_message_received)
def _register_messages(self):
_LOGGER.debug('Starting HeatSetPoint register_messages')
heat_set_point_status = StandardReceive.template(
address=self._address,
commandtuple=COMMAND_THERMOSTAT_HEAT_SET_POINT_STATUS_0X72_NONE,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE, False))
self._message_callbacks.add(heat_set_point_status,
self._status_message_received)
ext_status_recd = ExtendedReceive.template(
commandtuple=COMMAND_EXTENDED_GET_SET_0X2E_0X00,
cmd2=0x02,
flags=MessageFlags.template(MESSAGE_TYPE_DIRECT_MESSAGE, True),
userdata=Userdata.template({"d1": 0x01}))
_LOGGER.debug('Reg Ext Status: %s', ext_status_recd)
self._message_callbacks.add(ext_status_recd, self._ext_status_received)
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 _register_messages(self):
ext_msg_aldb_record = ExtendedReceive.template(
address=self._address,
commandtuple=COMMAND_EXTENDED_READ_WRITE_ALDB_0X2F_0X00,
userdata=Userdata.template({'d2': 1}),
flags=MessageFlags.template(
messageType=MESSAGE_TYPE_DIRECT_MESSAGE, extended=1))
std_msg_pre_nak = StandardReceive.template(flags=MessageFlags.template(
messageType=MESSAGE_FLAG_DIRECT_MESSAGE_NAK_0XA0),
cmd2=0xfc)
ext_msg_pre_nak = ExtendedReceive.template(flags=MessageFlags.template(
messageType=MESSAGE_FLAG_DIRECT_MESSAGE_NAK_0XA0),
cmd2=0xfc)
self._message_callbacks.add(ext_msg_aldb_record,
self._handle_aldb_record_received)
self._message_callbacks.add(std_msg_pre_nak, self._handle_pre_nak)
self._message_callbacks.add(ext_msg_pre_nak, self._handle_pre_nak)
def test_standardReceive():
"""Test StandardReceive."""
address = bytearray([0x11, 0x22, 0x33])
target = bytearray([0x44, 0x55, 0x66])
flags = 0x77
cmd1 = 0x88
cmd2 = 0x99
msg = StandardReceive(address,
target, {
'cmd1': cmd1,
'cmd2': cmd2
},
flags=flags)
assert msg.hex == hexmsg(0x02, 0x50, Address(address), Address(target),
flags, cmd1, cmd2)
assert len(msg.hex) / 2 == msg.sendSize
assert len(msg.hex) / 2 == msg.receivedSize
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
def _register_message_handlers(self):
template_assign_all_link = StandardReceive.template(
commandtuple=COMMAND_ASSIGN_TO_ALL_LINK_GROUP_0X01_NONE)
template_all_link_response = AllLinkRecordResponse(None, None, None,
None, None, None)
template_get_im_info = GetImInfo()
template_next_all_link_rec = GetNextAllLinkRecord(acknak=MESSAGE_NAK)
template_all_link_complete = AllLinkComplete(None, None, None,
None, None, None)
template_x10_send = X10Send(None, None, MESSAGE_ACK)
template_x10_received = X10Received(None, None)
self._message_callbacks.add(
template_assign_all_link,
self._handle_assign_to_all_link_group)
self._message_callbacks.add(
template_all_link_response,
self._handle_all_link_record_response)
self._message_callbacks.add(
template_get_im_info,
self._handle_get_plm_info)
self._message_callbacks.add(
template_next_all_link_rec,
self._handle_get_next_all_link_record_nak)
self._message_callbacks.add(
template_all_link_complete,
self._handle_assign_to_all_link_group)
self._message_callbacks.add(
template_x10_send,
self._handle_x10_send_receive)
self._message_callbacks.add(
template_x10_received,
self._handle_x10_send_receive)
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
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
async def do_plm(loop):
"""Asyncio coroutine to test the PLM."""
_LOGGER.info('Connecting to Insteon PLM')
# pylint: disable=not-an-iterable
conn = await MockConnection.create(loop=loop)
def async_insteonplm_light_callback(device):
"""Log that our new device callback worked."""
_LOGGER.warning('New Device: %s %02x %02x %s, %s', device.id,
device.cat, device.subcat, device.description,
device.model)
# pylint: disable=unused-variable
def async_light_on_level_callback(device_id, state, value):
"""Callback to catch changes to light value."""
_LOGGER.info('Device %s state %s value is changed to %02x', device_id,
state, value)
conn.protocol.add_device_callback(async_insteonplm_light_callback)
plm = conn.protocol
plm.connection_made(conn.transport)
_LOGGER.info('Replying with IM Info')
_LOGGER.info('_____________________')
cmd_sent = await wait_for_plm_command(plm, GetImInfo(), loop)
if not cmd_sent:
assert False
msg = insteonplm.messages.getIMInfo.GetImInfo(address='1a2b3c',
cat=0x03,
subcat=0x20,
firmware=0x00,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
assert plm.address == Address('1a2b3c')
assert plm.cat == 0x03
assert plm.subcat == 0x20
assert plm.product_key == 0x00
_LOGGER.info('Replying with an All-Link Record')
_LOGGER.info('________________________________')
cmd_sent = await wait_for_plm_command(plm, GetFirstAllLinkRecord(), loop)
if not cmd_sent:
assert False
msg = GetFirstAllLinkRecord(MESSAGE_ACK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = AllLinkRecordResponse(flags=0x00,
group=0x01,
address='4d5e6f',
linkdata1=0x01,
linkdata2=0x0b,
linkdata3=0x000050)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT)
_LOGGER.info('Replying with Last All-Link Record')
_LOGGER.info('__________________________________')
cmd_sent = await wait_for_plm_command(plm, GetNextAllLinkRecord(), loop)
if not cmd_sent:
assert False
msg = GetNextAllLinkRecord(MESSAGE_NAK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = GetNextAllLinkRecord(MESSAGE_NAK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = GetNextAllLinkRecord(MESSAGE_NAK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = GetNextAllLinkRecord(MESSAGE_NAK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
_LOGGER.info('Replying with Device Info Record')
_LOGGER.info('________________________________')
msg = StandardSend('4d5e6f', COMMAND_ID_REQUEST_0X10_0X00)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
msg = StandardSend('4d5e6f',
COMMAND_ID_REQUEST_0X10_0X00,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = StandardReceive(address='4d5e6f',
target='010b00',
commandtuple={
'cmd1': 0x01,
'cmd2': 0x00
},
flags=MESSAGE_FLAG_BROADCAST_0X80)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
for addr in plm.devices:
_LOGGER.info('Device: %s', addr)
_LOGGER.info('Replying with Device Status Record')
_LOGGER.info('__________________________________')
msg = StandardSend('4d5e6f', COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
msg = StandardSend('4d5e6f',
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
msg = insteonplm.messages.standardReceive.StandardReceive(address='4d5e6f',
target='1a2b3c',
commandtuple={
'cmd1': 0x17,
'cmd2': 0xaa
},
flags=0x20)
plm.data_received(msg.bytes)
await asyncio.sleep(RECV_MSG_WAIT, loop=loop)
assert plm.devices['4d5e6f'].states[0x01].value == 0xaa
_LOGGER.info('Testing device message ACK/NAK handling')
_LOGGER.info('_______________________________________')
plm.devices['4d5e6f'].states[0x01].on()
plm.devices['4d5e6f'].states[0x01].off()
plm.devices['4d5e6f'].states[0x01].set_level(0xbb)
# Test that the first ON command is sent
msg = StandardSend('4d5e6f', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
# ACK the ON command
msg = StandardSend('4d5e6f',
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
flags=0x00,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
# Let the Direct ACK timeout expire
await asyncio.sleep(DIRECT_ACK_WAIT_TIMEOUT, loop=loop)
# Test that the Off command has now sent
msg = StandardSend('4d5e6f', COMMAND_LIGHT_OFF_0X13_0X00)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
# NAK the OFF command and test that the OFF command is resent
plm.transport.lastmessage = ''
msg = StandardSend('4d5e6f',
COMMAND_LIGHT_OFF_0X13_0X00,
acknak=MESSAGE_NAK)
plm.data_received(msg.bytes)
msg = StandardSend('4d5e6f', COMMAND_LIGHT_OFF_0X13_0X00)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
# Let the ACK/NAK timeout expire and test that the OFF command is resent
plm.transport.lastmessage = ''
msg = StandardSend('4d5e6f', COMMAND_LIGHT_OFF_0X13_0X00)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
# ACK the OFF command and let the Direct ACK message expire
msg = StandardSend('4d5e6f',
COMMAND_LIGHT_OFF_0X13_0X00,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
# Direct ACK of off message
msg = StandardReceive(address='4d5e6f',
target='010b00',
commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
flags=MESSAGE_FLAG_DIRECT_MESSAGE_ACK_0X20)
plm.data_received(msg.bytes)
# Test that the second SET_LEVEL command is sent
msg = StandardSend('4d5e6f', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xbb)
cmd_sent = await wait_for_plm_command(plm, msg, loop)
if not cmd_sent:
assert False
# ACK the SET_LEVEL command and let the Direct ACK message expire
msg = StandardSend('4d5e6f',
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xbb,
acknak=MESSAGE_ACK)
plm.data_received(msg.bytes)
msg = StandardReceive(address='4d5e6f',
target='010b00',
commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xbb,
flags=MESSAGE_FLAG_DIRECT_MESSAGE_ACK_0X20)
plm.data_received(msg.bytes)
await plm.close()
_LOGGER.error('PLM closed in test_plm')
await asyncio.sleep(.1, loop=loop)
open_tasks = asyncio.Task.all_tasks(loop=loop)
for task in open_tasks:
if hasattr(task, 'name'):
_LOGGER.error('Device: %s Task: %s', task.name, task)
else:
_LOGGER.error('Task: %s', task)
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)
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)
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)
