def __on_connect(self, client, userdata, flags, rc):
if rc == 0:
logger.info("connected to broker '{}' on '{}'".format(self.ip_address, self.port))
self.mqtt_c.subscribe("{0}/{1}/status/current".format(self.device.product_type, self.device.id))
try:
Client.add(self.device)
except AttributeError:
DevicePool.add(self.device)
self.__requestDeviceStates()
self.device_sensor_request.start()
else:
logger.error("could not connect to broker '{}' on '{}' - reason '{}'".format(self.ip_address, self.port, rc))
def setSettings(self, rpkwh, kwh, name):
if type(kwh) is str:
kwh = kwh.replace(',', '.')
if devices_db.updateDevice(self._id,
rpkwh=int(rpkwh),
kwh=float(kwh),
name=str(name)):
self._rpkwh = int(rpkwh)
self._kwh = float(kwh)
self._meter_name = str(name)
if not self._device.name == self._meter_name:
self._device.name = self._meter_name
try:
Client.update(self._device)
except AttributeError:
DevicePool.update(self._device)
def _evaluate(self, unknown_devices, init):
missing_devices, new_devices, changed_devices = self._diff(__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(__class__._known_devices[missing_device_id].get('name'), missing_device_id))
del __class__.bridge_map[missing_device_id]
if init:
DevicePool.remove(missing_device_id)
else:
Client.disconnect(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('name')
logger.info("found '{}' with id '{}'".format(name, new_device_id))
__class__.bridge_map[new_device_id] = (unknown_devices[new_device_id].get('LIGHT_KEY'), Converter(get_light_gamut(unknown_devices[new_device_id].get('modelid'))))
device = Device(new_device_id, SEPL_DEVICE_TYPE, name)
device.addTag('type', unknown_devices[new_device_id].get('type'))
device.addTag('manufacturer', unknown_devices[new_device_id].get('manufacturername'))
if init:
DevicePool.add(device)
else:
Client.add(device)
if changed_devices:
for changed_device_id in changed_devices:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('name')
if not name == device.name:
device.name = name
if init:
DevicePool.update(device)
else:
Client.update(device)
logger.info("name of '{}' changed to {}".format(changed_device_id, name))
__class__._known_devices = unknown_devices
def run(self):
logger.debug("starting serial controller for device '{}'".format(
self._id))
self._writeSerialLog('serial connection open')
self._writeSerialLog(self._greeting, 'D')
if self._waitFor('RDY'):
self._writeSerialLog('RDY', 'D')
logger.info("started serial controller for device '{}'".format(
self._id))
logger.debug(self._serial_con)
if self._configureDevice(init=True):
try:
Client.add(self._device)
except AttributeError:
DevicePool.add(self._device)
if self._strt:
self.startDetection()
while True:
try:
command, callbk, kwargs = self._commands.get(timeout=1)
if command != self._stopAction:
if kwargs:
command(callbk, **kwargs)
else:
command(callbk)
else:
callbk(409)
except Empty:
pass
except __class__.Interrupt:
break
try:
Client.disconnect(self._device)
except AttributeError:
DevicePool.remove(self._device)
else:
logger.error("device '{}' not ready".format(self._id))
self._closeConnection()
logger.info("serial controller for device '{}' exited".format(
self._id))
def run(self):
logger.info("starting session for '{}'".format(self.device.id))
try:
self.mqtt_c.connect(self.ip_address, self.port, keepalive=5)
self.mqtt_c.loop_start()
self.init_state.wait(timeout=10)
if self.device.state:
while not self.stop:
try:
command = self.command_queue.get(timeout=0.5)
state = self.device.state
for key, value in command.items():
if key in DysonDevice.state_map and value in DysonDevice.state_map[key]:
state[key] = value
payload = {
"msg": "STATE-SET",
"time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
"mode-reason": "LAPP",
"data": state
}
self.mqtt_c.publish('{}/{}/command'.format(self.device.product_type, self.device.id), json.dumps(payload), 1)
except Empty:
pass
except Exception as ex:
logger.error("error handling command - '{}'".format(ex))
try:
Client.disconnect(self.device)
except AttributeError:
DevicePool.remove(self.device)
else:
self.mqtt_c.disconnect()
logger.error("could not get device state for '{}'".format(self.device.id))
except TimeoutError as ex:
logger.error("could not connect to broker '{}' on '{}' - reason '{}'".format(self.ip_address, self.port, ex))
self.mqtt_c.loop_stop()
if self.device_sensor_request.is_alive():
self.device_sensor_request.join()
SessionManager.cleanSession(self.device.id)
def _evaluate(self, unknown_devices):
missing_devices, new_devices = self._diff(self._know_devices,
unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}'".format(missing_device_id))
try:
Client.delete(missing_device_id)
except AttributeError:
DevicePool.remove(missing_device_id)
SessionManager.delRemoteDevice(missing_device_id)
if new_devices:
for new_device_id in new_devices:
try:
dyson_data = dyson_map[unknown_devices[new_device_id]
['ProductType']]
dyson_device = DysonDevice(
new_device_id, dyson_data['type'], dyson_data['name'],
decrypt_password(unknown_devices[new_device_id]
['LocalCredentials']),
unknown_devices[new_device_id]['ProductType'],
unknown_devices[new_device_id]['ScaleUnit'])
dyson_device.addTag('manufacturer', 'Dyson')
count = ''
for tag in dyson_data['tags']:
dyson_device.addTag('type{}'.format(count), tag)
if not count:
count = 0
count = count + 1
logger.info("found '{}' with id '{}'".format(
dyson_device.name, dyson_device.id))
SessionManager.addRemoteDevice(dyson_device)
except KeyError:
logger.error(
"missing device data or malformed message - '{}'".
format(unknown_devices[new_device_id]))
self._know_devices = unknown_devices.keys()
def _evaluate(self, unknown_devices):
missing_devices, new_devices, changed_devices = self._diff(__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(__class__._known_devices[missing_device_id].get('label'), missing_device_id))
try:
Client.delete(missing_device_id)
except AttributeError:
DevicePool.remove(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('label')
logger.info("found '{}' with id '{}'".format(name, new_device_id))
device = Device(new_device_id, SEPL_DEVICE_TYPE, name)
product = unknown_devices[new_device_id].get('product')
device.addTag('type', 'Extended color light')
device.addTag('product', product.get('name'))
device.addTag('manufacturer', product.get('company'))
try:
Client.add(device)
except AttributeError:
DevicePool.add(device)
if changed_devices:
for changed_device_id in changed_devices:
seconds_since_seen = unknown_devices[changed_device_id].get('seconds_since_seen')
if seconds_since_seen >= 60:
try:
Client.disconnect(changed_device_id)
except AttributeError:
DevicePool.remove(changed_device_id)
del unknown_devices[changed_device_id]
else:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('label')
if not name == device.name:
device.name = name
try:
Client.update(device)
except AttributeError:
DevicePool.update(device)
logger.info("name of '{}' changed to {}".format(changed_device_id, name))
__class__._known_devices = unknown_devices
def pushReadings():
while True:
for device in DevicePool.devices().values():
try:
response = http.get('http://{}/api/air/kick'.format(device.ip))
if response.status == 204:
time.sleep(5)
response = http.get('http://{}/api/air/state'.format(device.ip))
if response.status == 200:
air_state = json.loads(response.body)
for sensor in air_state['air']['sensors']:
Client.event(
device.id,
'reading_{}'.format(sensor['type']),
json.dumps({
'value': sensor['value'],
'unit': 'µg/m³',
'time': '{}Z'.format(datetime.datetime.utcnow().isoformat())
}),
block=False
)
except Exception as ex:
logger.error(ex)
time.sleep(20)
def _evaluate(self, unknown_devices, init):
missing_devices, new_devices, changed_devices = self._diff(
__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(
__class__._known_devices[missing_device_id].get(
'deviceName'), missing_device_id))
if init:
DevicePool.remove(missing_device_id)
else:
Client.disconnect(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('deviceName')
logger.info("found '{}' with id '{}'".format(
name, new_device_id))
device = BleboxDevice(new_device_id, SEPL_DEVICE_TYPE, name,
unknown_devices[new_device_id].get('ip'))
device.addTag('type',
unknown_devices[new_device_id].get('type'))
if init:
DevicePool.add(device)
else:
Client.add(device)
if changed_devices:
for changed_device_id in changed_devices:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('deviceName')
if not name == device.name:
device.name = name
if init:
DevicePool.update(device)
else:
Client.update(device)
logger.info("name of '{}' changed to {}".format(
changed_device_id, name))
__class__._known_devices = unknown_devices
from connector_client.device import Device
from configuration import SM_ID, SM_NAME, SM_MANUFACTURER, SM_TYPE, SEPL_DEVICE_TYPE, SEPL_SERVICE
from smart_meter_serial import SmartMeterSerial
from logger import root_logger
except ImportError as ex:
exit("{} - {}".format(__name__, ex.msg))
import datetime, json
logger = root_logger.getChild(__name__)
smart_meter = Device(SM_ID, SEPL_DEVICE_TYPE, SM_NAME)
if SM_TYPE:
smart_meter.addTag('type', SM_TYPE)
if SM_MANUFACTURER:
smart_meter.addTag('manufacturer', SM_MANUFACTURER)
DevicePool.add(smart_meter)
sm_serial = SmartMeterSerial()
def getReading(source):
payload = dict()
while True:
readings = source.read()
if readings:
payload['value'] = float(readings['1.8.0'][0])
payload['unit'] = readings['1.8.0'][1]
payload['time'] = '{}Z'.format(
datetime.datetime.utcnow().isoformat())
Client.event(device=SM_ID,
service=SEPL_SERVICE,