568 lines
24 KiB
Python
568 lines
24 KiB
Python
"""Driver for flow-monitor"""
|
|
|
|
import threading
|
|
import json
|
|
import time
|
|
import os
|
|
from device_base import deviceBase
|
|
import persistence
|
|
from utilities import get_public_ip_address, get_private_ip_address
|
|
from file_logger import filelogger as log
|
|
from datetime import datetime as dt
|
|
import minimalmodbusM1
|
|
|
|
try:
|
|
os.system("/usr/sbin/ntpdate pool.ntp.org")
|
|
except:
|
|
dtz = dt.fromtimestamp(last_measured_timestamp)
|
|
os.system('date -s "{}-{}-{} {}:{}:{}"'.format(dtz.year,dtz.month,dtz.day,dtz.hour,dtz.minute,dtz.second))
|
|
|
|
PLC_IP_ADDRESS = "192.168.1.12"
|
|
#from Tags import tags
|
|
|
|
_ = None
|
|
|
|
log.info("flow-monitor startup")
|
|
|
|
# GLOBAL VARIABLES
|
|
WAIT_FOR_CONNECTION_SECONDS = 20
|
|
IP_CHECK_PERIOD = 60
|
|
|
|
|
|
#CHANNELS = tags
|
|
|
|
# PERSISTENCE FILE
|
|
PERSIST = persistence.load()
|
|
if not PERSIST:
|
|
PERSIST = {
|
|
"pressure_raw_min": 0.0,
|
|
"pressure_raw_max": 10.0,
|
|
"flow_raw_min": 3.89,
|
|
"pressure_psi_min": 0.0,
|
|
"gpm_or_bpd": "gpm",
|
|
"gpm_ignore_limit": 1.0,
|
|
"flow_gpm_max": 100.0,
|
|
"pressure_psi_max": 600.0,
|
|
"flow_raw_max": 19.54,
|
|
"flow_gpm_min": 0.0,
|
|
"lowflow": 10.0,
|
|
"modbus": False
|
|
}
|
|
persistence.store(PERSIST, 'persist.json')
|
|
try:
|
|
PERSIST['modbus']
|
|
except:
|
|
PERSIST['modbus'] = False
|
|
persistence.store(PERSIST, 'persist.json')
|
|
|
|
TOTALIZER = persistence.load('totalizers.json')
|
|
if not TOTALIZER:
|
|
TOTALIZER = {
|
|
'Todays': 0,
|
|
'Yesterdays': 0,
|
|
'Current Months': 0,
|
|
'Previous Months': 0,
|
|
'Monthly Holding': 0,
|
|
'Daily Holding': 0,
|
|
'Lifetime': 0,
|
|
'Day': 0,
|
|
'Month': 0,
|
|
'Last Report': 0
|
|
}
|
|
persistence.store(TOTALIZER, 'totalizers.json')
|
|
|
|
def scale(raw_val, raw_min, raw_max, eu_min, eu_max):
|
|
"""Scale a raw value."""
|
|
if raw_val < raw_min:
|
|
raw_val = raw_min
|
|
if raw_val > raw_max:
|
|
raw_val = raw_max
|
|
slope = (eu_max - eu_min) / (raw_max - raw_min)
|
|
intercept = eu_max - (slope * raw_max)
|
|
return slope * raw_val + intercept
|
|
|
|
class start(threading.Thread, deviceBase):
|
|
"""Start class required by Meshify."""
|
|
|
|
def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None,
|
|
companyId=None, offset=None, mqtt=None, Nodes=None):
|
|
"""Initialize the driver."""
|
|
threading.Thread.__init__(self)
|
|
deviceBase.__init__(self, name=name, number=number, mac=mac, Q=Q,
|
|
mcu=mcu, companyId=companyId, offset=offset,
|
|
mqtt=mqtt, Nodes=Nodes)
|
|
|
|
self.daemon = True
|
|
self.version = "22"
|
|
self.lock = threading.Lock()
|
|
self.force_send = False
|
|
self.public_ip_address = ""
|
|
self.private_ip_address = ""
|
|
self.public_ip_address_last_checked = 0
|
|
self.ping_counter = 0
|
|
self.finished = threading.Event()
|
|
threading.Thread.start(self)
|
|
|
|
# this is a required function for all drivers, its goal is to upload some piece of data
|
|
# about your device so it can be seen on the web
|
|
def register(self):
|
|
"""Register the driver."""
|
|
# self.sendtodb("log", "BOOM! Booted.", 0)
|
|
pass
|
|
|
|
def run(self):
|
|
"""Actually run the driver."""
|
|
self.instrument = self.startRS485()
|
|
global CHANNELS, INSTRUMENT, lock
|
|
INSTRUMENT = self.instrument
|
|
lock = self.lock
|
|
#from Channel import PLCChannel, ModbusChannel,read_tag, write_tag, TAG_DATAERROR_SLEEPTIME
|
|
from Tags import tags
|
|
CHANNELS = tags
|
|
|
|
for i in range(0, WAIT_FOR_CONNECTION_SECONDS):
|
|
print("flow-monitor driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
|
|
time.sleep(1)
|
|
log.info("BOOM! Starting flow-monitor driver...")
|
|
|
|
self._check_ip_address()
|
|
|
|
self.nodes["flowmonitor_0140"] = self
|
|
|
|
send_loops = 0
|
|
self.sendtodb("setrawmin", PERSIST["flow_raw_min"], 0)
|
|
self.sendtodb("setrawmax", PERSIST["flow_raw_max"], 0)
|
|
self.sendtodb("setgpmmin", PERSIST["flow_gpm_min"], 0)
|
|
self.sendtodb("setgpmmax", PERSIST["flow_gpm_max"], 0)
|
|
self.sendtodb("setpressurerawmin", PERSIST["pressure_raw_min"], 0)
|
|
self.sendtodb("setpressurerawmax", PERSIST["pressure_raw_max"], 0)
|
|
self.sendtodb("setpressurepsimin", PERSIST["pressure_psi_min"], 0)
|
|
self.sendtodb("setpressurepsimax", PERSIST["pressure_psi_max"], 0)
|
|
gal_totalizer_value = TOTALIZER['Lifetime']
|
|
last_measured_timestamp = time.time()
|
|
while True:
|
|
try:
|
|
# Gets a dictionary of the IO states
|
|
# {
|
|
# 'bat': u'23.10',
|
|
# 'ver': u'Mar 16 2016 21:29:31',
|
|
# 'dout3': 'Off',
|
|
# 'temp': u'40.37',
|
|
# 'vin': u'24.6',
|
|
# 'pulse': u'0',
|
|
# 'dout4': 'Off',
|
|
# 'dout1': 'Off',
|
|
# 'din2': 'Off',
|
|
# 'din1': 'Off',
|
|
# 'dout2': 'On',
|
|
# 'cloop': u'0.0',
|
|
# 'analog4': u'0.0',
|
|
# 'analog3': u'0.0',
|
|
# 'analog2': u'0.0',
|
|
# 'analog1': u'0.0',
|
|
# 'relay1': 'Off'
|
|
# }
|
|
mcu_status = self.mcu.getDict()
|
|
except Exception as e:
|
|
log.error("Error getting MCU State: {}".format(e))
|
|
|
|
cloop_val = float(mcu_status['cloop'])
|
|
analog1_val = float(mcu_status['analog1'])
|
|
din1_val = 1 if mcu_status['din1'] == 'On' else 0 # Check DIGITAL INPUT 1 for run status
|
|
scaled_cloop = scale(cloop_val, PERSIST["flow_raw_min"], PERSIST["flow_raw_max"], PERSIST["flow_gpm_min"], PERSIST["flow_gpm_max"])
|
|
psi_val = scale(analog1_val, PERSIST["pressure_raw_min"], PERSIST["pressure_raw_max"], PERSIST["pressure_psi_min"], PERSIST["pressure_psi_max"])
|
|
|
|
if PERSIST["gpm_or_bpd"] == "gpm":
|
|
gpm_val = scaled_cloop
|
|
bpd_val = (gpm_val / 42.0) * 60.0 * 24.0 # Computes BPD from GPM
|
|
else:
|
|
bpd_val = scaled_cloop
|
|
gpm_val = (((bpd_val * 42.0) / 24.0) / 60.0) # Computes GPM from BPD
|
|
|
|
if gpm_val < PERSIST["gpm_ignore_limit"]:
|
|
gpm_val = 0
|
|
bpd_val = 0
|
|
|
|
#Determine run status
|
|
runstatus = "undefined"
|
|
if din1_val == 0 and gpm_val == 0:
|
|
runstatus = "Stopped" #Stopped
|
|
elif din1_val == 0 and gpm_val > 10:
|
|
runstatus = "Running" #Assumed running might not have run indication
|
|
elif din1_val == 0 and gpm_val > 0:
|
|
runstatus = "Running: Low Flow"
|
|
elif din1_val == 1 and gpm_val == 0:
|
|
runstatus = "Running: No Flow" #no flow warning
|
|
elif din1_val == 1 and gpm_val < PERSIST["lowflow"]:
|
|
runstatus = "Running: Low Flow" #low flow warning
|
|
elif din1_val == 1 and gpm_val >= PERSIST["lowflow"]:
|
|
runstatus = "Running" #running normally
|
|
|
|
now = time.time()
|
|
time_diff = now - last_measured_timestamp
|
|
if 0 < time_diff < 180:
|
|
# Volume flowed since last measuring
|
|
gal_flow_delta = (time_diff / 60.0) * gpm_val
|
|
|
|
# Increment totalizers
|
|
gal_totalizer_value += gal_flow_delta
|
|
last_measured_timestamp = now
|
|
elif time_diff < 0:
|
|
#negative time difference means clock got reset or somehow went the wrong way
|
|
try:
|
|
os.system("/usr/sbin/ntpdate pool.ntp.org")
|
|
except:
|
|
dtz = dt.fromtimestamp(last_measured_timestamp)
|
|
os.system('date -s "{}-{}-{} {}:{}:{}"'.format(dtz.year,dtz.month,dtz.day,dtz.hour,dtz.minute,dtz.second))
|
|
now = time.time()
|
|
elif time_diff > 180:
|
|
last_measured_timestamp = now
|
|
|
|
if self.force_send:
|
|
log.warning("FORCE SEND: TRUE")
|
|
|
|
for chan in CHANNELS:
|
|
if chan.mesh_name == "psi_pressure":
|
|
val = psi_val
|
|
elif chan.mesh_name == "run_status":
|
|
val = runstatus
|
|
elif PERSIST["modbus"]:
|
|
try:
|
|
val = chan.read()
|
|
except:
|
|
log.error("Issue with modbus read in driver")
|
|
val = None
|
|
if chan.mesh_name == "gpm_flow" and val != None:
|
|
if val == 0:
|
|
runstatus = "Stopped"
|
|
elif val > PERSIST["lowflow"]:
|
|
runstatus = "Running"
|
|
else:
|
|
runstatus = "Running: Low Flow"
|
|
if PERSIST["gpm_or_bpd"] == "bpd":
|
|
val = ((val * 42.0) / 24.0) / 60.0
|
|
elif chan.mesh_name == "gpm_flow":
|
|
val = gpm_val
|
|
else:
|
|
val = gal_totalizer_value
|
|
|
|
if chan.mesh_name == 'gal_total':
|
|
self.totalize(val)
|
|
elif chan.check(val, self.force_send):
|
|
self.sendtodb(chan.mesh_name, chan.value, 0)
|
|
if chan.mesh_name == 'gpm_flow':
|
|
if val == None:
|
|
self.sendtodb('bpd_flow', chan.value,0)
|
|
else:
|
|
self.sendtodb('bpd_flow', (chan.value / 42.0) * 60 * 24, 0)
|
|
|
|
#time.sleep(TAG_DATAERROR_SLEEPTIME) # sleep to allow Micro800 to handle ENET requests
|
|
if PERSIST["modbus"]:
|
|
time.sleep(5)
|
|
# print("flow-monitor driver still alive...")
|
|
if self.force_send:
|
|
if send_loops > 2:
|
|
log.warning("Turning off force_send")
|
|
self.force_send = False
|
|
send_loops = 0
|
|
else:
|
|
send_loops += 1
|
|
|
|
|
|
if (now - self.public_ip_address_last_checked) > IP_CHECK_PERIOD:
|
|
self._check_ip_address()
|
|
|
|
|
|
def _check_ip_address(self):
|
|
"""Check the public IP address and send to Meshify if changed."""
|
|
try:
|
|
self.public_ip_address_last_checked = time.time()
|
|
test_public_ip = get_public_ip_address()
|
|
test_public_ip = test_public_ip
|
|
test_private_ip = get_private_ip_address()
|
|
if not test_public_ip == self.public_ip_address and not test_public_ip == "0.0.0.0":
|
|
self.sendtodb('public_ip_address', test_public_ip, 0)
|
|
self.public_ip_address = test_public_ip
|
|
if not test_private_ip == self.private_ip_address:
|
|
self.sendtodb('private_ip_address', test_private_ip, 0)
|
|
self.private_ip_address = test_private_ip
|
|
except Exception as e:
|
|
self.sendtodb('error', e, 0)
|
|
|
|
|
|
def flowmonitor_sync(self, name, value):
|
|
"""Sync all data from the driver."""
|
|
self.force_send = True
|
|
# self.sendtodb("log", "synced", 0)
|
|
return True
|
|
|
|
def flowmonitor_startcmd(self, name, value):
|
|
"""Start the well."""
|
|
self.mcu.relay1(str(1))
|
|
return True
|
|
|
|
def flowmonitor_stopcmd(self, name, value):
|
|
"""Stop the well."""
|
|
self.mcu.relay1(str(0))
|
|
return True
|
|
|
|
def flowmonitor_modbus(self, name, value):
|
|
if PERSIST["modbus"] == False:
|
|
PERSIST["modbus"] = True
|
|
else:
|
|
PERSIST["modbus"] = False
|
|
persistence.store(PERSIST, "persist.json")
|
|
return True
|
|
|
|
def flowmonitor_setrawmin(self, name, value):
|
|
"""Set the raw min scaling value."""
|
|
try:
|
|
PERSIST['flow_raw_min'] = float(value)
|
|
self.sendtodb("setrawmin", PERSIST['flow_raw_min'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.flow_raw_min: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setrawmax(self, name, value):
|
|
"""Set the raw max scaling value."""
|
|
try:
|
|
PERSIST['flow_raw_max'] = float(value)
|
|
self.sendtodb("setrawmax", PERSIST['flow_raw_max'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.flow_raw_max: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setgpmmin(self, name, value):
|
|
"""Set the gpm min scaling value."""
|
|
try:
|
|
PERSIST['flow_gpm_min'] = float(value)
|
|
self.sendtodb("setgpmmin", PERSIST['flow_gpm_min'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.flow_gpm_min: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setgpmmax(self, name, value):
|
|
"""Set the gpm max scaling value."""
|
|
try:
|
|
PERSIST['flow_gpm_max'] = float(value)
|
|
self.sendtodb("setgpmmax", PERSIST['flow_gpm_max'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.flow_gpm_max: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setpressurerawmin(self, name, value):
|
|
"""Set the pressure raw min scaling value."""
|
|
try:
|
|
PERSIST['pressure_raw_min'] = float(value)
|
|
self.sendtodb("setpressurerawmin", PERSIST['pressure_raw_min'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.pressure_raw_min: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setpressurerawmax(self, name, value):
|
|
"""Set the pressure raw max scaling value."""
|
|
try:
|
|
PERSIST['pressure_raw_max'] = float(value)
|
|
self.sendtodb("setpressurerawmax", PERSIST['pressure_raw_max'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.pressure_raw_max: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setpressurepsimin(self, name, value):
|
|
"""Set the pressure psi min scaling value."""
|
|
try:
|
|
PERSIST['pressure_psi_min'] = float(value)
|
|
self.sendtodb("setpressurepsimin", PERSIST['pressure_psi_min'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.pressure_psi_min: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setpressurepsimax(self, name, value):
|
|
"""Set the pressure psi max scaling value."""
|
|
try:
|
|
PERSIST['pressure_psi_max'] = float(value)
|
|
self.sendtodb("setpressurepsimax", PERSIST['pressure_psi_max'], 0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Could not set self.pressure_psi_max: {}".format(e))
|
|
return(True)
|
|
|
|
def flowmonitor_setgpmignorelimit(self, name, value):
|
|
"""Set the GPM Ignore Limit."""
|
|
try:
|
|
PERSIST['gpm_ignore_limit'] = float(value)
|
|
self.sendtodb("setgpmignorelimit", PERSIST['gpm_ignore_limit'], 0)
|
|
persistence.store(PERSIST)
|
|
return True
|
|
except Exception as e:
|
|
log.error("Error during flowmonitor_setgpmignorelimit: {}".format(e))
|
|
return False
|
|
|
|
def flowmonitor_gpmorbpd(self, name, value):
|
|
"""Set the read in value to GPM or BPD"""
|
|
try:
|
|
PERSIST["gpm_or_bpd"] = str(value)
|
|
self.sendtodb("gpmorbpd", PERSIST["gpm_or_bpd"], 0)
|
|
return True
|
|
except Exception as e:
|
|
log.error("Error during flowmonitor_setgpmorbpd: {}".format(e))
|
|
return False
|
|
|
|
def flowmonitor_setlowflow(self, name, value):
|
|
"""Set the low flow limit"""
|
|
try:
|
|
PERSIST["lowflow"] = float(value)
|
|
self.sendtodb("setlowflow", PERSIST["lowflow"],0)
|
|
persistence.store(PERSIST)
|
|
except Exception as e:
|
|
log.error("Error during flomonitor_setlowflow: {}".format(e))
|
|
return False
|
|
return True
|
|
|
|
|
|
|
|
|
|
def totalize(self, val):
|
|
right_now = dt.today()
|
|
month = right_now.month
|
|
day = right_now.day
|
|
#Totalize Today, Yesterday, Month, Last Month
|
|
#if the stored day is 0 then it's a fresh run of this should initalize values now
|
|
if TOTALIZER['Day'] == 0:
|
|
TOTALIZER['Day'] = day
|
|
TOTALIZER['Month'] = month
|
|
TOTALIZER['Daily Holding'] = val
|
|
TOTALIZER['Monthly Holding'] = val
|
|
persistence.store(TOTALIZER, 'totalizers.json')
|
|
#Communication error during initialization check if lifetime has reported properly and update holdings
|
|
if TOTALIZER['Daily Holding'] == None and not(val == None):
|
|
TOTALIZER['Daily Holding'] = val
|
|
TOTALIZER['Monthly Holding'] = val
|
|
|
|
try:
|
|
if val - TOTALIZER['Daily Holding'] - TOTALIZER['Todays'] > 500 or time.time() - TOTALIZER['Last Report'] > 3600 or self.force_send:
|
|
TOTALIZER['Todays'] = val - TOTALIZER['Daily Holding']
|
|
TOTALIZER['Current Months'] = val - TOTALIZER['Monthly Holding']
|
|
TOTALIZER['Lifetime'] = val
|
|
if PERSIST["gpm_or_bpd"] == "gpm":
|
|
self.sendtodb('gal_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays']/42, 0)
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months']/42, 0)
|
|
self.sendtodb('gal_total_yesterday', TOTALIZER['Yesterdays'], 0)
|
|
self.sendtodb('bbl_total_yesterday', TOTALIZER['Yesterdays']/42, 0)
|
|
if self.force_send:
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months']/42, 0)
|
|
else:
|
|
self.sendtodb('gal_total', TOTALIZER['Todays']*42, 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('gal_total_yesterday', TOTALIZER['Yesterdays'] * 42, 0)
|
|
self.sendtodb('bbl_total_yesterday', TOTALIZER['Yesterdays'], 0)
|
|
if self.force_send:
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
TOTALIZER['Last Report'] = time.time()
|
|
except:
|
|
if time.time() - TOTALIZER['Last Report'] > 3600 or self.force_send:
|
|
if PERSIST["gpm_or_bpd"] == "gpm":
|
|
self.sendtodb('gal_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays']/42, 0)
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months']/42, 0)
|
|
self.sendtodb('gal_total_yesterday', TOTALIZER['Yesterdays'], 0)
|
|
self.sendtodb('bbl_total_yesterday', TOTALIZER['Yesterdays']/42, 0)
|
|
if self.force_send:
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months']/42, 0)
|
|
else:
|
|
self.sendtodb('gal_total', TOTALIZER['Todays']*42, 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('gal_total_yesterday', TOTALIZER['Yesterdays'] * 42, 0)
|
|
self.sendtodb('bbl_total_yesterday', TOTALIZER['Yesterdays'], 0)
|
|
if self.force_send:
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
TOTALIZER['Last Report'] = time.time()
|
|
|
|
#If the current day doesn't equal the stored day roll the dailies over
|
|
if not(day == TOTALIZER['Day']):
|
|
#if a comms error use the stored values else use the latested values
|
|
if val == None:
|
|
TOTALIZER['Yesterdays'] = TOTALIZER['Todays']
|
|
TOTALIZER['Todays'] = 0
|
|
TOTALIZER['Daily Holding'] = TOTALIZER['Lifetime']
|
|
else:
|
|
TOTALIZER['Yesterdays'] = val - TOTALIZER['Daily Holding']
|
|
TOTALIZER['Todays'] = 0
|
|
TOTALIZER['Daily Holding'] = val
|
|
TOTALIZER['Lifetime'] = val
|
|
TOTALIZER['Day'] = day
|
|
if PERSIST["gpm_or_bpd"] == "gpm":
|
|
self.sendtodb('gal_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays']/42, 0)
|
|
self.sendtodb('total_fm_yesterday_gal', TOTALIZER['Yesterdays'], 0)
|
|
self.sendtodb('total_fm_yesterday_bbls', TOTALIZER['Yesterdays']/42, 0)
|
|
self.sendtodb('lifetime_flow_meter_gal', TOTALIZER['Lifetime'], 0)
|
|
self.sendtodb('lifetime_flow_meter_bbls', TOTALIZER['Lifetime']/42, 0)
|
|
else:
|
|
self.sendtodb('gal_total', TOTALIZER['Todays'] * 42, 0)
|
|
self.sendtodb('bbl_total', TOTALIZER['Todays'], 0)
|
|
self.sendtodb('total_fm_yesterday_gal', TOTALIZER['Yesterdays'] * 42, 0)
|
|
self.sendtodb('total_fm_yesterday_bbls', TOTALIZER['Yesterdays'], 0)
|
|
self.sendtodb('lifetime_flow_meter_gal', TOTALIZER['Lifetime'] * 42, 0)
|
|
self.sendtodb('lifetime_flow_meter_bbls', TOTALIZER['Lifetime'], 0)
|
|
TOTALIZER['Last Report'] = time.time()
|
|
#the day has rolled over if the month also rolls over
|
|
if not(month == TOTALIZER['Month']):
|
|
#if a comms error use the stored values else use the latested values
|
|
if val == None:
|
|
TOTALIZER['Previous Months'] = TOTALIZER['Current Months']
|
|
TOTALIZER['Current Months'] = 0
|
|
TOTALIZER['Monthly Holding'] = TOTALIZER['Lifetime']
|
|
else:
|
|
TOTALIZER['Previous Months'] = val - TOTALIZER['Monthly Holding']
|
|
TOTALIZER['Current Months'] = 0
|
|
TOTALIZER['Monthly Holding'] = val
|
|
TOTALIZER['Month'] = month
|
|
if PERSIST["gpm_or_bpd"] == "gpm":
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months']/42, 0)
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months']/42, 0)
|
|
else:
|
|
self.sendtodb('gal_total_thismonth', TOTALIZER['Current Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_thismonth', TOTALIZER['Current Months'], 0)
|
|
self.sendtodb('gal_total_lastmonth', TOTALIZER['Previous Months'] * 42, 0)
|
|
self.sendtodb('bbl_total_lastmonth', TOTALIZER['Previous Months'], 0)
|
|
TOTALIZER['Last Report'] = time.time()
|
|
persistence.store(TOTALIZER, 'totalizers.json')
|
|
|
|
def startRS485(self):
|
|
instrument = ""
|
|
with self.lock:
|
|
#minimalmodbus.BAUDRATE = 9600
|
|
#minimalmodbus.STOPBITS = 1
|
|
connected = False
|
|
while connected == False:
|
|
log.info("Attempting to setup RS485")
|
|
connected = self.mcu.set485Baud(9600)#switch to configurable
|
|
time.sleep(1)
|
|
log.info("RS485 SETUP SUCCESSFUL!!!!!")
|
|
serial = self.mcu.rs485
|
|
instrument = minimalmodbusM1.Instrument(1,serial)
|
|
instrument.address = 2 #switch to configurable
|
|
return instrument
|
|
|