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)