async def do_run():
"""Connect to the PLM and load the ALDB."""
# devices = await async_connect(device=DEVICE)
devices = await async_connect(host=HOST,
username=USERNAME,
password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
# modem = devices.modem '', '13.37.42'
identify_scenes()
device1 = devices["2C.38.32"]
device1.groups[1].subscribe(state_changed)
device2 = devices["13.37.42"]
device2.groups[1].subscribe(state_changed)
_LOGGER.info("Turning scene on")
await async_trigger_scene_on(group=0x1A)
await asyncio.sleep(5)
_LOGGER.info("Turning scene off")
set_log_levels(
logger="info",
logger_pyinsteon="info",
logger_messages="info",
logger_topics=False,
)
await async_trigger_scene_off(group=0x1A)
await asyncio.sleep(5)
await async_close()
async def run():
"""Run the monitoring."""
set_log_levels(
logger="error",
logger_pyinsteon="error",
logger_messages="debug",
logger_topics=False,
)
await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0, refresh=True)
await devices.async_save(workdir=PATH)
print(
"'memory','in_use','controller','high_water_mark','bit5','bit4','group','target','data1','data2','data3'"
)
for addr in devices.modem.aldb:
rec = devices.modem.aldb[addr]
print("{},{},{},{},{},{},{},{},{},{},{}".format(
rec.mem_addr,
rec.is_in_use,
rec.is_controller,
rec.is_high_water_mark,
rec.is_bit5_set,
rec.is_bit4_set,
rec.group,
rec.target.id,
rec.data1,
rec.data2,
rec.data3,
))
await async_close()
async def set_default_links():
"""Load the device databae."""
await async_connect(device=DEVICE)
# await async_connect(host=HOST,
# username=USERNAME,
# password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
await devices.async_save(workdir=PATH)
set_log_levels(logger='info',
logger_pyinsteon='debug',
logger_messages='debug',
logger_topics=True)
address = "133696"
device = devices[address]
rec_0fd7 = ALDBRecord(memory=0x0fb7,
controller=False,
group=0,
target='00.00.00',
data1=0,
data2=0,
data3=0,
in_use=False,
bit5=False,
bit4=False,
high_water_mark=True)
device.aldb[0x0fb7] = rec_0fd7
await device.aldb.async_write()
await device.aldb.async_load(refresh=True)
await devices.async_save(workdir=PATH)
await async_close()
async def set_default_links():
"""Load the device databae."""
# await async_connect(device=DEVICE)
await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
device = devices[address]
set_log_levels(
logger="info",
logger_pyinsteon="info",
logger_messages="info",
logger_topics=True,
)
devices.modem.aldb.remove(controller=False, group=1, target=address)
for mem_addr in device.aldb:
rec = device.aldb[mem_addr]
if rec.target == devices.modem.address and rec.group == 1:
device.aldb.remove(mem_addr)
await devices.modem.aldb.async_write()
await device.aldb.async_write()
await device.async_add_default_links()
set_log_levels(
logger="info",
logger_pyinsteon="info",
logger_messages="info",
logger_topics=False,
)
await devices.modem.aldb.async_load()
await device.aldb.async_load(refresh=True)
_LOGGER.info("Modem Links")
for mem_addr in devices.modem.aldb:
_LOGGER.info(devices.modem.aldb[mem_addr])
_LOGGER.info("Device Links")
for mem_addr in devices[address].aldb:
_LOGGER.info(device.aldb[mem_addr])
await async_close()
async def run():
"""Run the monitoring."""
set_log_levels(
logger="info",
logger_pyinsteon="info",
logger_messages="info",
logger_topics=True,
)
# await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
await async_connect(device=DEVICE)
devices.subscribe(device_added)
await devices.async_load(workdir=PATH, id_devices=0)
await devices.async_save(workdir=PATH)
address = "453194"
device = devices[address]
if device:
await device.async_read_op_flags()
await device.async_read_ext_properties()
_LOGGER.info(
"LED_BLINK_ON_TX_ON: %s",
device.operating_flags[MOMENTARY_ON_OFF_TRIGGER].value,
)
device.operating_flags[MOMENTARY_ON_OFF_TRIGGER].new_value = True
await device.async_write_op_flags()
await device.async_write_ext_properties()
await device.async_read_op_flags()
await device.async_read_ext_properties()
_LOGGER.info(
"LED_BLINK_ON_TX_ON: %s",
device.operating_flags[MOMENTARY_ON_OFF_TRIGGER].value,
)
else:
_LOGGER.info("No device found for address: %s", address)
await devices.async_save(workdir=PATH)
await async_close()
async def run():
"""Run the monitoring."""
set_log_levels(logger='info',
logger_pyinsteon='info',
logger_messages='debug',
logger_topics=True)
await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
devices.subscribe(device_added)
await devices.async_load(workdir=PATH)
await devices.async_save(workdir=PATH)
await devices.modem.async_get_configuration()
await devices.modem.async_set_configuration(
disable_auto_linking=devices.modem.disable_auto_linking,
monitor_mode=True,
auto_led=devices.modem.auto_led,
deadman=devices.modem.deadman)
_LOGGER.info('Devices loaded: %d', len(devices))
try:
while True:
await asyncio.sleep(5)
except KeyboardInterrupt:
await async_close()
raise KeyboardInterrupt()
from pyinsteon import async_close, async_connect
from samples import _LOGGER, PATH, get_hub_config, set_log_levels
# DEVICE = '/dev/ttyS5'
DEVICE = 'COM5'
USERNAME, PASSWORD, HOST = get_hub_config()
async def do_run():
"""Connect to the PLM and load the ALDB."""
# devices = await async_connect(device=DEVICE)
devices = await async_connect(host=HOST,
username=USERNAME,
password=PASSWORD)
modem = devices.modem
_LOGGER.info('Connected')
_LOGGER.info('Modem Address: %s', modem.address)
await devices.async_load(workdir=PATH)
await devices.async_save(workdir=PATH)
for address in devices:
device = devices[address]
_LOGGER.info('%s %s %s', device.address, device.description, device.model)
await async_close()
if __name__ == '__main__':
set_log_levels(logger='info', logger_pyinsteon='debug',
logger_messages='debug', logger_topics=True)
loop = asyncio.get_event_loop()
loop.run_until_complete(do_run())
def device_added(address):
"""Call set up device."""
asyncio.ensure_future(async_setup_device(address))
async def do_run():
"""Connect to the PLM and load the ALDB."""
# devices = await async_connect(device=DEVICE)
devices = await async_connect(host=HOST,
username=USERNAME,
password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
devices.subscribe(device_added)
await async_enter_linking_mode(link_mode=AllLinkMode.EITHER, group=0)
_LOGGER.info("Press device SET button")
await done.get()
await async_close()
if __name__ == "__main__":
set_log_levels(
logger="info",
logger_pyinsteon="True",
logger_messages="debug",
logger_topics=True,
)
loop = asyncio.get_event_loop()
loop.run_until_complete(do_run())
"""Send the messages to mimic triggering."""
address = "27c387"
RX1 = unhexlify("0250{}000001cf1300".format(address))
# pylint: disable=protected-access
devices.modem._protocol.data_received(RX1)
async def load_database():
"""Load the device databae."""
await async_connect(device=DEVICE)
# await async_connect(host=HOST,
# username=USERNAME,
# password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
_LOGGER.info("Trigger the device now...")
# Uncomment the line below to mock a device sending a message.
asyncio.ensure_future(send_messages())
await asyncio.sleep(10)
for address in devices:
device = devices[address]
_LOGGER.info("Device: %s %s", device.address, device.description)
await async_close()
if __name__ == "__main__":
set_log_levels(logger="info", logger_pyinsteon="info", logger_messages="info")
loop = asyncio.get_event_loop()
_LOGGER.info("Loading All-Link database for all devices")
loop.run_until_complete(load_database())
"""Connect to the PLM and load the ALDB."""
# devices = await async_connect(device=DEVICE)
devices = await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
modem = devices.modem
_LOGGER.info("Connected")
_LOGGER.info("Modem Address: %s", modem.address)
await devices.async_load(workdir=PATH, id_devices=0)
device = devices["13.36.96"]
device.groups[1].subscribe(state_changed)
await device.async_on()
await asyncio.sleep(1)
await device.async_off()
_LOGGER.info("Please manually turn device on and off.")
await asyncio.sleep(20)
_LOGGER.info("Getting device status.")
await device.async_status()
await async_close()
if __name__ == "__main__":
set_log_levels(
logger="info",
logger_pyinsteon="info",
logger_messages="info",
logger_topics=False,
)
loop = asyncio.get_event_loop()
loop.run_until_complete(do_run())
async def run():
"""Run the monitoring."""
set_log_levels(logger='info',
logger_pyinsteon='info',
logger_messages='debug',
logger_topics=True)
# await async_connect(device=DEVICE)
await async_connect(host=HOST, username=USERNAME, password=PASSWORD)
await devices.async_load(workdir=PATH, id_devices=0)
address = '133696'
device = devices[address]
modem1 = '19.1A.60'
modem2 = '31.18.A2'
modem3 = '31.3E.1E'
rec_0fff = ALDBRecord(0x0fff, False, 0, modem1, 0, 0, 0, bit5=True)
rec_0ff7 = ALDBRecord(0x0ff7, True, 1, modem1, 0, 0, 0, bit5=True)
rec_0fef = ALDBRecord(0x0fef, False, 0, modem2, 0, 0, 0, bit5=True)
rec_0fe7 = ALDBRecord(0x0fe7, True, 1, modem2, 0, 0, 0, bit5=True)
rec_0fdf = ALDBRecord(0x0fdf, False, 0, modem3, 0, 0, 0, bit5=True)
rec_0fd7 = ALDBRecord(0x0fd7, True, 1, modem3, 0, 0, 0, bit5=True)
rec_0fcf = ALDBRecord(0x0fcf,
False,
0,
'00.00.00',
0,
0,
0,
bit5=False,
bit4=False,
in_use=False,
high_water_mark=True)
device.aldb[0x0fff] = rec_0fff
device.aldb[0x0ff7] = rec_0ff7
device.aldb[0x0fef] = rec_0fef
device.aldb[0x0fe7] = rec_0fe7
device.aldb[0x0fdf] = rec_0fdf
device.aldb[0x0fd7] = rec_0fd7
device.aldb[0x0fcf] = rec_0fcf
await device.aldb.async_write()
await device.aldb.async_load(refresh=True)
await devices.async_save(workdir=PATH)
print(
"'memory','in_use','controller','high_water_mark','bit5','bit4','group','target','data1','data2','data3'"
)
for addr in device.aldb:
rec = device.aldb[addr]
print(rec)
await async_close()
logger_topics=True)
address = "133696"
device = devices[address]
rec_0fd7 = ALDBRecord(memory=0x0fb7,
controller=False,
group=0,
target='00.00.00',
data1=0,
data2=0,
data3=0,
in_use=False,
bit5=False,
bit4=False,
high_water_mark=True)
device.aldb[0x0fb7] = rec_0fd7
await device.aldb.async_write()
await device.aldb.async_load(refresh=True)
await devices.async_save(workdir=PATH)
await async_close()
if __name__ == '__main__':
set_log_levels(logger='info',
logger_pyinsteon='info',
logger_messages='info',
logger_topics=False)
loop = asyncio.get_event_loop()
_LOGGER.info('Loading All-Link database for all devices')
loop.run_until_complete(set_default_links())