def add_known_devices(self, plm): """Add devices from the saved devices or from the device overrides.""" from insteonplm.devices import ALDBStatus for addr in self._saved_devices: if not self._devices.get(addr): saved_device = self._saved_devices.get(Address(addr).id, {}) cat = saved_device.get('cat') subcat = saved_device.get('subcat') product_key = saved_device.get('firmware') product_key = saved_device.get('product_key', product_key) device = self.create_device_from_category( plm, addr, cat, subcat, product_key) if device: _LOGGER.debug('Device with id %s added to device list ' 'from saved device data.', addr) aldb_status = saved_device.get('aldb_status', 0) device.aldb.status = ALDBStatus(aldb_status) aldb = saved_device.get('aldb', {}) device.aldb.load_saved_records(aldb_status, aldb) self[addr] = device for addr in self._overrides: if not self._devices.get(addr): device_override = self._overrides.get(Address(addr).id, {}) cat = device_override.get('cat') subcat = device_override.get('subcat') product_key = device_override.get('firmware') product_key = device_override.get('product_key', product_key) device = self.create_device_from_category( plm, addr, cat, subcat, product_key) if device: _LOGGER.debug('Device with id %s added to device list ' 'from device override data.', addr) self[addr] = device
def template( cls, address=None, target=None, commandtuple=None, userdata=None, cmd2=-1, flags=None, ): """Create message template for callbacks.""" msgraw = bytearray([0x02, cls._code]) msgraw.extend(bytes(cls._receivedSize)) msg = ExtendedReceive.from_raw_message(msgraw) if commandtuple: cmd1 = commandtuple.get("cmd1") cmd2out = commandtuple.get("cmd2") else: cmd1 = None cmd2out = None if cmd2 is not -1: cmd2out = cmd2 msg._address = Address(address) msg._target = Address(target) msg._messageFlags = MessageFlags(flags) msg._cmd1 = cmd1 msg._cmd2 = cmd2out msg._userdata = Userdata.create_pattern(userdata) return msg
def __init__(self, address, target, commandtuple, userdata, cmd2=None, flags=0x10): """Initialize the ExtendedRecieve message class.""" if commandtuple.get('cmd1', None) is not None: cmd1 = commandtuple['cmd1'] cmd2out = commandtuple['cmd2'] else: raise ValueError if cmd2 is not None: cmd2out = cmd2 if cmd2out is None: raise ValueError self._address = Address(address) self._target = Address(target) self._messageFlags = MessageFlags(flags) # self._messageFlags.extended = 1 self._cmd1 = cmd1 self._cmd2 = cmd2out self._userdata = Userdata(userdata)
def template(cls, address=None, target=None, commandtuple=None, cmd2=-1, flags=None): """Create a message template used for callbacks.""" msgraw = bytearray([0x02, cls._code]) msgraw.extend(bytes(cls._receivedSize)) msg = StandardReceive.from_raw_message(msgraw) if commandtuple: cmd1 = commandtuple.get('cmd1') cmd2out = commandtuple.get('cmd2') else: cmd1 = None cmd2out = None if cmd2 is not -1: cmd2out = cmd2 msg._address = Address(address) msg._target = Address(target) msg._messageFlags = MessageFlags(flags) msg._cmd1 = cmd1 msg._cmd2 = cmd2out return msg
def test_extendedReceive(): """Test ExtendedReceive.""" address = bytearray([0x11, 0x22, 0x33]) target = bytearray([0x44, 0x55, 0x66]) flags = 0x77 cmd1 = 0x88 cmd2 = 0x99 userdata = {} userdatatest = bytearray() for i in range(1, 15): key = 'd' + str(i) userdata.update({key: 0xe0}) userdatatest.append(0xe0) msg = ExtendedReceive(address, target, { 'cmd1': cmd1, 'cmd2': cmd2 }, userdata, flags=flags) assert msg.hex == hexmsg(0x02, 0x51, Address(address), Address(target), flags, cmd1, cmd2, userdatatest) assert len(msg.hex) / 2 == msg.sendSize assert len(msg.hex) / 2 == msg.receivedSize
def test_eq(): """Test Addresses pattern matching.""" addr1 = Address(None) addr2 = Address('1a2b3c') addr3 = Address('4d5e6f') assert addr1.matches_pattern(addr2) assert addr3.matches_pattern(addr1) assert not (addr2.matches_pattern(addr3)) assert addr2.matches_pattern(addr2)
def test_extendedSend(): """Test ExtendedSend.""" address = bytearray([0x11, 0x22, 0x33]) flags = 0x44 | 0x10 cmd1 = 0x55 cmd2 = 0x66 userdata = {} ack = 0x06 nak = 0x15 for i in range(1, 15): key = 'd' + str(i) val = 0xe0 + i userdata.update({key: val}) msg = ExtendedSend(address, { 'cmd1': cmd1, 'cmd2': cmd2 }, userdata, flags=flags) assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags | 0x10, cmd1, cmd2, userdata) assert not msg.isack assert not msg.isnak assert len(msg.hex) / 2 == msg.sendSize msg = ExtendedSend(address, { 'cmd1': cmd1, 'cmd2': cmd2 }, userdata, flags=flags, acknak=ack) assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags | 0x10, cmd1, cmd2, userdata, ack) assert msg.isack assert not msg.isnak assert len(msg.hex) / 2 == msg.receivedSize msg = ExtendedSend(address, { 'cmd1': cmd1, 'cmd2': cmd2 }, userdata, flags=flags, acknak=nak) assert msg.hex == hexmsg(0x02, 0x62, Address(address), flags | 0x10, cmd1, cmd2, userdata, nak) assert not msg.isack assert msg.isnak assert len(msg.hex) / 2 == msg.receivedSize
def test_x10(): addr = Address.x10('A', 5) assert addr.hex == '000601' assert addr.human == 'X10.A.05' assert addr.is_x10 assert addr.x10_housecode == 'A' assert addr.x10_unitcode == 5 assert addr.x10_housecode_byte == 6 assert addr.x10_unitcode_byte == 1 addr2 = Address.x10('A', 20) assert addr2.human == 'X10.A.20'
async def write_aldb(self, addr, mem_addr: int, mode: str, group: int, target, data1=0x00, data2=0x00, data3=0x00): """Write a device All-Link record.""" dev_addr = Address(addr) target_addr = Address(target) device = self.plm.devices[dev_addr.id] if device: _LOGGING.debug('calling device write_aldb') device.write_aldb(mem_addr, mode, group, target_addr, data1, data2, data3) await asyncio.sleep(1, loop=self.loop) while device.aldb.status == ALDBStatus.LOADING: await asyncio.sleep(1, loop=self.loop) self.print_device_aldb(addr)
def create_device_from_category(self, plm, addr, cat, subcat, product_key=0x00): """Create a new device from the cat, subcat and product_key data.""" saved_device = self._saved_devices.get(Address(addr).id, {}) cat = saved_device.get('cat', cat) subcat = saved_device.get('subcat', subcat) product_key = saved_device.get('product_key', product_key) device_override = self._overrides.get(Address(addr).id, {}) cat = device_override.get('cat', cat) subcat = device_override.get('subcat', subcat) product_key = device_override.get('firmware', product_key) product_key = device_override.get('product_key', product_key) return insteonplm.devices.create(plm, addr, cat, subcat, product_key)
def add_override(self, addr, key, value): """Register an attribute override for a device.""" address = Address(str(addr)).id _LOGGER.debug("New override for %s %s is %s", address, key, value) device_override = self._overrides.get(address, {}) device_override[key] = value self._overrides[address] = device_override
def trigger_group_on(self, group): """Trigger an All-Link Group on.""" from .messages.standardSend import StandardSend from .constants import COMMAND_LIGHT_ON_0X11_NONE target = Address(bytearray([0x00, 0x00, group])) flags = 0xCF msg = StandardSend(target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xFF, flags=flags) self.send_msg(msg) dev_list = self._find_scene(group) _LOGGER.debug("Scene %d turned on", group) for addr in dev_list: device = self._devices[addr.id] flags = 0x4F msg = StandardSend(device.address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=group, flags=flags) self.send_msg(msg) if hasattr(device, "async_refresh_state"): _LOGGER.debug("Checking status of device %s", addr.human) device.async_refresh_state()
def __init__(self, plm, address, cat, subcat, product_key=0x00, description='', model=''): """Initialize the Device class.""" self.log = logging.getLogger(__name__) self._plm = plm self._address = Address(address) self._cat = cat self._subcat = subcat if self._subcat is None: self._subcat = 0x00 self._product_key = product_key if self._product_key is None: self._product_key = 0x00 self._description = description self._model = model self._last_communication_received = datetime.datetime(1, 1, 1, 1, 1, 1) self._recent_messages = asyncio.Queue(loop=self._plm.loop) self._product_data_in_aldb = False self._stateList = StateList() self._send_msg_lock = asyncio.Lock(loop=self._plm.loop) self._sent_msg_wait_for_directACK = {} self._directACK_received_queue = asyncio.Queue(loop=self._plm.loop) self._message_callbacks = MessageCallback() self._aldb = ALDB(self._send_msg, self._plm.loop, self._address) self._register_messages()
def test_bytearray(): """Test Address created from bytearray.""" addr_ba = bytearray([0x1a, 0x2b, 0x3c]) addr = Address(addr_ba) assert addr.human == '1A.2B.3C' assert addr.hex == '1a2b3c' assert addr.bytes == b'\x1a\x2b\x3c'
def test_bytes(): """Test Address created from bytes string.""" addr_b = b'\x1a\x2b\x3c' addr = Address(addr_b) assert addr.human == '1A.2B.3C' assert addr.hex == '1a2b3c' assert addr.bytes == b'\x1a\x2b\x3c'
def template( cls, address=None, commandtuple=None, userdata=None, cmd2=-1, flags=None, acknak=None, ): """Create a message template used for callbacks.""" msgraw = bytearray([0x02, cls._code]) msgraw.extend(bytes(cls._receivedSize)) msg = ExtendedSend.from_raw_message(msgraw) if commandtuple: cmd1 = commandtuple.get("cmd1") cmd2out = commandtuple.get("cmd2") else: cmd1 = None cmd2out = None if cmd2 is not -1: cmd2out = cmd2 msg._address = Address(address) msg._messageFlags = MessageFlags(flags) msg._messageFlags.extended = 1 msg._cmd1 = cmd1 msg._cmd2 = cmd2out msg._userdata = Userdata.template(userdata) msg._acknak = acknak return msg
def __init__(self, address, commandtuple, cmd2=None, flags=0x00, acknak=None): """Initialize the StandardSend message class.""" if commandtuple.get('cmd1', None) is not None: cmd1 = commandtuple['cmd1'] cmd2out = commandtuple['cmd2'] else: raise ValueError if cmd2 is not None: cmd2out = cmd2 if cmd2out is None: raise ValueError self._address = Address(address) self._messageFlags = MessageFlags(flags) self._messageFlags.extended = 0 self._cmd1 = cmd1 self._cmd2 = cmd2out self._acknak = self._setacknak(acknak)
def test_create_allLinkComplete_message(): """Test create allLinkComplete message.""" linkcode = 0x11 group = 0x22 address1 = 0x33 address2 = 0x44 address3 = 0x55 cat = 0x66 subcat = 0x77 firmware = 0x88 rawmessage = bytearray([ 0x02, 0x53, linkcode, group, address1, address2, address3, cat, subcat, firmware ]) msg, buffer = insteonplm.messages.create(rawmessage) assert isinstance(msg, AllLinkComplete) assert msg.linkcode == linkcode assert msg.group == group assert msg.address == Address(bytearray([address1, address2, address3])) assert msg.category == cat assert msg.subcategory == subcat assert msg.firmware == firmware
def __init__(self, address, commandtuple, userdata, cmd2=None, flags=0x10, acknak=None): """Init the ExtendedSend message class.""" if commandtuple.get("cmd1", None) is not None: cmd1 = commandtuple["cmd1"] cmd2out = commandtuple["cmd2"] else: raise ValueError if cmd2 is not None: cmd2out = cmd2 if cmd2out is None: raise ValueError self._address = Address(address) self._messageFlags = MessageFlags(flags) self._messageFlags.extended = 1 self._cmd1 = cmd1 self._cmd2 = cmd2out self._userdata = Userdata(userdata) self._acknak = self._setacknak(acknak)
def __init__(self, flags, group, address, linkdata1, linkdata2, linkdata3): """Init the AllLinkRecordResponse Class.""" self._controlFlags = flags self._group = group self._address = Address(address) self._linkdata1 = linkdata1 self._linkdata2 = linkdata2 self._linkdata3 = linkdata3
def __init__(self, linkcode, group, address, cat, subcat, firmware): """Init the AllLinkComplete Class.""" self._linkcode = linkcode self._group = group self._address = Address(address) self._category = cat self._subcategory = subcat self._firmware = firmware
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 __init__(self, memory, control_flags, group, address, data1, data2, data3): """Initialze the ALDBRecord class.""" self._memoryLocation = memory self._address = Address(address) self._group = group self._data1 = data1 self._data2 = data2 self._data3 = data3 self._control_flags = ControlFlags.create_from_byte(control_flags)
def del_aldb(self, addr, mem_addr: int): """Write a device All-Link record.""" dev_addr = Address(addr) device = self.plm.devices[dev_addr.id] if device: _LOGGING.debug('calling device del_aldb') device.del_aldb(mem_addr) yield from asyncio.sleep(1, loop=self.loop) while device.aldb.status == ALDBStatus.LOADING: yield from asyncio.sleep(1, loop=self.loop) self.print_device_aldb(addr)
def print_device_aldb(self, addr): """Diplay the All-Link database for a device.""" if Address(addr).id == self.plm.address.id: device = self.plm else: dev_addr = Address(addr) device = self.plm.devices[dev_addr.id] if device: if device.aldb.status in [ALDBStatus.LOADED, ALDBStatus.PARTIAL]: if device.aldb.status == ALDBStatus.PARTIAL: _LOGGING.info('ALDB partially loaded for device %s', addr) for mem_addr in device.aldb: record = device.aldb[mem_addr] _LOGGING.debug('mem_addr: %s', mem_addr) _LOGGING.info('ALDB record: %s', record) else: _LOGGING.info('ALDB not loaded. ' 'Use `load_aldb %s` first.', device.address.id) else: _LOGGING.info('Device not found.')
def test_allLinkFailureReport(): """Test AllLinkFailureReport.""" group = 0x11 addr = bytearray([0x22, 0x33, 0x44]) msg = AllLinkCleanupFailureReport(group, addr) assert msg.address == Address(addr) assert msg.group == group assert msg.hex == hexmsg(0x02, 0x56, 0x01, 0x11, 0x22, 0x33, 0x44) assert len(msg.hex) / 2 == msg.sendSize assert len(msg.hex) / 2 == msg.receivedSize
def __init__(self, address, target, commandtuple, cmd2=None, flags=0x00): """Init the StandardReceive message class.""" if commandtuple.get('cmd1') is not None: cmd1 = commandtuple['cmd1'] cmd2out = commandtuple['cmd2'] else: raise ValueError if cmd2 is not None: cmd2out = cmd2 if cmd2out is None: raise ValueError self._address = Address(address) self._target = Address(target) self._messageFlags = MessageFlags(flags) # self._messageFlags.extended = 0 self._cmd1 = cmd1 self._cmd2 = cmd2out
def __init__(self, plm, housecode, unitcode): """Initialize the X10Device class.""" self._address = Address.x10(housecode, unitcode) self._plm = plm self._description = "Generic X10 device" self._model = '' self._aldb = ALDB(None, None, self._address, version=ALDBVersion.Null) self._message_callbacks = MessageCallback() self._stateList = StateList() self._send_msg_lock = asyncio.Lock(loop=self._plm.loop) self.log = logging.getLogger()
def _handle_x10_send_receive(self, msg): housecode_byte, unit_command_byte = rawX10_to_bytes(msg.rawX10) housecode = byte_to_housecode(housecode_byte) if msg.flag == 0x00: unitcode = byte_to_unitcode(unit_command_byte) self._x10_address = Address.x10(housecode, unitcode) if self._x10_address: device = self.devices[self._x10_address.id] if device: device.receive_message(msg) else: self._x10_command_to_device(housecode, unit_command_byte, msg)
def __init__(self, address=None, cat=None, subcat=None, firmware=None, acknak=None): """Initialize the GetImInfo Class.""" self._address = Address(address) self._category = cat self._subcategory = subcat self._firmware = firmware self._acknak = self._setacknak(acknak)