def load_eth_account_list(account_num):
eth_account_list = []
ds = []
for keystore in get_keystore_list():
d = deferToThread(load_eth_account, keystore)
ds.append(d)
# eth_account_list.append(load_eth_account(keystore))
account_num -= 1
if account_num == 0:
break
def handle_result(result):
for (success, value) in result:
if success:
account = value
print('Loading account success: ', account.address)
eth_account_list.append(account)
else:
print('Loading account failure: ', value.getErrorMessage())
return eth_account_list
if ds:
dl = DeferredList(ds, consumeErrors=True)
dl.addCallback(handle_result)
else:
dl = Deferred()
dl.callback([])
return dl
def disconnect(self):
self.queueEmpty.addCallback(lambda result: self.stopConnecting())
readyToStop = DeferredList([self.connectionLost, self.connectFailed],
fireOnOneCallback=True,
fireOnOneErrback=True)
self.checkQueue()
# This can happen if the client is stopped before a connection is ever made
if (not readyToStop.called) and (not self.started):
readyToStop.callback(None)
return readyToStop
def disconnect(self):
self.queueEmpty.addCallback(lambda result: self.stopConnecting())
readyToStop = DeferredList(
[self.connectionLost, self.connectFailed], fireOnOneCallback=True, fireOnOneErrback=True
)
self.checkQueue()
# This can happen if the client is stopped before a connection is ever made
if (not readyToStop.called) and (not self.started):
readyToStop.callback(None)
return readyToStop
class InsteonPLM(YomboModule):
"""
The primary class...
"""
_insteon_commands = {
0x11: 'on',
0x12: 'on_fast',
0x13: 'off',
0x14: 'off_fast',
}
_insteon_commands_lookup = {
'on': {
'insteon': 0x11,
'x10': 0x02,
},
'faston': {
'insteon': 0x12,
'x10': 0x02,
},
'off': {
'insteon': 0x13,
'x10': 0x03,
},
'fastoff': {
'insteon': 0x14,
'x10': 0x03,
},
'level': {
'insteon': 0x11,
'x10': 0x10,
},
}
def _init_(self, **kwargs):
self.load_deferred = None # Prevents loader from moving on past _start_ until we are done.
self.load_deferred_dl = None # Prevents loader from moving on past _start_ until we are done.
self.startable = False # track when load has completed...
self.call_later_set_and_hold = None
self.plm_history = deque([], 50)
self.status = True # InsteonAPI checks this..
self.insteonapi = None # pointer to the insteon api module.
self.ready = False
def _start_(self, **kwargs):
if self.insteonapi is None:
logger.error(
"Insteon PLM module doesn't have required Insteon API module. Disabling PLM."
)
return
d1 = self.connect_plm()
self.load_deferred = Deferred()
self.load_deferred_dl = DeferredList(d1, self.load_deferred)
return self.load_deferred_dl
@inlineCallbacks
def connect_plm(self):
try:
serial_port = self._module_variables_cached['port']['values'][0]
except:
serial_port = '/dev/insteon'
self.plm_connection = yield ensureDeferred(
plm.Connection.create(device=serial_port, loop=self._event_loop))
self.plm_protocol = self.plm_connection.protocol
self.plm_devices = self.plm_connection.protocol.devices._devices
self.plm_protocol.add_poll_completed_callback(self.plm_poll_completed)
self.plm_protocol.add_update_callback(self.plm_update_device, {})
self.plm_protocol.add_message_callback(self.plm_set_and_hold, {
'code': 0x54,
'event': 0x03
})
self.ready = True
def plm_poll_completed(self):
if self.load_deferred_dl is not None and self.load_deferred_dl.called is False:
self.load_deferred_dl.callback(10)
def _stop_(self, **kwargs):
if self.load_deferred is not None and self.load_deferred.called is False:
self.load_deferred.callback(
1) # if we don't check for this, we can't stop!
if self.load_deferred_dl is not None and self.load_deferred_dl.called is False:
self.load_deferred_dl.callback(
1) # if we don't check for this, we can't stop!
def insteonapi_init(
self,
insteonapi): # the api module giving us a reference to itself.
self.insteonapi = insteonapi
def insteonplm_insteonapi_interfaces(self, **kwargs):
"""
This is a hook implemented by the Insteon api module. This simply tells the Insteon API module that we can support
Insteon device interactions.
:param kwargs:
:return:
"""
try:
priority = self._module_variables_cached['port']['values'][0]
except:
priority = 0
# logger.warn("Registering Insteon PLM with Insteon API as priority 0.")
return {'priority': priority, 'module': self}
def device_command(self, **kwargs):
"""
Called by the insteonapi module to send a command.
:param kwargs:
:return:
"""
logger.debug("in device_command. Ready: {ready}", ready=self.ready)
if self.ready is False:
return ('failed', 'PLM interface not ready.')
device = kwargs['device']
command = kwargs['command']
inputs = kwargs['inputs']
request_id = kwargs['request_id']
device_variables = device.device_variables_cached
address = Address(device_variables['address']['values'][0])
# print("plm plm_devices: %s" % self.plm_devices)
# print("plm device_variables: %s" % device_variables)
plm_device = self.plm_devices[address.hex]
do_command = command.machine_label
fast = do_command.endswith('fast')
if 'brightness' in inputs:
brightness = float(inputs['brightness'])
elif 'percent' in inputs:
brightness = translate_int_value(float(inputs['percent']), 0, 100,
0, 255)
else:
brightness = 255
if 'ramprate' in inputs:
ramprate = int(inputs['ramprate'])
else:
ramprate = None
if do_command.startswith('on'):
# else:
# brightness = 255
self.plm_protocol.turn_on(address,
brightness=brightness,
ramprate=ramprate,
fast=fast)
elif do_command == 'set_brightness':
self.plm_protocol.turn_on(address, brightness=brightness)
elif do_command == 'brighten':
brightness = self.insteonapi.devices[
address.human]['onlevel'] + 26 # about 11-12 steps
self.plm_protocol.turn_on(address, brightness=brightness)
elif do_command == 'dim':
brightness = self.insteonapi.devices[
address.human]['onlevel'] - 26 # about 11-12 steps
self.plm_protocol.turn_on(address, brightness=brightness)
elif do_command == 'dim_start':
self.plm_protocol.send_insteon_standard(plm_device, '23', '00')
elif do_command == 'dim_stop':
self.plm_protocol.send_insteon_standard(plm_device, '24', '00')
elif do_command == 'dim_start':
self.plm_protocol.send_insteon_standard(plm_device, '23', '01')
elif do_command == 'dim_stop':
self.plm_protocol.send_insteon_standard(plm_device, '24', '01')
elif do_command.startswith('off'):
fast = do_command.endswith('fast')
self.plm_protocol.turn_off(address, ramprate=ramprate, fast=fast)
else:
return ('failed', 'Unknown command: %s' % do_command)
return ('done', 'Command delivered to PLM interface.')
def get_plm_device(self, address):
address = Address(address)
# print("address: %s -> %s" % (addr, address.__dict__))
device = self.devices[address.hex]
def get_found_devices(self):
"""
Called by Insteon API to get all devices linked to the PLM device.
:return:
"""
results = {}
for address, device in self.plm_devices.items():
results[device['address']] = device
return results
def plm_set_and_hold(self, message):
"""
The PLM device had it's set button pressed for a while. Lets update the device list after a bit.
:param message:
:return:
"""
# print("got a plm set and hold: %s" % message)
if self.call_later_set_and_hold is not None:
try:
self.call_later_set_and_hold.cancel()
except:
pass
self.call_later_set_and_hold = reactor.callLater(
3, self.plm_protocol.load_all_link_database)
# print("Devices: %s" % self.plm_devices )
def plm_message(self, message):
self.plm_history.append(message)
def plm_update_device(self, message):
# print("UYpdate from address: %s" % message.cmd1)
# print("UYpdate from address: %s" % message.__dict__)
device = self.plm_devices[message.address.hex]
# print("Update from device: %s" % device)
# for now, just handle lights...
if 'onlevel' not in device:
return
onlevel = device['onlevel']
if onlevel == 0:
command_label = 'off'
else:
command_label = 'on'
self.insteonapi.insteon_device_update(device, command_label)
