"""Driver for connecting Pond Level to Meshify.""" import threading from device_base import deviceBase import time import json import persistence _ = None pond_level = { 'value': 15.0, 'timestamp': 0 } psi_reading = { 'value': 0.0, 'timestamp': 0 } send_delta = 2.0 send_time = 300 temp_pl = pond_level['value'] temp_psi = psi_reading['value'] scaling_persist = persistence.load(filename="scaling_persist.json") strapping_persist = persistence.load(filename="strapping_persist.json") def scale_to_eu(inp_measurement, raw_max, raw_min, eu_max, eu_min): """Scale the inp_measurement to engineering units.""" m = (eu_max - eu_min) / (raw_max - raw_min) b = eu_max - raw_max * m scaled = inp_measurement * m + b return scaled 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 = "3" self.finished = threading.Event() self.forceSend = False threading.Thread.start(self) self.PL_RAWMAX = 20.0 self.PL_RAWMIN = 4.0 self.PL_EUMAX = 23.068 self.PL_EUMIN = 0.0 self.PSI_RAWMAX = 10.0 self.PSI_RAWMIN = 0.0 self.PSI_EUMAX = 600.0 self.PSI_EUMIN = 0.0 # Strapping table format # { # height: volume, # height: volume, # height: volume, # etc... # } self.strapping_table = {} # 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) def run(self): """Actually run the driver.""" global pond_level, temp_pl, psi_reading, temp_psi, send_delta, send_time try: self.PL_RAWMAX = scaling_persist['raw_max'] self.PL_RAWMIN = scaling_persist['raw_min'] self.PL_EUMAX = scaling_persist['eu_max'] self.PL_EUMIN = scaling_persist['eu_min'] except KeyError: print("No persistence data for pond level scaling parameters.") except TypeError: print("No persistence data for pond level scaling parameters.") try: self.PSI_RAWMAX = scaling_persist['psi_raw_max'] self.PSI_RAWMIN = scaling_persist['psi_raw_min'] self.PSI_EUMAX = scaling_persist['psi_eu_max'] self.PSI_EUMIN = scaling_persist['psi_eu_min'] except KeyError: print("No persistence data for pressure scaling parameters.") except TypeError: print("No persistence data for pressure scaling parameters.") try: if len(strapping_persist.keys()) > 0: for k in strapping_persist.keys(): self.strapping_table[float(k)] = strapping_persist[k] print("Using stored strapping table:\n{}".format(self.strapping_table)) else: print("No stored strapping table found.") except Exception as e: print("No stored strapping table. Got Error: {}".format(e)) wait_sec = 30 for i in range(0, wait_sec): print("pondlevel driver will start in {} seconds".format(wait_sec - i)) time.sleep(1) print("BOOM! Starting pondlevel driver...") # db.setup_calibration_table(drop_first=False) self.send_calibration_points() self.sendtodb("setrawmax", self.PL_RAWMAX, 0) self.sendtodb("setrawmin", self.PL_RAWMIN, 0) self.sendtodb("seteumax", self.PL_EUMAX, 0) self.sendtodb("seteumin", self.PL_EUMIN, 0) self.sendtodb("setpsirawmax", self.PSI_RAWMAX, 0) self.sendtodb("setpsirawmin", self.PSI_RAWMIN, 0) self.sendtodb("setpsieumax", self.PSI_EUMAX, 0) self.sendtodb("setpsieumin", self.PSI_EUMIN, 0) send_loops = 0 while True: pl_send_now = False psi_send_now = False if self.forceSend: print "FORCE SEND: TRUE" pl_send_now = True psi_send_now = True mcu_status = self.mcu.getDict() # Gets a dictionary of the IO states cloop_val = float(mcu_status['cloop']) analog1_val = float(mcu_status['analog1']) temp_pl = scale_to_eu(cloop_val, self.PL_RAWMAX, self.PL_RAWMIN, self.PL_EUMAX, self.PL_EUMIN) temp_psi = scale_to_eu(analog1_val, self.PSI_RAWMAX, self.PSI_RAWMIN, self.PSI_EUMAX, self.PSI_EUMIN) # Check if pond level needs to be sent # 4/30/2018 -- COMMENTING OUT # Pond level was sending irregular data # -- Patrick McDonagh # if abs(temp_pl - pond_level['value']) > send_delta: # print("Sending pond level {} due to value change".format(temp_pl)) # pl_send_now = True # 4/30/2018 -- END COMMENTING OUT if (time.time() - pond_level['timestamp']) > send_time: print("Sending pond level {} due to time limit".format(temp_pl)) pl_send_now = True # Check if pressure needs to be sent if abs(temp_psi - psi_reading['value']) > send_delta: print("Sending pressure psi {} due to value change".format(temp_psi)) psi_send_now = True if (time.time() - psi_reading['timestamp']) > send_time: print("Sending pressure psi {} due to time limit".format(temp_psi)) psi_send_now = True if pl_send_now: self.sendtodb('pond_level', temp_pl, 0) pond_volume = 0.0 try: pond_volume = self.get_volume_for_height(temp_pl) except Exception: pass self.sendtodb('pond_volume', pond_volume, 0) pond_level['value'] = temp_pl pond_level['timestamp'] = time.time() if psi_send_now: self.sendtodb('pressure_psi', temp_psi, 0) psi_reading['value'] = temp_psi psi_reading['timestamp'] = time.time() print("pondlevel driver still alive...") if self.forceSend: if send_loops > 2: print("Turning off forceSend") self.forceSend = False send_loops = 0 else: send_loops += 1 time.sleep(10) def send_calibration_points(self): """Send calibration data from database to Meshify.""" strapping_table_list = [] height_list = self.strapping_table.keys() height_list.sort() for height in height_list: strapping_table_list.append([height, self.strapping_table[height]]) strapping_table_string = json.dumps(strapping_table_list) self.sendtodb('calibration_data', strapping_table_string, 0) def pondlevel_sync(self, name, value): """Sync all data from the driver.""" self.forceSend = True self.sendtodb("log", "synced", 0) return True def pondlevel_addcalibrationpoint(self, name, value): """Add a JSON calibration point to the database.""" try: new_point = json.loads(value.replace("'", '"')) print("Trying to add Height: {}, volume: {}".format(new_point['height'], new_point['volume'])) self.strapping_table[float(new_point['height'])] = float(new_point['volume']) self.store_strapping_table() # db.insert_calibration_data(new_point['height'], new_point['volume']) self.send_calibration_points() return True except Exception as e: print("EXCEPTION: {}".format(e)) def pondlevel_deletecalibrationpoint(self, name, value): """Delete a calibration point from the database.""" try: del self.strapping_table[float(value)] self.store_strapping_table() # db.delete_calibration_data(int(value)) self.send_calibration_points() return True except Exception as e: print("Error deleting calibration point: {}".format(e)) return(e) def store_scaling_data(self): """Store scaling data in the persist file.""" scale_obj = { 'raw_max': self.PL_RAWMAX, 'raw_min': self.PL_RAWMIN, 'eu_max': self.PL_EUMAX, 'eu_min': self.PL_EUMIN, 'psi_raw_max': self.PSI_RAWMAX, 'psi_raw_min': self.PSI_RAWMIN, 'psi_eu_max': self.PSI_EUMAX, 'psi_eu_min': self.PSI_EUMIN } persistence.store(scale_obj, filename="scaling_persist.json") def store_strapping_table(self): """Store strapping table in the persist file.""" persistence.store(self.strapping_table, filename="strapping_persist.json") def get_volume_for_height(self, height): """Interpret a volume for a given height.""" try: height = float(height) strapping_table_list = [] height_list = self.strapping_table.keys() height_list.sort() for height_i in height_list: strapping_table_list.append([float(height_i), float(self.strapping_table[height_i])]) print("Strapping Table Data\n===") print(strapping_table_list) cal_min_height = strapping_table_list[0][0] cal_max_height = strapping_table_list[-1][0] lower_cal = [0.0, 0.0] upper_cal = [0.0, 0.0] if (height <= cal_max_height and height >= cal_min_height): for i in range(0, len(strapping_table_list) - 1): if (height >= strapping_table_list[i][0] and height <= strapping_table_list[i+1][0]): lower_cal = strapping_table_list[i] upper_cal = strapping_table_list[i+1] elif height > cal_max_height: lower_cal = strapping_table_list[-2] upper_cal = strapping_table_list[-1] elif height < cal_min_height: lower_cal = strapping_table_list[0] upper_cal = strapping_table_list[1] line_m = (float(upper_cal[1]) - float(lower_cal[1])) / (float(upper_cal[0]) - float(lower_cal[0])) line_b = float(upper_cal[1]) - line_m * float(upper_cal[0]) return line_m * height + line_b except Exception as e: print("Error in get_volume_for_height: {}".format(e)) return 0.0 def pondlevel_setrawmin(self, name, value): """Set the raw min scaling value.""" self.PL_RAWMIN = float(value) self.sendtodb("setrawmin", self.PL_RAWMIN, 0) self.store_scaling_data() return(True) def pondlevel_setrawmax(self, name, value): """Set the raw max scaling value.""" self.PL_RAWMAX = float(value) self.sendtodb("setrawmax", self.PL_RAWMAX, 0) self.store_scaling_data() return(True) def pondlevel_seteumin(self, name, value): """Set the gpm min scaling value.""" self.PL_EUMIN = float(value) self.sendtodb("seteumin", self.PL_EUMIN, 0) self.store_scaling_data() return(True) def pondlevel_seteumax(self, name, value): """Set the gpm max scaling value.""" self.PL_EUMAX = float(value) self.sendtodb("seteumax", self.PL_EUMAX, 0) self.store_scaling_data() return(True) def pondlevel_setpsirawmin(self, name, value): """Set the raw min pressure scaling value.""" self.PSI_RAWMIN = float(value) self.sendtodb("setpsirawmin", self.PSI_RAWMIN, 0) self.store_scaling_data() return(True) def pondlevel_setpsirawmax(self, name, value): """Set the raw max pressure scaling value.""" self.PSI_RAWMAX = float(value) self.sendtodb("setpsirawmax", self.PSI_RAWMAX, 0) self.store_scaling_data() return(True) def pondlevel_setpsieumin(self, name, value): """Set the psi min pressure scaling value.""" self.PSI_EUMIN = float(value) self.sendtodb("setpsieumin", self.PSI_EUMIN, 0) self.store_scaling_data() return(True) def pondlevel_setpsieumax(self, name, value): """Set the psi max pressure scaling value.""" self.PSI_EUMAX = float(value) self.sendtodb("setpsieumax", self.PSI_EUMAX, 0) self.store_scaling_data() return(True)