151 lines
5.2 KiB
Python
151 lines
5.2 KiB
Python
"""Driver for testing Flow Monitor to Meshify."""
|
|
import time
|
|
import sqlite3
|
|
from datetime import datetime
|
|
|
|
|
|
class Channel:
|
|
"""Meshify channel structure."""
|
|
|
|
def __init__(self, meshify_name, senddelta_value, senddelta_time):
|
|
"""Initialize the channel with variables."""
|
|
self.meshify_name = meshify_name
|
|
self.senddelta_time = senddelta_time
|
|
self.senddelta_value = senddelta_value
|
|
|
|
self.last_sent_value = None
|
|
self.last_sent_timestamp = 0
|
|
|
|
def check_if_send_needed(self, value, timestamp):
|
|
"""Check to see if the value needs to be pushed."""
|
|
if self.last_sent_value is None or self.last_sent_timestamp == 0:
|
|
return True
|
|
|
|
if abs(value - self.last_sent_value) > self.senddelta_value:
|
|
return True
|
|
|
|
if (timestamp - self.last_sent_timestamp) > self.senddelta_time:
|
|
return True
|
|
|
|
return False
|
|
|
|
def update(self, last_sent_value, last_sent_timestamp):
|
|
"""Update values after a push."""
|
|
self.last_sent_value = last_sent_value
|
|
self.last_sent_timestamp = last_sent_timestamp
|
|
|
|
|
|
def scale(raw_val, raw_min, raw_max, eu_min, eu_max):
|
|
"""Scale a raw value."""
|
|
m = (eu_max - eu_min) / (raw_max - raw_min)
|
|
b = eu_max - (m * raw_max)
|
|
return m * raw_val + b
|
|
|
|
|
|
def is_today(tstamp):
|
|
"""Check if a given timestamp belongs to the current date."""
|
|
midnight_today = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
|
|
midnight_ts = (midnight_today - datetime(1970, 1, 1)).total_seconds()
|
|
return tstamp >= midnight_ts
|
|
|
|
|
|
def loop():
|
|
"""Run the driver."""
|
|
# Configuration Parameters
|
|
# total_time_store_delta = 600 # seconds
|
|
# flow_time_store_delta = 600 # seconds
|
|
|
|
raw_min = 3.89
|
|
raw_max = 19.54
|
|
|
|
gpm_min = 0.0
|
|
gpm_max = 600.0
|
|
|
|
gal_per_bbl = 42.0
|
|
|
|
# galtotal_ch = Channel('gal_total', 100.0, total_time_store_delta)
|
|
# bbltotal_ch = Channel('bbl_total', galtotal_ch.senddelta_value/gal_per_bbl, total_time_store_delta)
|
|
#
|
|
# gpmflow_ch = Channel('gpm_flow', 10.0, flow_time_store_delta)
|
|
# bpdflow_ch = Channel('bpd_flow', gpmflow_ch.senddelta_value/gal_per_bbl, total_time_store_delta)
|
|
#
|
|
# runstatus_ch = Channel('run_status', 0.5, 600)
|
|
|
|
last_measured_timestamp = time.time()
|
|
conn = sqlite3.connect('flow-monitor.db')
|
|
c = conn.cursor()
|
|
|
|
conn.commit()
|
|
c.execute('SELECT * FROM flow_data WHERE id = 1')
|
|
stored_data = c.fetchone()
|
|
gal_totalizer_value = stored_data[1]
|
|
bbl_totalizer_value = stored_data[2]
|
|
last_measured_timestamp = stored_data[3]
|
|
if not is_today(last_measured_timestamp):
|
|
gal_totalizer_value = 0
|
|
bbl_totalizer_value = 0
|
|
last_measured_timestamp = time.time()
|
|
|
|
wait_loops = 0
|
|
while wait_loops < 15:
|
|
print("Waiting to start driver in {} seconds".format(15 - wait_loops))
|
|
wait_loops += 1
|
|
time.sleep(1)
|
|
|
|
while True:
|
|
try:
|
|
mcu_status = {}
|
|
mcu_status['cloop'] = '12.0'
|
|
mcu_status['din1'] = 'Off'
|
|
print(mcu_status)
|
|
cloop_val = float(mcu_status['cloop'])
|
|
|
|
din1_val = 1 if mcu_status['din1'] == 'On' else 0
|
|
gpm_val = scale(cloop_val, raw_min, raw_max, gpm_min, gpm_max)
|
|
if gpm_val < 0:
|
|
gpm_val = 0
|
|
|
|
bpd_val = (gpm_val / gal_per_bbl) * 60.0 * 24.0
|
|
|
|
now = time.time()
|
|
time_diff = now - last_measured_timestamp
|
|
gal_flow_delta = (time_diff / 60.0) * gpm_val
|
|
bbl_flow_delta = (time_diff / 60.0) * (1.0 / 60.0) * (1.0 / 24.0) * bpd_val
|
|
|
|
gal_totalizer_value += gal_flow_delta
|
|
bbl_totalizer_value += bbl_flow_delta
|
|
last_measured_timestamp = now
|
|
|
|
c.execute('UPDATE flow_data SET gal_totalizer_value=?, bbl_totalizer_value=?, last_measured_timestamp=?',
|
|
(gal_totalizer_value, bbl_totalizer_value, last_measured_timestamp))
|
|
conn.commit()
|
|
|
|
print('gpm: {}, bpd: {}, gal: {}, bbl:{}'.format(gpm_val, bpd_val, gal_totalizer_value, bbl_totalizer_value))
|
|
|
|
# if galtotal_ch.check_if_send_needed(gal_totalizer_value, now):
|
|
# self.sendtodb(galtotal_ch.meshify_name, gal_totalizer_value, 0)
|
|
# galtotal_ch.update(gal_totalizer_value, now)
|
|
#
|
|
# if bbltotal_ch.check_if_send_needed(bbl_totalizer_value, now):
|
|
# self.sendtodb(bbltotal_ch.meshify_name, bbl_totalizer_value, 0)
|
|
# bbltotal_ch.update(bbl_totalizer_value, now)
|
|
#
|
|
# if gpmflow_ch.check_if_send_needed(gpm_val, now):
|
|
# self.sendtodb(gpmflow_ch.meshify_name, gpm_val, 0)
|
|
# gpmflow_ch.update(gpm_val, now)
|
|
#
|
|
# if bpdflow_ch.check_if_send_needed(bpd_val, now):
|
|
# self.sendtodb(bpdflow_ch.meshify_name, bpd_val, 0)
|
|
# bpdflow_ch.update(bpd_val, now)
|
|
#
|
|
# if runstatus_ch.check_if_send_needed(din1_val, now):
|
|
# self.sendtodb(runstatus_ch.meshify_name, din1_val, 0)
|
|
# runstatus_ch.update(din1_val, now)
|
|
|
|
except Exception as e:
|
|
print("problem in the driver: {}".format(e))
|
|
time.sleep(5)
|
|
|
|
|
|
loop()
|