nmelone/MaxWaterSystem-Lite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Completes #1.

Browse Source 
- Adds Pressure Transmitter on Analog 1
- Updates device driver for reading Analog 1
- Updates device driver to store scaling parameters in persist.json
- Increments version to 11
- Adds migration script to convert from using SQLite scaling storage
- Updates HTML Templates
- Updates README
This commit is contained in:
Patrick McDonagh
2018-04-05 16:41:54 -05:00
parent f48c165aff
commit 91096b2291
8 changed files with 448 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
HTML/Configuration.html
View File

@@ -106,6 +106,45 @@
</form>
</div>
</div>
<div class="col-md-6 text-center box-me" id="pressure-transmitter-toggle">
<% if (channels['flowmonitor.psi_pressure_enabled'].value == "True"){ %>
<h2>Pressure Transmitter Enabled</h2>
<% } else { %>
<h2>Pressure Transmitter Disabled</h2>
<% } %>
<div data-valueupdate="psi_pressure_enabled" data-refreshonupdate=true>
<form>
<% if (channels['flowmonitor.psi_pressure_enabled'].value == "True"){ %>
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend="False"
data-channelId="<%= channels["flowmonitor.psi_pressure_enabled"].channelId %>"
data-techname="<%=channels["flowmonitor.psi_pressure_enabled"].techName %>"
data-name="<%= channels["flowmonitor.psi_pressure_enabled"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.psi_pressure_enabled"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.psi_pressure_enabled"].channelId %>"
class="btn btn-large btn-theme animated setstatic">Disable Pressure Transmitter</a>
<% } else { %>
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend="True"
data-channelId="<%= channels["flowmonitor.psi_pressure_enabled"].channelId %>"
data-techname="<%=channels["flowmonitor.psi_pressure_enabled"].techName %>"
data-name="<%= channels["flowmonitor.psi_pressure_enabled"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.psi_pressure_enabled"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.psi_pressure_enabled"].channelId %>"
class="btn btn-large btn-theme animated setstatic">Enable Pressure Transmitter</a>
<% } %>
</form>
</div>
</div>
</div>

33
HTML/Overview.html
View File

@@ -82,6 +82,35 @@
</span>
</div>
</div>
<% if (channels["flowmonitor.psi_pressure_enabled"].value == "True") { %>
<div class='col-xs-6 col-offset-xs-3 text-center box-me'>
<h2>Pressure Transmitter</h2>
<div class="gauge-box">
<div data-labelheight="10"
style="height: 170px; background: transparent; margin: 0 auto;"
id="gauge-psi_pressure"
data-chart="solidgauge"
data-nodename="flowmonitor.psi_pressure"
data-units="BPD"
data-min="0"
data-max="5000"
data-decimalplaces="2"
data-colors="0.1:#DF5353,0.5:#DDDF0D,0.9:#55BF3B"
data-valuefontsize="18px">
</div>
<div class- "timestamp-box">
<a href="#" data-channelId="<%= channels['flowmonitor.psi_pressure'].channelId %>" class="data-table" title="Download Channel History">
<i class="fa fa-download"></i>
</a>
</div>
<span data-timeupdate="psi_pressure">
<%= channels["flowmonitor.psi_pressure"].timestamp %>
</span>
</div>
</div>
<% } %>
</div>
<div class="row box-me">
@@ -133,6 +162,10 @@
data-chart="chart"
data-nodename1="flowmonitor.bpd_flow"
data-datalabel1="Flow Rate (BPD)"
<% if (channels["flowmonitor.psi_pressure_enabled"].value === "True") { %>
data-nodename2="flowmonitor.psi_pressure"
data-datalabel2="Pressure (PSI)"
<% } %>
data-daysofhistory="2"
data-chartlabel="Last 48 Hours"
data-ylabel=""

147
HTML/Scaling.html
View File

@@ -1,4 +1,8 @@
<div class="row row-flex">
<div class="col-xs-12" style="text-align: center;">
<h1>Flowmeter</h1>
</div>
<div class="col-md-6 box-me entry-top-level" id="setrawmin">
<div style="margin-left:15px;">
<h2>Raw Min</h2>
@@ -172,6 +176,149 @@
</div>
<div class="row row-flex">
<div class="col-xs-12" style="text-align: center;">
<h1>Pressure Transmitter</h1>
</div>
<div class="col-md-6 box-me entry-top-level" id="setpressurerawmin">
<div style="margin-left:15px;">
<h2>Raw Min</h2>
<form class="form-inline">
<div class="form-group" style="margin-bottom:15px;">
<label
class="sr-only"
for="<%= channels["flowmonitor.setpressurerawmin"].channelId %>">Raw Min Value</label>
<div class="input-group">
<input
class="form-control channel_value"
type="number"
step="any"
value="<%=channels['flowmonitor.setpressurerawmin'].value %>">
<div class="input-group-addon">V</div>
</div>
</div>
<hr />
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend=1.0
data-channelId="<%= channels["flowmonitor.setpressurerawmin"].channelId %>"
data-techname="<%=channels["flowmonitor.setpressurerawmin"].techName %>"
data-name="<%= channels["flowmonitor.setpressurerawmin"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.setpressurerawmin"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.setpressurerawmin"].channelId %>"
class="btn btn-large btn-theme animated setstatic material-icons">send</a>
</form>
</div>
</div>
<div class="col-md-6 box-me entry-top-level" id="setpressurerawmax">
<div style="margin-left:15px;">
<h2>Raw Max</h2>
<form class="form-inline">
<div class="form-group" style="margin-bottom:15px;">
<label
class="sr-only"
for="<%= channels["flowmonitor.setpressurerawmax"].channelId %>">Raw Max Value</label>
<div class="input-group">
<input
class="form-control channel_value"
type="number"
step="any"
value="<%=channels['flowmonitor.setpressurerawmax'].value %>">
<div class="input-group-addon">V</div>
</div>
</div>
<hr />
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend=1.0
data-channelId="<%= channels["flowmonitor.setpressurerawmax"].channelId %>"
data-techname="<%=channels["flowmonitor.setpressurerawmax"].techName %>"
data-name="<%= channels["flowmonitor.setpressurerawmax"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.setpressurerawmax"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.setpressurerawmax"].channelId %>"
class="btn btn-large btn-theme animated setstatic material-icons">send</a>
</form>
</div>
</div>
<div class="col-md-6 box-me entry-top-level" id="setpressurepsimin">
<div style="margin-left:15px;">
<h2>PSI Min</h2>
<form class="form-inline">
<div class="form-group" style="margin-bottom:15px;">
<label
class="sr-only"
for="<%= channels["flowmonitor.setpressurepsimin"].channelId %>">PSI Min Value</label>
<div class="input-group">
<input
class="form-control channel_value"
type="number"
step="any"
value="<%=channels['flowmonitor.setpressurepsimin'].value %>">
<div class="input-group-addon">PSI</div>
</div>
</div>
<hr />
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend=1.0
data-channelId="<%= channels["flowmonitor.setpressurepsimin"].channelId %>"
data-techname="<%=channels["flowmonitor.setpressurepsimin"].techName %>"
data-name="<%= channels["flowmonitor.setpressurepsimin"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.setpressurepsimin"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.setpressurepsimin"].channelId %>"
class="btn btn-large btn-theme animated setstatic material-icons">send</a>
</form>
</div>
</div>
<div class="col-md-6 box-me entry-top-level" id="setpressurepsimax">
<div style="margin-left:15px;">
<h2>PSI Max</h2>
<form class="form-inline">
<div class="form-group" style="margin-bottom:15px;">
<label
class="sr-only"
for="<%= channels["flowmonitor.setpressurepsimax"].channelId %>">PSI Max Value</label>
<div class="input-group">
<input
class="form-control channel_value"
type="number"
step="any"
value="<%=channels['flowmonitor.setpressurepsimax'].value %>">
<div class="input-group-addon">PSI</div>
</div>
</div>
<hr />
<a
href="#"
data-confirm-message="Are you sure you want to do this?"
data-refreshpause="1"
data-command=""
data-staticsend=1.0
data-channelId="<%= channels["flowmonitor.setpressurepsimax"].channelId %>"
data-techname="<%=channels["flowmonitor.setpressurepsimax"].techName %>"
data-name="<%= channels["flowmonitor.setpressurepsimax"].name%>"
data-nodechannelcurrentId="<%= channels["flowmonitor.setpressurepsimax"].nodechannelcurrentId %>"
id="<%= channels["flowmonitor.setpressurepsimax"].channelId %>"
class="btn btn-large btn-theme animated setstatic material-icons">send</a>
</form>
</div>
</div>
</div>
<script>
$('.channel_value').each(function(topLevel){
$(this).change(function(){

2
HTML/Trends.html
View File

@@ -30,7 +30,7 @@
data-ylabel=""
data-xlabel="Date"
data-units=""
data-channelnames="flowmonitor.gal_total,flowmonitor.gal_total_yesterday,flowmonitor.bbl_total,flowmonitor.bbl_total_yesterday,flowmonitor.gpm_flow,flowmonitor.gal_total_thismonth,flowmonitor.gal_total_lastmonth,flowmonitor.bbl_total_thismonth,flowmonitor.bbl_total_lastmonth,flowmonitor.bpd_flow"></div>
data-channelnames="flowmonitor.gal_total,flowmonitor.gal_total_yesterday,flowmonitor.bbl_total,flowmonitor.bbl_total_yesterday,flowmonitor.gpm_flow,flowmonitor.gal_total_thismonth,flowmonitor.gal_total_lastmonth,flowmonitor.bbl_total_thismonth,flowmonitor.bbl_total_lastmonth,flowmonitor.bpd_flow<% if (channels['flowmonitor.psi_pressure_enabled'].value == 'True') { %>,flowmonitor.psi_pressure<% } %>"></div>
<style>
.dynamic-chart-form {

29
README.md
View File

@@ -1,22 +1,15 @@
# flow-monitor
# Max Water System Lite
## To set up sqlite database
```
sqlite3 flow-monitor.db
## Wiring
CREATE TABLE flow_data (
id integer PRIMARY KEY,
gal_totalizer_value float,
bbl_totalizer_value float,
last_measured_timestamp integer
);
| Channel | Device |
| -------------- | -------------------- |
| Relay 1 | Starter Output |
| Digital In 1 | Auto Switch |
| Digital In 2 | Start Button |
| Current Loop | Flowmeter |
| Analog Input 1 | Pressure Transmitter |
INSERT INTO flow_data (id, gal_totalizer_value, bbl_totalizer_value, last_measured_timestamp) VALUES (1, 0.0, 0.0, 0);
```
## Contributors
## To reset the sqlite database
```
sqlite3 flow-monitor.db
UPDATE flow_data SET gal_totalizer_value=0.0, bbl_totalizer_value=0.0, last_measured_timestamp=0 WHERE id=1;
```
- [Patrick McDonagh](https://github.com/patrickjmcd) - Owner

14
config.txt
View File

@@ -1,11 +1,11 @@
{
"files": {
"file3": "persistence.py",
"file2": "utilities.py",
"file3": "persistence.py",
"file2": "utilities.py",
"file1": "flow-monitor.py"
},
"deviceName": "flowmonitor",
"driverId": "0140",
"releaseVersion": "10",
},
"deviceName": "flowmonitor",
"driverId": "0180",
"releaseVersion": "11",
"driverFileName": "flow-monitor.py"
}
}

8
driverConfig.json
View File

@@ -1,10 +1,10 @@
{
"version": 11,
"driverFilename": "flow-monitor.py",
"s3BucketName": "flow-monitor",
"name": "flowmonitor",
"additionalDriverFiles": [
"utilities.py",
"persistence.py"
],
"name": "flowmonitor",
"version": 9,
"driverFilename": "flow-monitor.py"
]
}

306
flow-monitor.py
View File

@@ -3,10 +3,30 @@ import threading
import time
from datetime import datetime
import sqlite3
import logging
import sys
from device_base import deviceBase
import persistence
from utilities import get_public_ip_address
# LOGGING SETUP
from logging.handlers import RotatingFileHandler
log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
logFile = './flowmonitor.log'
my_handler = RotatingFileHandler(logFile, mode='a', maxBytes=500*1024, backupCount=2, encoding=None, delay=0)
my_handler.setFormatter(log_formatter)
my_handler.setLevel(logging.INFO)
logger = logging.getLogger('flowmonitor')
logger.setLevel(logging.INFO)
logger.addHandler(my_handler)
console_out = logging.StreamHandler(sys.stdout)
console_out.setFormatter(log_formatter)
logger.addHandler(console_out)
logger.info("flowmonitor startup")
CREATE_FLOWDATA_TABLE = """CREATE TABLE flow_data (
id integer PRIMARY KEY,
gal_totalizer_value float,
@@ -39,30 +59,43 @@ UPDATE_FLOWDATA = """UPDATE flow_data SET
bbl_monthly_totalizer=?,
last_measured_timestamp=? WHERE id=1"""
CREATE_SCALINGDATA_TABLE = """CREATE TABLE scaling_data (
id integer PRIMARY KEY,
raw_min float,
raw_max float,
gpm_min float,
gpm_max float
);"""
INSERT_SCALINGDATA = """INSERT INTO scaling_data (
id,
raw_min,
raw_max,
gpm_min,
gpm_max) VALUES (1, ?, ?, ?, ?);"""
UPDATE_SCALINGDATA = """UPDATE scaling_data SET
raw_min=?,
raw_max=?,
gpm_min=?,
gpm_max=? WHERE id=1;"""
PERSIST = persistence.load()
def migrate_from_sqlite_to_json_scaling():
"""Migrate data from SQLite db to JSON, if needed"""
global PERSIST
try:
PERSIST['flow_raw_min']
logger.info("Don't need to migrate from SQLite to JSON.")
return False
except (KeyError, TypeError):
logger.info("Migrating from SQLite to JSON.")
if not PERSIST:
PERSIST = {}
conn = sqlite3.connect('/root/python_firmware/drivers/flow-monitor.db')
cursor = conn.cursor()
try:
cursor.execute('SELECT * FROM scaling_data WHERE id = 1') # dummy query for checking database
stored_data = cursor.fetchone()
flow_raw_min = stored_data[1]
flow_raw_max = stored_data[2]
flow_gpm_min = stored_data[3]
flow_gpm_max = stored_data[4]
except (sqlite3.OperationalError, TypeError):
logger.info("No stored data in SQLite for scaling, we'll just use default values")
return False
PERSIST["flow_raw_min"] = flow_raw_min
PERSIST["flow_raw_max"] = flow_raw_max
PERSIST["flow_gpm_min"] = flow_gpm_min
PERSIST["flow_gpm_max"] = flow_gpm_max
persistence.store(PERSIST)
class ChannelSimple(object):
"""Simple Meshify channel structure."""
@@ -126,14 +159,20 @@ class start(threading.Thread, deviceBase):
mcu=mcu, companyId=companyId, offset=offset,
mqtt=mqtt, Nodes=Nodes)
# Default Scaling Values for Flowmeter
self.RAW_MIN = 3.89
self.RAW_MAX = 19.54
self.GPM_MIN = 0.0
self.GPM_MAX = 100.0
self.flow_raw_min = 3.89
self.flow_raw_max = 19.54
self.flow_gpm_min = 0.0
self.flow_gpm_max = 100.0
self.pressure_raw_min = 0.00
self.pressure_raw_max = 10.00
self.pressure_psi_min = 0.00
self.pressure_psi_max = 600.0
self.GPM_IGNORE_LIMIT = 1.0
self.daemon = True
self.version = "10"
self.version = "11"
self.finished = threading.Event()
threading.Thread.start(self)
@@ -149,6 +188,7 @@ class start(threading.Thread, deviceBase):
# Configuration Parameters
total_time_store_delta = 600 # seconds
flow_time_store_delta = 600 # seconds
pressure_time_store_delta = 600 # seconds
gal_per_bbl = 42.0
startup_wait_seconds = 30
ip_check_after = 3600 # check public IP address after an hour
@@ -169,13 +209,14 @@ class start(threading.Thread, deviceBase):
bbltotalthismonth_ch = ChannelSimple('bbl_total_thismonth', galtotalthismonth_ch.senddelta_value/gal_per_bbl, total_time_store_delta)
gpmflow_ch = ChannelSimple('gpm_flow', 10.0, flow_time_store_delta)
bpdflow_ch = ChannelSimple('bpd_flow', gpmflow_ch.senddelta_value * 34.2857, flow_time_store_delta)
psipressure_ch = ChannelSimple('psi_pressure', 10.0, pressure_time_store_delta)
runstatus_ch = ChannelSimple('run_status', 0.5, 600)
# Startup timer.
# Waits for connection to Meshify before attempting to send data
wait_loops = 0
while wait_loops < startup_wait_seconds:
print("Waiting to start flowmonitor driver in {} seconds".format(startup_wait_seconds - wait_loops))
logger.info("Waiting to start flowmonitor driver in {} seconds".format(startup_wait_seconds - wait_loops))
wait_loops += 1
time.sleep(1)
@@ -203,7 +244,7 @@ class start(threading.Thread, deviceBase):
last_measured_timestamp = stored_data[5]
except sqlite3.OperationalError:
# Caught if the table does not exist in the database.
print("No table flow_data in the database. I'll create it now.")
logger.warning("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_FLOWDATA_TABLE)
cursor.execute(INSERT_BLANK_FLOWDATA)
conn.commit()
@@ -211,32 +252,49 @@ class start(threading.Thread, deviceBase):
# Reset the database if the correct size data is not in the database.
self.flowmonitor_resetdatabase(None, None)
# Load scaling data
migrate_from_sqlite_to_json_scaling()
try:
cursor.execute('SELECT * FROM scaling_data WHERE id = 1') # dummy query for checking database
stored_data = cursor.fetchone()
self.RAW_MIN = stored_data[1]
self.RAW_MAX = stored_data[2]
self.GPM_MIN = stored_data[3]
self.GPM_MAX = stored_data[4]
self.sendtodb("setrawmin", self.RAW_MIN, 0)
self.sendtodb("setrawmax", self.RAW_MAX, 0)
self.sendtodb("setgpmmin", self.GPM_MIN, 0)
self.sendtodb("setgpmmax", self.GPM_MAX, 0)
except (sqlite3.OperationalError, TypeError):
# Caught if the table does not exist in the database.
print("No table scaling_data in the database. I'll create it now.")
cursor.execute(CREATE_SCALINGDATA_TABLE)
cursor.execute(INSERT_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
self.sendtodb("setrawmin", self.RAW_MIN, 0)
self.sendtodb("setrawmax", self.RAW_MAX, 0)
self.sendtodb("setgpmmin", self.GPM_MIN, 0)
self.sendtodb("setgpmmax", self.GPM_MAX, 0)
conn.commit()
self.flow_raw_min = PERSIST["flow_raw_min"]
self.flow_raw_max = PERSIST["flow_raw_max"]
self.flow_gpm_min = PERSIST["flow_gpm_min"]
self.flow_gpm_max = PERSIST["flow_gpm_max"]
except KeyError:
logger.warning("No flow scaling data exists in persist file. We'll add some now")
PERSIST["flow_raw_min"] = self.flow_raw_min
PERSIST["flow_raw_max"] = self.flow_raw_max
PERSIST["flow_gpm_min"] = self.flow_gpm_min
PERSIST["flow_gpm_max"] = self.flow_gpm_max
persistence.store(PERSIST)
self.sendtodb("setrawmin", self.flow_raw_min, 0)
self.sendtodb("setrawmax", self.flow_raw_max, 0)
self.sendtodb("setgpmmin", self.flow_gpm_min, 0)
self.sendtodb("setgpmmax", self.flow_gpm_max, 0)
try:
self.pressure_raw_min = PERSIST["pressure_raw_min"]
self.pressure_raw_max = PERSIST["pressure_raw_max"]
self.pressure_psi_min = PERSIST["pressure_psi_min"]
self.pressure_psi_max = PERSIST["pressure_psi_max"]
except KeyError:
logger.warning("No flow scaling data exists in persist file. We'll add some now")
PERSIST["pressure_raw_min"] = self.pressure_raw_min
PERSIST["pressure_raw_max"] = self.pressure_raw_max
PERSIST["pressure_psi_min"] = self.pressure_psi_min
PERSIST["pressure_psi_max"] = self.pressure_psi_max
persistence.store(PERSIST)
self.sendtodb("setpressurerawmin", self.pressure_raw_min, 0)
self.sendtodb("setpressurerawmax", self.pressure_raw_max, 0)
self.sendtodb("setpressurepsimin", self.pressure_psi_min, 0)
self.sendtodb("setpressurepsimax", self.pressure_psi_max, 0)
try:
self.GPM_IGNORE_LIMIT = PERSIST['gpm_ignore_limit']
except Exception:
print("no persisted GPM Ignore Limit. Using default of {}".format(self.GPM_IGNORE_LIMIT))
logger.warning("no persisted GPM Ignore Limit. Using default of {}".format(self.GPM_IGNORE_LIMIT))
self.flowmonitor_setgpmignorelimit("gpm_ignore_limit", self.GPM_IGNORE_LIMIT)
# on bootup, if the day has changed, clear the totalizers.
@@ -250,10 +308,30 @@ class start(threading.Thread, deviceBase):
while True:
try:
mcu_status = self.mcu.getDict() # 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'
# }
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
gpm_val = scale(cloop_val, self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX)
gpm_val = scale(cloop_val, self.flow_raw_min, self.flow_raw_max, self.flow_gpm_min, self.flow_gpm_max)
psi_val = scale(analog1_val, self.pressure_raw_min, self.pressure_raw_max, self.pressure_psi_min, self.pressure_psi_max)
if gpm_val < self.GPM_IGNORE_LIMIT:
gpm_val = 0
@@ -278,8 +356,8 @@ class start(threading.Thread, deviceBase):
cursor.execute(UPDATE_FLOWDATA, (gal_totalizer_value, bbl_totalizer_value, gal_monthly_totalizer, bbl_monthly_totalizer, last_measured_timestamp))
conn.commit()
print('gpm: {}, bpd: {}, gal: {}, bbl:{}, month_gal:{}, month_bbl:{}'.format(
gpm_val, bpd_val, gal_totalizer_value, bbl_totalizer_value, gal_monthly_totalizer, bbl_monthly_totalizer))
logger.info('gpm: {}, bpd: {}, psi: {}, gal: {}, bbl:{}, month_gal:{}, month_bbl:{}'.format(
gpm_val, bpd_val, psi_val, gal_totalizer_value, bbl_totalizer_value, gal_monthly_totalizer, bbl_monthly_totalizer))
# Channel Checks:
# check to see if the value needs to be sent to Meshify
@@ -307,6 +385,10 @@ class start(threading.Thread, deviceBase):
self.sendtodb(bpdflow_ch.meshify_name, bpd_val, 0)
bpdflow_ch.update(bpd_val, now)
if psipressure_ch.check_if_send_needed(psi_val, now):
self.sendtodb(psipressure_ch.meshify_name, psi_val, 0)
psipressure_ch.update(psi_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)
@@ -358,7 +440,7 @@ class start(threading.Thread, deviceBase):
self.flowmonitor_stopcmd(None, None)
except Exception as e:
print("problem in the driver: {}".format(e))
logger.error("problem in the driver: {}".format(e))
time.sleep(2)
def flowmonitor_startcmd(self, name, value):
@@ -381,9 +463,9 @@ class start(threading.Thread, deviceBase):
cursor.execute(CREATE_FLOWDATA_TABLE)
cursor.execute(INSERT_BLANK_FLOWDATA)
conn.commit()
print("DATABASE HAS BEEN RESET!")
logger.info("DATABASE HAS BEEN RESET!")
except sqlite3.OperationalError:
print("No table flow_data in the database. I'll create it now.")
logger.warning("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_FLOWDATA_TABLE)
cursor.execute(INSERT_BLANK_FLOWDATA)
conn.commit()
@@ -391,66 +473,90 @@ class start(threading.Thread, deviceBase):
def flowmonitor_setrawmin(self, name, value):
"""Set the raw min scaling value."""
conn = sqlite3.connect('/root/python_firmware/drivers/flow-monitor.db')
cursor = conn.cursor()
try:
self.RAW_MIN = float(value)
cursor.execute(UPDATE_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
self.sendtodb("setrawmin", self.RAW_MIN, 0)
conn.commit()
except sqlite3.OperationalError:
print("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_SCALINGDATA_TABLE)
cursor.execute(INSERT_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
self.flow_raw_min = float(value)
self.sendtodb("setrawmin", self.flow_raw_min, 0)
PERSIST['flow_raw_min'] = self.flow_raw_min
persistence.store(PERSIST)
except Exception as e:
logger.error("Could not set self.flow_raw_min: {}".format(e))
return(True)
def flowmonitor_setrawmax(self, name, value):
"""Set the raw max scaling value."""
conn = sqlite3.connect('/root/python_firmware/drivers/flow-monitor.db')
cursor = conn.cursor()
try:
self.RAW_MAX = float(value)
self.sendtodb("setrawmax", self.RAW_MAX, 0)
cursor.execute(UPDATE_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
except sqlite3.OperationalError:
print("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_SCALINGDATA_TABLE)
cursor.execute(INSERT_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
self.flow_raw_max = float(value)
self.sendtodb("setrawmax", self.flow_raw_max, 0)
PERSIST['flow_raw_max'] = self.flow_raw_max
persistence.store(PERSIST)
except Exception as e:
logger.error("Could not set self.flow_raw_max: {}".format(e))
return(True)
def flowmonitor_setgpmmin(self, name, value):
"""Set the gpm min scaling value."""
conn = sqlite3.connect('/root/python_firmware/drivers/flow-monitor.db')
cursor = conn.cursor()
try:
self.GPM_MIN = float(value)
self.sendtodb("setgpmmin", self.GPM_MIN, 0)
cursor.execute(UPDATE_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
except sqlite3.OperationalError:
print("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_SCALINGDATA_TABLE)
cursor.execute(INSERT_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
self.flow_gpm_min = float(value)
self.sendtodb("setgpmmin", self.flow_gpm_min, 0)
PERSIST['flow_gpm_min'] = self.flow_gpm_min
persistence.store(PERSIST)
except Exception as e:
logger.error("Could not set self.flow_gpm_min: {}".format(e))
return(True)
def flowmonitor_setgpmmax(self, name, value):
"""Set the gpm max scaling value."""
conn = sqlite3.connect('/root/python_firmware/drivers/flow-monitor.db')
cursor = conn.cursor()
try:
self.GPM_MAX = float(value)
self.sendtodb("setgpmmax", self.GPM_MAX, 0)
cursor.execute(UPDATE_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
except sqlite3.OperationalError:
print("No table flow_data in the database. I'll create it now.")
cursor.execute(CREATE_SCALINGDATA_TABLE)
cursor.execute(INSERT_SCALINGDATA, (self.RAW_MIN, self.RAW_MAX, self.GPM_MIN, self.GPM_MAX))
conn.commit()
self.flow_gpm_max = float(value)
self.sendtodb("setgpmmax", self.flow_gpm_max, 0)
PERSIST['flow_gpm_max'] = self.flow_gpm_max
persistence.store(PERSIST)
except Exception as e:
logger.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:
self.pressure_raw_min = float(value)
self.sendtodb("setpressurerawmin", self.pressure_raw_min, 0)
PERSIST['pressure_raw_min'] = self.pressure_raw_min
persistence.store(PERSIST)
except Exception as e:
logger.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:
self.pressure_raw_max = float(value)
self.sendtodb("setpressurerawmax", self.pressure_raw_max, 0)
PERSIST['pressure_raw_max'] = self.pressure_raw_max
persistence.store(PERSIST)
except Exception as e:
logger.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:
self.pressure_psi_min = float(value)
self.sendtodb("setpressurepsimin", self.pressure_psi_min, 0)
PERSIST['pressure_psi_min'] = self.pressure_psi_min
persistence.store(PERSIST)
except Exception as e:
logger.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:
self.pressure_psi_max = float(value)
self.sendtodb("setpressurepsimax", self.pressure_psi_max, 0)
PERSIST['pressure_psi_max'] = self.pressure_psi_max
persistence.store(PERSIST)
except Exception as e:
logger.error("Could not set self.pressure_psi_max: {}".format(e))
return(True)
def flowmonitor_setgpmignorelimit(self, name, value):
@@ -460,5 +566,5 @@ class start(threading.Thread, deviceBase):
self.sendtodb("setgpmignorelimit", self.GPM_IGNORE_LIMIT, 0)
return True
except Exception as e:
print("Error during flowmonitor_setgpmignorelimit: {}".format(e))
logger.error("Error during flowmonitor_setgpmignorelimit: {}".format(e))
return False