def node_update(obj=None):
if not obj:
obj = {}
try:
node_host_name = utils.get_object_field_value(obj, 'name')
L.l.debug('Received node state update from {}'.format(node_host_name))
#avoid node to update itself in infinite recursion
if node_host_name != Constant.HOST_NAME:
models.Node().save_changed_fields_from_json_object(
json_object=obj,
unique_key_name='name',
notify_transport_enabled=False,
save_to_graph=False)
else:
L.l.debug('Skipping node DB save, this node is master = {}'.format(
variable.NODE_THIS_IS_MASTER_OVERALL))
sent_date = utils.get_object_field_value(obj,
'event_sent_datetime')
if sent_date is not None:
event_sent_date_time = utils.parse_to_date(sent_date)
seconds_elapsed = (utils.get_base_location_now_date() -
event_sent_date_time).total_seconds()
if seconds_elapsed > 15:
L.l.warning(
'Very slow mqtt, delay is {} seconds rate msg {}/min'.
format(seconds_elapsed,
mqtt_io.mqtt_msg_count_per_minute))
except Exception as ex:
L.l.warning('Error on node update, err {}'.format(ex))
def record_update(obj):
source_host_name = utils.get_object_field_value(
obj, Constant.JSON_PUBLISH_SOURCE_HOST)
if source_host_name != Constant.HOST_NAME:
# Log.logger.info("Received plotly cache update from {}".format(source_host_name))
models.PlotlyCache().save_changed_fields_from_json_object(
json_object=obj,
notify_transport_enabled=False,
save_to_graph=False)
def gpio_record_update(json_object):
try:
host_name = utils.get_object_field_value(json_object, 'name')
# L.l.info('Received gpio state update from {} json={}'.format(host_name, json_object))
if host_name != Constant.HOST_NAME:
models.GpioPin().save_changed_fields_from_json_object(
json_object=json_object,
notify_transport_enabled=False,
save_to_graph=False)
except Exception as ex:
L.l.warning('Error on gpio state update, err {}'.format(ex))
def record_update(obj_dict=None):
if not obj_dict:
obj_dict = {}
try:
source_host_name = utils.get_object_field_value(
obj_dict, Constant.JSON_PUBLISH_SOURCE_HOST)
zone_id = utils.get_object_field_value(
obj_dict, utils.get_model_field_name(models.ZoneHeatRelay.zone_id))
pin_name = utils.get_object_field_value(
obj_dict,
utils.get_model_field_name(models.ZoneHeatRelay.heat_pin_name))
is_on = utils.get_object_field_value(
obj_dict,
utils.get_model_field_name(models.ZoneHeatRelay.heat_is_on))
# fixme: remove hard reference to object field
sent_on = utils.get_object_field_value(obj_dict, "event_sent_datetime")
L.l.debug(
'Received heat relay update from {} zoneid={} pin={} is_on={} sent={}'
.format(source_host_name, zone_id, pin_name, is_on, sent_on))
zone_heat_relay = models.ZoneHeatRelay.query.filter_by(
zone_id=zone_id).first()
if zone_heat_relay:
gpio_host_name = zone_heat_relay.gpio_host_name
cmd_heat_is_on = utils.get_object_field_value(
obj_dict,
utils.get_model_field_name(models.ZoneHeatRelay.heat_is_on))
L.l.debug(
'Local heat state zone_id {} must be changed to {} on pin {}'.
format(zone_id, cmd_heat_is_on, zone_heat_relay.gpio_pin_code))
if cmd_heat_is_on:
pin_value = 1
else:
pin_value = 0
# set pin only on pins owned by this host
if zone_heat_relay and gpio_host_name == Constant.HOST_NAME:
L.l.info("Setting heat pin {} to {}".format(
zone_heat_relay.gpio_pin_code, pin_value))
pin_state = gpio.relay_update(
gpio_pin_code=zone_heat_relay.gpio_pin_code,
pin_value=pin_value)
else:
pin_state = pin_value
if pin_state == pin_value:
pin_state = (pin_state == 1)
zone_heat_relay.heat_is_on = pin_state
zone_heat_relay.notify_transport_enabled = False
commit()
else:
L.l.warning(
'Heat state zone_id {} unexpected val={} after setval={}'.
format(zone_id, pin_state, pin_value))
else:
L.l.warning(
'No heat relay defined for zone {}, db data issue?'.format(
zone_id))
except Exception as ex:
L.l.warning('Error updating heat relay state, err {}'.format(ex))
def zone_custom_relay_record_update(json_object):
# save relay state to db, except for current node
# carefull not to trigger infinite recursion updates
try:
target_host_name = utils.get_object_field_value(
json_object, 'gpio_host_name')
source_host = utils.get_object_field_value(json_object, 'source_host_')
is_event_external = utils.get_object_field_value(
json_object, 'is_event_external')
# L.l.info('Received custom relay state update for host {}'.format(host_name))
if target_host_name == Constant.HOST_NAME:
# execute local pin change related actions like turn on/off a relay
if P.initialised:
gpio_pin_code = utils.get_object_field_value(
json_object, 'gpio_pin_code')
relay_type = utils.get_object_field_value(
json_object, 'relay_type')
relay_is_on = utils.get_object_field_value(
json_object, 'relay_is_on')
expire = utils.get_object_field_value(json_object, 'expire')
if relay_type == Constant.GPIO_PIN_TYPE_ZWAVE:
if source_host == Constant.HOST_NAME:
if is_event_external:
# event received from outside, so no need to set relay state again
pass
else:
# event received from user db change, so act it
vals = gpio_pin_code.split('_')
if len(vals) == 2:
node_id = int(vals[1])
L.l.info(
'Received relay state update host {}, obj={}'
.format(target_host_name, json_object))
# zwave switch name is not needed, identify device only by node_id
zwave.set_switch_state(node_id=node_id,
state=relay_is_on)
if expire is not None:
# revert back to initial state
expire_time = datetime.now() + timedelta(
seconds=expire)
init_val = not (bool(relay_is_on))
func = (zwave.set_switch_state, node_id,
init_val)
if expire_time not in P.expire_func_list.keys(
):
P.expire_func_list[expire_time] = func
func_update = (
io_common.update_custom_relay,
gpio_pin_code, init_val, True)
P.expire_func_list[
expire_time + timedelta(
microseconds=1)] = func_update
else:
L.l.error(
"Duplicate zwave key in list")
exit(999)
else:
L.l.error(
"Incorrect zwave switch format {}, must be <name>_<node_id>"
.format(gpio_pin_code))
elif relay_type == Constant.GPIO_PIN_TYPE_SONOFF:
if source_host == Constant.HOST_NAME:
if is_event_external:
# event received from outside, so no need to set relay state again
pass
else:
# event received from user db change, so act it
sonoff.set_relay_state(relay_name=gpio_pin_code,
relay_is_on=relay_is_on)
else:
# fixme: what to do here?
L.l.info(
"Warning - what should I do, event from other host?"
)
else:
gpio_record = models.GpioPin.query.filter_by(
pin_code=gpio_pin_code,
host_name=Constant.HOST_NAME).first()
if gpio_record is not None:
# if source_host != Constant.HOST_NAME:
# L.l.info('Event received from other host, event={}'.format(json_object))
# if source_host == Constant.HOST_NAME:
if is_event_external:
L.l.info(
'Event received from outside, so no need to set relay state again'
)
else:
# L.l.info('Event received from user db change, so act it')
value = 1 if relay_is_on else 0
pin_code = gpio_record.pin_index_bcm
pin_type = gpio_record.pin_type
board = gpio_record.board_index
relay_set(gpio_pin_index_bcm=pin_code,
gpio_pin_type=pin_type,
gpio_board_index=board,
value=value,
from_web=False)
if expire is not None and relay_is_on:
# revert back to off state in x seconds
expire_time = datetime.now() + timedelta(
seconds=expire)
init_val = not (bool(relay_is_on))
func = (relay_set, pin_code, pin_type, board,
init_val, False)
# set notify to true to inform openhab on state change
if pin_type == Constant.GPIO_PIN_TYPE_PI_FACE_SPI:
pin_code_ok = piface.format_pin_code(
board_index=board,
pin_direction=Constant.
GPIO_PIN_DIRECTION_OUT,
pin_index=pin_code)
else:
pin_code_ok = pin_code
func_update = (io_common.update_custom_relay,
pin_code_ok, init_val, True)
if expire_time not in P.expire_func_list.keys(
):
P.expire_func_list[expire_time] = func
P.expire_func_list[expire_time + timedelta(
microseconds=1)] = func_update
else:
L.l.error("Duplicate key in gpio list")
exit(999)
else:
L.l.warning(
'Could not find gpio record for custom relay pin code={}'
.format(gpio_pin_code))
# todo: check if for zwave we get multiple redundant db saves
models.ZoneCustomRelay().save_changed_fields_from_json_object(
json_object=json_object,
notify_transport_enabled=False,
save_to_graph=False)
except Exception as ex:
L.l.error('Error on zone custom relay update, err={}'.format(ex),
exc_info=True)
def record_update(obj):
# save sensor state to db, except for current node
try:
sensor_host_name = utils.get_object_field_value(obj, 'name')
L.l.debug('Received sensor state update from {}'.format(sensor_host_name))
# avoid node to update itself in infinite recursion
if sensor_host_name != Constant.HOST_NAME:
address = utils.get_object_field_value(obj, 'address')
n_address = utils.get_object_field_value(obj, 'n_address')
sensor_type = utils.get_object_field_value(obj, 'type')
record = models.Sensor(address=address)
assert isinstance(record, models.Sensor)
zone_sensor = models.ZoneSensor.query.filter_by(sensor_address=address).first()
if zone_sensor is not None:
record.sensor_name = zone_sensor.sensor_name
else:
record.sensor_name = '(n/a) {} {} {}'.format(address, n_address, sensor_type)
record.type = utils.get_object_field_value(obj, 'type')
record.updated_on = utils.get_base_location_now_date()
if obj.has_key('counters_a'): record.counters_a = utils.get_object_field_value(obj, 'counters_a')
if obj.has_key('counters_b'): record.counters_b = utils.get_object_field_value(obj, 'counters_b')
if obj.has_key('delta_counters_a'):
record.delta_counters_a = utils.get_object_field_value(obj, 'delta_counters_a')
if obj.has_key('delta_counters_b'):
record.delta_counters_b = utils.get_object_field_value(obj, 'delta_counters_b')
if obj.has_key('temperature'): record.temperature = utils.get_object_field_value(obj, 'temperature')
if obj.has_key('humidity'): record.humidity = utils.get_object_field_value(obj, 'humidity')
if obj.has_key('iad'): record.iad = utils.get_object_field_value(obj, 'iad')
if obj.has_key('vad'): record.vad = utils.get_object_field_value(obj, 'vad')
if obj.has_key('vdd'): record.vdd = utils.get_object_field_value(obj, 'vdd')
if obj.has_key('pio_a'): record.pio_a = utils.get_object_field_value(obj, 'pio_a')
if obj.has_key('pio_b'): record.pio_b = utils.get_object_field_value(obj, 'pio_b')
if obj.has_key('sensed_a'): record.sensed_a = utils.get_object_field_value(obj, 'sensed_a')
if obj.has_key('sensed_b'): record.sensed_b = utils.get_object_field_value(obj, 'sensed_b')
current_record = models.Sensor.query.filter_by(address=address).first()
# force field changed detection for delta_counters
if current_record:
current_record.delta_counters_a = 0
current_record.delta_counters_b = 0
record.save_changed_fields(current_record=current_record, new_record=record, notify_transport_enabled=False,
save_to_graph=False)
# commit() # not needed?
# enable below only for testing on netbook
# if Constant.HOST_NAME == 'xxxnetbook' and (record.delta_counters_a or record.delta_counters_b):
# dispatcher.send(Constant.SIGNAL_UTILITY, sensor_name=record.sensor_name,
# units_delta_a=record.delta_counters_a,
# units_delta_b=record.delta_counters_b, total_units_a=record.counters_a,
# total_units_b=record.counters_b,
# sampling_period_seconds=owsensor_loop.sampling_period_seconds)
except Exception as ex:
L.l.error('Error on sensor update, err {}'.format(ex), exc_info=True)
db.session.rollback()