def test_extended_ack():
"""Test extended ack."""
callbacks = MockCallbacks()
callbacks.callbackvalue1 = "Callback 1"
callbacks.callbackvalue2 = "Callback 2"
message_callbacks = MessageCallback()
address = '1a2b3c'
template_ext_ack = ExtendedSend.template(address, acknak=MESSAGE_ACK)
template_std_ack = StandardSend.template(address, acknak=MESSAGE_ACK)
message_callbacks.add(template_ext_ack, callbacks.callbackvalue1)
message_callbacks.add(template_std_ack, callbacks.callbackvalue2)
extmsg = ExtendedSend(address,
COMMAND_LIGHT_ON_0X11_NONE, {'d1': 0x02},
cmd2=0xff,
acknak=MESSAGE_ACK)
stdmsg = StandardSend(address,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
acknak=MESSAGE_ACK)
result1 = message_callbacks.get_callbacks_from_message(extmsg)
result2 = message_callbacks.get_callbacks_from_message(stdmsg)
assert result2 == [callbacks.callbackvalue2]
assert result1 == [callbacks.callbackvalue1]
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)
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 _send_status_request(self):
msg = StandardSend(
address=self._address,
commandtuple=COMMAND_THERMOSTAT_GET_ZONE_INFORMATION_0X6A_NONE,
cmd2=0x00,
)
self._send_method(msg, self._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 device_text_string_request(self):
"""Get FX Username.
Only required for devices that support FX Commands.
FX Addressee responds with an ED 0x0301 FX Username Response message.
"""
msg = StandardSend(self._address, COMMAND_FX_USERNAME_0X03_0X01)
self._send_msg(msg)
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 assign_to_all_link_group(self, group=0x01):
"""Assign a device to an All-Link Group.
The default is group 0x01.
"""
msg = StandardSend(self._address,
COMMAND_ASSIGN_TO_ALL_LINK_GROUP_0X01_NONE,
cmd2=group)
self._send_msg(msg)
def product_data_request(self):
"""Request product data from a device.
Not supported by all devices.
Required after 01-Feb-2007.
"""
msg = StandardSend(self._address,
COMMAND_PRODUCT_DATA_REQUEST_0X03_0X00)
self._send_msg(msg)
def enter_unlinking_mode(self, group):
"""Unlink a device from an All-Link group.
Not supported by i1 devices.
"""
msg = StandardSend(self._address,
COMMAND_ENTER_UNLINKING_MODE_0X0A_NONE,
cmd2=group)
self._send_msg(msg)
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 test_delete_callback():
"""Test delete callback."""
callbacks = MessageCallback()
callbacktest1 = "test callback 1"
callbacktest2 = "test callback 2"
callbacktest3 = "test callback 3"
callbacks.add(StandardSend.template(), callbacktest1)
callbacks.add(StandardSend.template(), callbacktest2)
callbacks.add(StandardSend.template(acknak=MESSAGE_NAK), callbacktest3)
msg = StandardSend('333333', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
acknak=MESSAGE_NAK)
callback_list = callbacks.get_callbacks_from_message(msg)
assert len(callback_list) == 3
callbacks.remove(StandardSend.template(), callbacktest2)
callback_list = callbacks.get_callbacks_from_message(msg)
assert len(callback_list) == 2
def enter_linking_mode(self, group=0x01):
"""Tell a device to enter All-Linking Mode.
Same as holding down the Set button for 10 sec.
Default group is 0x01.
Not supported by i1 devices.
"""
msg = StandardSend(self._address,
COMMAND_ENTER_LINKING_MODE_0X09_NONE,
cmd2=group)
self._send_msg(msg)
def test_standardSend():
"""Test StandardSend."""
address = bytearray([0x11, 0x22, 0x33])
flags = 0x44
cmd1 = 0x55
cmd2 = 0x66
ack = 0x06
nak = 0x15
msg = StandardSend(address, {'cmd1': cmd1, 'cmd2': cmd2}, flags=flags)
assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags, cmd1, cmd2)
assert not msg.isack
assert not msg.isnak
assert len(msg.hex) / 2 == msg.sendSize
msg = StandardSend(address, {
'cmd1': cmd1,
'cmd2': cmd2
},
flags=flags,
acknak=ack)
assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags, cmd1, cmd2,
ack)
assert msg.isack
assert not msg.isnak
assert len(msg.hex) / 2 == msg.receivedSize
msg = StandardSend(address, {
'cmd1': cmd1,
'cmd2': cmd2
},
flags=flags,
acknak=nak)
assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags, cmd1, cmd2,
nak)
assert not msg.isack
assert msg.isnak
assert len(msg.hex) / 2 == msg.receivedSize
def set_position_fast(self, val):
"""Set the devive OPEN LEVEL."""
if val == 0:
self.close_fast()
else:
setlevel = 255
if val < 1:
setlevel = val * 100
elif val <= 0xFF:
setlevel = val
set_command = StandardSend(self._address,
COMMAND_LIGHT_ON_FAST_0X12_NONE,
cmd2=setlevel)
self._send_method(set_command, self._open_message_received)
def set_level(self, val):
"""Set the devive ON LEVEL."""
if val == 0:
self.off()
else:
setlevel = 255
if val < 1:
setlevel = val * 100
elif val <= 0xff:
setlevel = val
set_command = StandardSend(self._address,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=setlevel)
self._send_method(set_command, self._on_message_received)
def run_test(loop):
mockPLM = MockPLM(loop)
address = '1a2b3c'
device = insteonplm.devices.create(mockPLM, address, 0x01, 0x0d, 0x44)
mockPLM.devices[address] = device
# Send the ON command. This should be sent directly to the PLM
device.states[0x01].on()
yield from asyncio.sleep(.1, loop=loop)
# Send the OFF command. This should wait in queue until the
# Direct ACK timeout
device.states[0x01].off()
yield from asyncio.sleep(.1, loop=loop)
# ACK the ON command
msgreceived = StandardSend(address,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
flags=0x00,
acknak=MESSAGE_ACK)
mockPLM.message_received(msgreceived)
asyncio.sleep(.1, loop=loop)
_LOGGING.debug('Assert that the ON command is the command in the PLM')
assert mockPLM.sentmessage == StandardSend(address,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
flags=0x00).hex
# Sleep until the Direct ACK time out should expire
yield from asyncio.sleep(DIRECT_ACK_WAIT_TIMEOUT + .2, loop=loop)
# Confirm that the OFF command made it to the PLM
assert mockPLM.sentmessage == StandardSend(
address, COMMAND_LIGHT_OFF_0X13_0X00).hex
def test_messagecallback_acknak():
"""Test messagecallback acknak."""
callbacks = MessageCallback()
callbacktest1 = "test callback 1"
callbacktest2 = "test callback 2"
callbacktest3 = "test callback 3"
callbacktest4 = "test callback 4"
address = '1a2b3c'
template_address = StandardSend.template(address=address)
template_address_ack = StandardSend.template(address=address,
acknak=MESSAGE_ACK)
template_empty = StandardSend.template()
template_nak = StandardSend.template(acknak=MESSAGE_NAK)
callbacks.add(template_address, callbacktest1)
callbacks.add(template_address_ack, callbacktest2)
callbacks.add(template_empty, callbacktest3)
callbacks.add(template_nak, callbacktest4)
msg1 = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xcd)
msg2 = StandardSend('222222', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
msg3 = StandardSend('333333',
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
acknak=MESSAGE_NAK)
msg4 = StandardSend('444444',
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff,
acknak=MESSAGE_ACK)
_LOGGER.debug('Getting callbacks for message 1')
callback1 = callbacks.get_callbacks_from_message(msg1)
_LOGGER.debug('Getting callbacks for message 2')
callback2 = callbacks.get_callbacks_from_message(msg2)
_LOGGER.debug('Getting callbacks for message 3')
callback3 = callbacks.get_callbacks_from_message(msg3)
_LOGGER.debug('Getting callbacks for message 4')
callback4 = callbacks.get_callbacks_from_message(msg4)
assert len(callback1) == 4
assert len(callback2) == 2
assert len(callback3) == 2
assert len(callback4) == 1
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 _status_request(self):
status_command = StandardSend(self._address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_NONE,
cmd2=0x03)
self._send_method(status_command, self._status_message_received)
def dim(self):
"""Dim the device one step."""
dim_command = StandardSend(self._address,
COMMAND_LIGHT_DIM_ONE_STEP_0X16_0X00)
self._send_method(dim_command)
def brighten(self):
"""Brighten the device one step."""
brighten_command = StandardSend(
self._address, COMMAND_LIGHT_BRIGHTEN_ONE_STEP_0X15_0X00)
self._send_method(brighten_command)
def off(self):
"""Turn the device off."""
off_command = StandardSend(self._address, COMMAND_LIGHT_OFF_0X13_0X00)
self._send_method(off_command, self._off_message_received)
def on(self):
"""Turn the device ON."""
on_command = StandardSend(self._address,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff)
self._send_method(on_command, self._on_message_received)
def _send_status_request(self):
msg = StandardSend(
address=self._address,
commandtuple=COMMAND_THERMOSTAT_CONTROL_GET_MODE_0X6B_0X02,
)
self._send_method(msg, self._status_received)
def _send_status_request(self):
led_status_msg = StandardSend(self._address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01)
self._send_method(led_status_msg, self._status_message_received)
def _send_status_request(self):
"""Send a status request message to the device."""
status_command = StandardSend(self._address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
self._send_method(status_command, self._status_message_received)
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 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
def close(self):
"""Send CLOSE command to device."""
close_command = StandardSend(self._address,
COMMAND_LIGHT_OFF_0X13_0X00)
self._send_method(close_command, self._close_message_received)
