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)
