Added report generator for thingsboard

meshifyDrivers/advvfdipp/Channel.py

@@ -0,0 +1,301 @@
+"""Define Meshify channel class."""
+import time
+import urllib
+from pycomm.ab_comm.clx import Driver as ClxDriver
+from pycomm.cip.cip_base import CommError, DataError
+from file_logger import filelogger as log
+
+
+
+TAG_DATAERROR_SLEEPTIME = 5
+
+def binarray(intval):
+    """Split an integer into its bits."""
+    bin_string = '{0:08b}'.format(intval)
+    bin_arr = [i for i in bin_string]
+    bin_arr.reverse()
+    return bin_arr
+
+
+def read_tag(addr, tag, plc_type="CLX"):
+    """Read a tag from the PLC."""
+    direct = plc_type == "Micro800"
+    clx = ClxDriver()
+    try:
+        if clx.open(addr, direct_connection=direct):
+            try:
+                val = clx.read_tag(tag)
+                clx.close()
+                return val
+            except DataError as err:
+                clx.close()
+                time.sleep(TAG_DATAERROR_SLEEPTIME)
+                log.error("Data Error during readTag({}, {}): {}".format(addr, tag, err))
+    except CommError:
+        # err = c.get_status()
+        clx.close()
+        log.error("Could not connect during readTag({}, {})".format(addr, tag))
+    except AttributeError as err:
+        clx.close()
+        log.error("AttributeError during readTag({}, {}): \n{}".format(addr, tag, err))
+    clx.close()
+    return False
+
+
+def read_array(addr, tag, start, end, plc_type="CLX"):
+    """Read an array from the PLC."""
+    direct = plc_type == "Micro800"
+    clx = ClxDriver()
+    if clx.open(addr, direct_connection=direct):
+        arr_vals = []
+        try:
+            for i in range(start, end):
+                tag_w_index = tag + "[{}]".format(i)
+                val = clx.read_tag(tag_w_index)
+                arr_vals.append(round(val[0], 4))
+            if arr_vals:
+                clx.close()
+                return arr_vals
+            else:
+                log.error("No length for {}".format(addr))
+                clx.close()
+                return False
+        except Exception:
+            log.error("Error during readArray({}, {}, {}, {})".format(addr, tag, start, end))
+            err = clx.get_status()
+            clx.close()
+            log.error(err)
+        clx.close()
+
+
+def write_tag(addr, tag, val, plc_type="CLX"):
+    """Write a tag value to the PLC."""
+    direct = plc_type == "Micro800"
+    clx = ClxDriver()
+    try:
+        if clx.open(addr, direct_connection=direct):
+            try:
+                initial_val = clx.read_tag(tag)
+                write_status = clx.write_tag(tag, val, initial_val[1])
+                clx.close()
+                return write_status
+            except DataError as err:
+                clx_err = clx.get_status()
+                clx.close()
+                log.error("--\nDataError during writeTag({}, {}, {}, plc_type={}) -- {}\n{}\n".format(addr, tag, val, plc_type, err, clx_err))
+
+    except CommError as err:
+        clx_err = clx.get_status()
+        log.error("--\nCommError during write_tag({}, {}, {}, plc_type={})\n{}\n--".format(addr, tag, val, plc_type, err))
+        clx.close()
+    return False
+
+
+class Channel(object):
+    """Holds the configuration for a Meshify channel."""
+
+    def __init__(self, mesh_name, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+        """Initialize the channel."""
+        self.mesh_name = mesh_name
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+
+    def __str__(self):
+        """Create a string for the channel."""
+        return "{}\nvalue: {},  last_send_time: {}".format(self.mesh_name, self.value, self.last_send_time)
+
+    def check(self, new_value, force_send=False):
+        """Check to see if the new_value needs to be stored."""
+        send_needed = False
+        send_reason = ""
+        if self.data_type == 'BOOL' or self.data_type == 'STRING':
+            if self.last_send_time == 0:
+                send_needed = True
+                send_reason = "no send time"
+            elif self.value is None:
+                send_needed = True
+                send_reason = "no value"
+            elif self.value != new_value:
+                if self.map_:
+                    if not self.value == self.map_[new_value]:
+                        send_needed = True
+                        send_reason = "value change"
+                    elif force_send:
+                        send_needed = True
+                        send_reason = "forced"
+                else:
+                    send_needed = True
+                    send_reason = "value change"
+            elif (time.time() - self.last_send_time) > self.guarantee_sec:
+                send_needed = True
+                send_reason = "guarantee sec"
+            elif force_send:
+                send_needed = True
+                send_reason = "forced"
+        else:
+            if self.last_send_time == 0:
+                send_needed = True
+                send_reason = "no send time"
+            elif self.value is None:
+                send_needed = True
+                send_reason = "no value"
+            elif abs(self.value - new_value) > self.chg_threshold:
+                send_needed = True
+                send_reason = "change threshold"
+            elif (time.time() - self.last_send_time) > self.guarantee_sec:
+                send_needed = True
+                send_reason = "guarantee sec"
+            elif force_send:
+                send_needed = True
+                send_reason = "forced"
+        if send_needed:
+            self.last_value = self.value
+            if self.map_:
+                try:
+                    self.value = self.map_[new_value]
+                except KeyError:
+                    log.error("Cannot find a map value for {} in {} for {}".format(new_value, self.map_, self.mesh_name))
+                    self.value = new_value
+            else:
+                self.value = new_value
+            self.last_send_time = time.time()
+            log.info("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+        return send_needed
+
+    def read(self):
+        """Read the value."""
+        pass
+
+
+def identity(sent):
+    """Return exactly what was sent to it."""
+    return sent
+
+
+class ModbusChannel(Channel):
+    """Modbus channel object."""
+
+    def __init__(self, mesh_name, register_number, data_type, chg_threshold, guarantee_sec, channel_size=1, map_=False, write_enabled=False, transform_fn=identity):
+        """Initialize the channel."""
+        super(ModbusChannel, self).__init__(mesh_name, data_type, chg_threshold, guarantee_sec, map_, write_enabled)
+        self.mesh_name = mesh_name
+        self.register_number = register_number
+        self.channel_size = channel_size
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+        self.transform_fn = transform_fn
+
+    def read(self, mbsvalue):
+        """Return the transformed read value."""
+        return self.transform_fn(mbsvalue)
+
+
+class PLCChannel(Channel):
+    """PLC Channel Object."""
+
+    def __init__(self, ip, mesh_name, plc_tag, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False, plc_type='CLX'):
+        """Initialize the channel."""
+        super(PLCChannel, self).__init__(mesh_name, data_type, chg_threshold, guarantee_sec, map_, write_enabled)
+        self.plc_ip = ip
+        self.mesh_name = mesh_name
+        self.plc_tag = plc_tag
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+        self.plc_type = plc_type
+
+    def read(self):
+        """Read the value."""
+        plc_value = None
+        if self.plc_tag and self.plc_ip:
+            read_value = read_tag(self.plc_ip, self.plc_tag, plc_type=self.plc_type)
+            if read_value:
+                plc_value = read_value[0]
+
+        return plc_value
+
+
+class BoolArrayChannels(Channel):
+    """Hold the configuration for a set of boolean array channels."""
+
+    def __init__(self, ip, mesh_name, plc_tag, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+        """Initialize the channel."""
+        super(BoolArrayChannels, self).__init__(mesh_name, data_type, chg_threshold, guarantee_sec, map_, write_enabled)
+        self.plc_ip = ip
+        self.mesh_name = mesh_name
+        self.plc_tag = plc_tag
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+
+    def compare_values(self, new_val_dict):
+        """Compare new values to old values to see if the values need storing."""
+        send = False
+        for idx in new_val_dict:
+            try:
+                if new_val_dict[idx] != self.last_value[idx]:
+                    send = True
+            except KeyError:
+                log.error("Key Error in self.compare_values for index {}".format(idx))
+                send = True
+        return send
+
+    def read(self, force_send=False):
+        """Read the value and check to see if needs to be stored."""
+        send_needed = False
+        send_reason = ""
+        if self.plc_tag:
+            val = read_tag(self.plc_ip, self.plc_tag)
+            if val:
+                bool_arr = binarray(val[0])
+                new_val = {}
+                for idx in self.map_:
+                    try:
+                        new_val[self.map_[idx]] = bool_arr[idx]
+                    except KeyError:
+                        log.error("Not able to get value for index {}".format(idx))
+
+                if self.last_send_time == 0:
+                    send_needed = True
+                    send_reason = "no send time"
+                elif self.value is None:
+                    send_needed = True
+                    send_reason = "no value"
+                elif self.compare_values(new_val):
+                    send_needed = True
+                    send_reason = "value change"
+                elif (time.time() - self.last_send_time) > self.guarantee_sec:
+                    send_needed = True
+                    send_reason = "guarantee sec"
+                elif force_send:
+                    send_needed = True
+                    send_reason = "forced"
+
+                if send_needed:
+                    self.value = new_val
+                    self.last_value = self.value
+                    self.last_send_time = time.time()
+                    log.info("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+        return send_needed

meshifyDrivers/advvfdipp/Tags.py

@@ -0,0 +1,49 @@
+from Channel import PLCChannel, ModbusChannel
+from advvfdipp import PLC_IP_ADDRESS
+
+tags = [ 
+	PLCChannel(PLC_IP_ADDRESS, "flowrate","val_Flowmeter","REAL", 300, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "fluidlevel","val_FluidLevel","REAL", 2, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "intakepressure","val_IntakePressure","REAL", 10, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "intaketemperature","val_IntakeTemperature","REAL", 5, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "tubingpressure","val_TubingPressure","REAL", 10, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "pidcontrolmode","sts_PID_Control","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "wellstatus","Device_Status_INT","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "vfdfrequency","VFD_SpeedFdbk","REAL", 5, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "flowtotal","Flow_Total[0]","REAL", 100, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "energytotal","Energy_Total[0]","REAL", 10, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "vfdcurrent","VFD_OutCurrent","REAL", 5, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "downholesensorstatus","Downhole_Sensor_Status_INT","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "fluidspecificgravity","cfg_FluidSpecificGravity","REAL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "flowtotalyesterday","Flow_Total[1]","REAL", 100, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "energytotalyesterday","Energy_Total[1]","REAL", 10, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmflowrate","alarm_Flowmeter","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmintakepressure","alarm_IntakePressure","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmintaketemperature","alarm_IntakeTemperature","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmtubingpressure","alarm_TubingPressure","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmvfd","alarm_VFD","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmlockout","alarm_Lockout","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "runpermissive","Run_Permissive_INT","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "startpermissive","Start_Permissive_INT","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "startcommand","cmd_Start","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "stopcommand","cmd_Stop","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "flowsetpoint","cfg_PID_FlowSP","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "fluidlevelsetpoint","cfg_PID_FluidLevelSP","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "manualfrequencysetpoint","cfg_PID_ManualSP","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "tubingpressuresetpoint","cfg_PID_TubingPressureSP","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmfluidlevel","alarm_FluidLevel","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "pressureshutdownlimit","AIn_IntakePressure.Val_LoLim","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "pressurestartuplimit","AIn_IntakePressure.Val_HiLim","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "temperatureshutdownlimit","AIn_IntakeTemperature.Val_HiLim","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "temperaturestartuplimit","AIn_IntakeTemperature.Val_LoLim","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "sensorheight","cfg_DHSensorDistToIntake","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "last_vfd_fault_code","PowerFlex755.Val_LastFaultCode","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "vfd_fault","sts_CurrentVFDFaultCode","INT", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "controllerfault_io","ControllerFault_IO","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "controllerfault_program","ControllerFault_Program","BOOL", 1, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "minvfdfrequency","PowerFlex755.Cfg_MinSpdRef","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "maxvfdfrequency","PowerFlex755.Cfg_MaxSpdRef","REAL", 1, 86400, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "hartnettotal","in_HART_Flowmeter_Net","REAL", 100, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "hartfwdtotal","in_HART_Flowmeter_Fwd","REAL", 100, 3600, plc_type="CLX"),
+	PLCChannel(PLC_IP_ADDRESS, "hartrevtotal","in_HART_Flowmeter_Rev","REAL", 100, 3600, plc_type="CLX")
+]

meshifyDrivers/advvfdipp/advvfdipp.py

@@ -0,0 +1,264 @@
+"""Driver for advvfdipp"""
+
+import threading
+import json
+import os
+import time
+from random import randint
+from datetime import datetime as dt
+# PERSISTENCE FILE
+import persistence
+PERSIST = persistence.load("extra_data.json")
+if not PERSIST:
+    PERSIST = {'ip_address': '192.168.1.10', 'download_pycomm': True, 'flowmeter_units': 'GPM'}
+    persistence.store(PERSIST, "extra_data.json")
+    os.system('echo "" > /root/python_firmware/drivers/modbusMap.p')
+PLC_IP_ADDRESS = PERSIST['ip_address']
+from device_base import deviceBase
+import urllib
+if PERSIST['download_pycomm']:
+    try:
+        urllib.urlretrieve('http://s3.amazonaws.com/pocloud-drivers/pycomm/clx.py', '/root/python_firmware/pycomm/ab_comm/clx.py')
+        urllib.urlretrieve('http://s3.amazonaws.com/pocloud-drivers/pycomm/cip_base.py', '/root/python_firmware/pycomm/cip/cip_base.py')
+        PERSIST['download_pycomm'] = False
+        persistence.store(PERSIST, "extra_data.json")
+    except Exception as e:
+        print("Could not download latest pycomm update: {}".format(e))
+
+from Channel import PLCChannel, ModbusChannel,read_tag, write_tag, TAG_DATAERROR_SLEEPTIME
+from utilities import get_public_ip_address, get_private_ip_address, get_additional_tags, convert_int
+from file_logger import filelogger as log
+from Tags import tags
+from runtimeStats import RuntimeStats as RTS
+
+path = "/root/python_firmware/drivers/additional_tags.py"
+
+f = open(path, "a+")
+f.seek(0)
+if os.stat(path).st_size == 0:
+    f.write("from Channel import PLCChannel, ModbusChannel\n")
+    f.write("from advvfdipp import PLC_IP_ADDRESS\n")
+    f.write("additional_tags = []")
+f.close()
+
+
+from additional_tags import additional_tags
+
+_ = None
+
+log.info("advvfdipp startup")
+
+# GLOBAL VARIABLES
+WAIT_FOR_CONNECTION_SECONDS = 30
+IP_CHECK_PERIOD = 60
+WATCHDOG_ENABLE = False
+WATCHDOG_CHECK_PERIOD = 60
+WATCHDOG_SEND_PERIOD = 3600  # Seconds, the longest amount of time before sending the watchdog status
+
+CHANNELS = tags + additional_tags
+
+
+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 = "18"
+        self.finished = threading.Event()
+        self.force_send = False
+        self.public_ip_address = ""
+        self.public_ip_address_last_checked = 0
+        self.watchdog = False
+        self.watchdog_last_checked = 0
+        self.watchdog_last_sent = 0
+        self.ping_counter = 0
+        self.rts = RTS()
+        self.rts.loadDataFromFile()
+        self.rts.saveDataToFile()
+        self.rts.manageTime()
+        self.today = dt.now().date()
+        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."""
+        for i in range(0, WAIT_FOR_CONNECTION_SECONDS):
+            print("advvfdipp driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
+            time.sleep(1)
+        log.info("BOOM! Starting advvfdipp driver...")
+
+        
+        #self._check_watchdog()
+        self._check_ip_address()
+
+        self.nodes["advvfdipp_0199"] = self
+        try:
+            if PERSIST['flowmeter_units']:
+                self.sendtodbDev(1, 'flowunits', PERSIST['flowmeter_units'], 0, 'advvfdipp')
+            else:
+                PERSIST['flowmeter_units'] = "GPM"
+                persistence.store(PERSIST, "extra_data.json")
+                self.sendtodbDev(1, 'flowunits', PERSIST['flowmeter_units'], 0, 'advvfdipp')
+        except:
+            PERSIST['flowmeter_units'] = "GPM"
+            persistence.store(PERSIST, "extra_data.json")
+            self.sendtodbDev(1, 'flowunits', PERSIST['flowmeter_units'], 0, 'advvfdipp')
+        send_loops = 0
+        convert_list = ["Device_Status_INT","sts_PID_Control","Downhole_Sensor_Status_INT","alarm_Flowmeter","alarm_IntakePressure",
+            "alarm_IntakeTemperature","alarm_TubingPressure","alarm_VFD","alarm_Lockout","alarm_FluidLevel","Run_Permissive_INT",
+            "Start_Permissive_INT","PowerFlex755.Val_LastFaultCode","sts_CurrentVFDFaultCode"]
+        while True:
+            now = time.time()
+            if self.force_send:
+                log.warning("FORCE SEND: TRUE")
+            if int(time.time()) % 600 == 0 or self.force_send:
+                if self.force_send:
+                    payload = {"ts": time.time()*1000, "values": {}}
+                else:
+                    payload = {"ts": round(time.time()/600)*600*1000, "values": {}}
+                for chan in CHANNELS:
+                    try:
+                        val = chan.read()
+                        if "hart" in chan.mesh_name and val == None:
+                            val = 0.0
+                        
+                        if chan.plc_tag in convert_list:
+                            converted_value = convert_int(chan.plc_tag, val)
+                            payload["values"][chan.mesh_name] = converted_value
+                            if chan.mesh_name == "wellstatus":
+                                if converted_value == "Running" and not self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["start"]:
+                                    self.rts.startRun()
+                                    self.rts.saveDataToFile()
+                                elif self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["start"] and not self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["end"]:
+                                    self.rts.endRun()
+                                    self.rts.saveDataToFile()
+                                payload["values"]["percentRunTime30Days"] = self.rts.calculateRunPercentMultiDay()
+                        elif chan.mesh_name == "vfdfrequency":
+                            if val > 0:
+                                self.rts.addHertzDataPoint(val)
+                                self.rts.saveDataToFile()
+                            payload["values"][chan.mesh_name] = val
+                            payload["values"]["avgFrequency30Days"] = self.rts.calculateAverageHertzMultiDay()
+                        else:
+                            payload["values"][chan.mesh_name] = val
+                    except Exception as e:
+                        log.info("Error: {}".format(e))
+                try:
+                    self.rts.manageTime()
+                    if dt.now().date() != self.today:
+                        payload["values"]["avgFrequency30Days"] = self.rts.calculateAverageHertzMultiDay()
+                        payload["values"]["percentRunTime30Days"] = self.rts.calculateRunPercentMultiDay()
+                        self.today = dt.now().date()
+                except Exception as e:
+                    log.error("Error: {}".format(e))
+                self._check_ip_address()
+                payload["values"]["public_ip_address"] = self.public_ip_address 
+                payload["values"]["private_ip_address"] = self.private_ip_address
+                self.sendToTB(json.dumps(payload))
+                self.sendToTBAttributes(json.dumps({"latestReportTime": round(time.time()/600)*600*1000}))
+            time.sleep(10) #sleep for 30 seconds after a full poll
+            # print("advvfdipp 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 WATCHDOG_ENABLE:
+                if (now - self.watchdog_last_checked) > WATCHDOG_CHECK_PERIOD:
+                    self._check_watchdog()
+
+            if (now - self.public_ip_address_last_checked) > IP_CHECK_PERIOD:
+                self._check_ip_address()
+
+    def _check_watchdog(self):
+        """Check the watchdog and send to Meshify if changed or stale."""
+        test_watchdog = self.advvfdipp_watchdog()
+        now = time.time()
+        self.watchdog_last_checked = now
+        if test_watchdog != self.watchdog or (now - self.watchdog_last_sent) > WATCHDOG_SEND_PERIOD:
+            self.sendtodbDev(1, 'watchdog', test_watchdog, 0, 'advvfdipp')
+            self.watchdog = test_watchdog
+            self.watchdog_last_sent = now
+
+
+    def _check_ip_address(self):
+        """Check the public IP address and send to Meshify if changed."""
+        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.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, 'tankalarms')
+            self.public_ip_address = test_public_ip
+        if not test_private_ip == self.private_ip_address:
+            #self.sendtodbDev(1, 'private_ip_address', test_private_ip, 0, 'tankalarms')
+            self.private_ip_address = test_private_ip
+        hostname = "8.8.8.8"
+        response = 1 
+        try:
+            response = os.system("ping -c 1 " + hostname + " > /dev/null 2>&1")
+        except Exception as e:
+            print("Something went wrong in ping: {}".format(e))
+
+        #and then check the response...
+        if response == 0:
+            print(hostname, 'is up!')
+            self.ping_counter = 0
+        else:
+            print(hostname, 'is down!')
+            self.ping_counter += 1
+    
+        if self.ping_counter >= 3:
+            print("Rebooting because no internet detected")
+            os.system('reboot')
+        
+
+    def advvfdipp_watchdog(self):
+        """Write a random integer to the PLC and then 1 seconds later check that it has been decremented by 1."""
+        randval = randint(0, 32767)
+        write_tag(str(PLC_IP_ADDRESS), 'watchdog_INT', randval, plc_type="CLX")
+        time.sleep(1)
+        watchdog_val = read_tag(str(PLC_IP_ADDRESS), 'watchdog_INT', plc_type="CLX")
+        try:
+            return (randval - 1) == watchdog_val[0]
+        except (KeyError, TypeError):
+            return False
+
+    def advvfdipp_sync(self, name, value):
+        """Sync all data from the driver."""
+        self.force_send = True
+        # self.sendtodb("log", "synced", 0)
+        return True
+
+    def advvfdipp_writeplctag(self, name, value):
+        """Write a value to the PLC."""
+        new_val = json.loads(str(value).replace("'", '"'))
+        tag_n = str(new_val['tag'])  # "cmd_Start"
+        val_n = new_val['val']
+        write_res = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n, plc_type="CLX")
+        print("Result of advvfdipp_writeplctag(self, {}, {}) = {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+
+    def advvfdipp_flowunits(self, name, value):
+        new_val = json.loads(str(value).replace("'", '"'))
+        PERSIST['flowmeter_units'] = new_val
+        persistence.store(PERSIST, "extra_data.json")
+        self.sendtodbDev(1, 'flowunits', PERSIST['flowmeter_units'], 0, 'advvfdipp')

meshifyDrivers/advvfdipp/config.txt

@@ -0,0 +1,15 @@
+{
+    "files": {
+        "file3": "file_logger.py", 
+        "file2": "Channel.py", 
+        "file1": "advvfdipp.py", 
+        "file6": "persistence.py", 
+        "file5": "utilities.py", 
+        "file4": "Tags.py",
+        "file5": "runtimeStats.py"
+    }, 
+    "deviceName": "advvfdipp", 
+    "releaseVersion": "19", 
+    "driverFileName": "advvfdipp.py", 
+    "driverId": "0100"
+}

meshifyDrivers/advvfdipp/device_base.py

@@ -0,0 +1,205 @@
+import types
+import traceback
+import binascii
+import threading
+import time
+import thread
+import os
+import struct
+import sys
+import textwrap
+
+class deviceBase():
+
+    def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None, companyId=None, offset=None, mqtt=None, Nodes=None):
+        self.offset = offset
+        self.company = companyId
+        self.name = name
+        self.number = number 
+        self.q = Q
+        self.deviceName = name + '_[' + mac +  ':' + number[0:2] + ':' + number[2:] + ']!'
+        self.chName = "M1" + '_[' + mac + ':'
+        self.chName2 = '_[' + mac + ':'
+        print 'device name is:'
+        print self.deviceName
+        mac2 = mac.replace(":", "")
+        self.mac = mac2.upper()
+        self.address = 1
+        self.debug = True
+        self.mcu = mcu
+        self.firstRun = True
+        self.mqtt = mqtt
+        self.nodes = Nodes
+        #local dictionary of derived nodes ex: localNodes[tank_0199] = self
+        self.localNodes = {}
+        os.system("chmod 777 /root/reboot")
+        os.system("echo nameserver 8.8.8.8 > /etc/resolv.conf")
+        
+        
+    def sendtodbLoc(self, ch, channel, value, timestamp, deviceName, mac):
+
+
+        #this will add your derived nodes the master nodes list, allowing them to receive sets!!
+        localNodesName = deviceName + "_" + str(ch) + "99"
+
+        if not self.localNodes.has_key(localNodesName):
+            self.localNodes[localNodesName] = True
+            self.nodes[localNodesName] = self
+
+        #make the techname 
+        lst = textwrap.wrap(str(mac), width=2)
+        tech = ""
+        for i in range(len(lst)):
+            tech += lst[i].lower() + ":"
+        
+
+        chName2 = '_[' + tech 
+
+        if int(ch) < 10:
+            ch = "0" + str(int(ch))
+
+        if len(ch) > 2:
+            ch = ch[:-2]
+
+        dname = deviceName + chName2 + str(ch) + ":98]!"
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, mac, dname, channel)
+        print topic
+        msg = """[ { "value":"%s", "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+
+    def sendtodbDevJSON(self, ch, channel, value, timestamp, deviceName):
+
+        if int(ch) < 10:
+            ch = "0" + str(int(ch))
+        dname = deviceName + self.chName2 + str(ch) + ":99]!"
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, dname, channel)
+        print topic
+        msg = """[ { "value":%s, "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+
+    def sendtodbLora(self, ch, channel, value, timestamp, deviceName):
+
+        if ":" not in ch:
+            ch = ch[0:2] + ":" + ch[2:4]
+
+        #this will add your derived nodes the master nodes list, allowing them to receive sets!!
+        localNodesName = deviceName + "_" + str(ch).replace(':', "")
+
+        if not self.localNodes.has_key(localNodesName):
+            self.localNodes[localNodesName] = True
+            self.nodes[localNodesName] = self
+
+        
+
+        dname = deviceName + self.chName2 + str(ch) + "]!"
+
+        
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, dname, channel)
+        print topic
+        msg = """[ { "value":"%s", "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+        
+    def sendtodbDev(self, ch, channel, value, timestamp, deviceName):
+
+
+        #this will add your derived nodes the master nodes list, allowing them to receive sets!!
+        localNodesName = deviceName + "_" + str(ch) + "99"
+
+        if not self.localNodes.has_key(localNodesName):
+            self.localNodes[localNodesName] = True
+            self.nodes[localNodesName] = self
+
+        if int(ch) < 10:
+            ch = "0" + str(int(ch))
+
+        dname = deviceName + self.chName2 + str(ch) + ":99]!"
+
+        
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, dname, channel)
+        print topic
+        msg = """[ { "value":"%s", "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+
+    def sendToTB(self, payload):
+        topic = 'v1/devices/me/telemetry'
+        print(topic, payload)
+        self.q.put([topic, payload, 0])
+    
+    def sendToTBAttributes(self, payload):
+        topic = 'v1/devices/me/attributes'
+        print(topic, payload)
+        self.q.put([topic, payload, 0])
+
+    def sendtodbCH(self, ch, channel, value, timestamp):
+
+
+        if int(ch) < 10:
+            ch = "0" + str(ch)
+
+        dname = self.chName + str(ch) + ":99]!"
+
+        
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, dname, channel)
+        print topic
+        msg = """[ { "value":"%s", "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+    
+    def sendtodb(self, channel, value, timestamp):
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+            if timestamp < 1400499858:
+                return
+        else:
+            timestamp =  str(int(timestamp) + int(self.offset))
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, self.deviceName, channel)
+        print topic
+        msg = """[ { "value":"%s", "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+    
+    def sendtodbJSON(self, channel, value, timestamp):
+
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+            if timestamp < 1400499858:
+                return
+        else:
+            timestamp =  str(int(timestamp) + int(self.offset))
+        
+        topic = 'meshify/db/%s/%s/%s/%s' % (self.company, self.mac, self.deviceName, channel)
+        print topic
+        msg = """[ { "value":%s, "timestamp":"%s" } ]""" % (str(value), str(timestamp))
+        print msg
+        self.q.put([topic, msg, 0])
+    def getTime(self):
+        return str(int(time.time() + int(self.offset)))
+
+
+
+

meshifyDrivers/advvfdipp/driverConfig.json

@@ -0,0 +1,14 @@
+{
+    "name": "advvfdipp",
+    "driverFilename": "advvfdipp.py",
+    "driverId": "0000",
+    "additionalDriverFiles": [
+        "utilities.py",
+        "persistence.py",
+        "Channel.py",
+        "logger.py",
+        "Tags.py"
+    ],
+    "version": 1,
+    "s3BucketName": "advvfdipp"
+}

meshifyDrivers/advvfdipp/file_logger.py

@@ -0,0 +1,18 @@
+"""Logging setup for advvfdipp"""
+import logging
+from logging.handlers import RotatingFileHandler
+import sys
+
+log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
+log_file = './advvfdipp.log'
+my_handler = RotatingFileHandler(log_file, mode='a', maxBytes=500*1024,
+                                 backupCount=2, encoding=None, delay=0)
+my_handler.setFormatter(log_formatter)
+my_handler.setLevel(logging.INFO)
+filelogger = logging.getLogger('advvfdipp')
+filelogger.setLevel(logging.INFO)
+filelogger.addHandler(my_handler)
+
+console_out = logging.StreamHandler(sys.stdout)
+console_out.setFormatter(log_formatter)
+filelogger.addHandler(console_out)

meshifyDrivers/advvfdipp/persistence.py

@@ -0,0 +1,21 @@
+"""Data persistance functions."""
+# if more advanced persistence is needed, use a sqlite database
+import json
+
+
+def load(filename="persist.json"):
+    """Load persisted settings from the specified file."""
+    try:
+        with open(filename, 'r') as persist_file:
+            return json.load(persist_file)
+    except Exception:
+        return False
+
+
+def store(persist_obj, filename="persist.json"):
+    """Store the persisting settings into the specified file."""
+    try:
+        with open(filename, 'w') as persist_file:
+            return json.dump(persist_obj, persist_file, indent=4)
+    except Exception:
+        return False

meshifyDrivers/advvfdipp/runtimeStats.py

@@ -0,0 +1,172 @@
+from datetime import datetime as dt
+import time
+import json
+import math
+
+class RuntimeStats:
+    
+    def __init__(self):
+        self.runs = {}
+        self.currentRun = 0
+        self.today = ""
+        self.todayString = ""
+
+    def manageTime(self):
+        if self.todayString != dt.strftime(dt.today(), "%Y-%m-%d"):
+            if self.runs[self.todayString]["run_" + str(self.currentRun)]["start"] and not self.runs[self.todayString]["run_" + str(self.currentRun)]["end"]:
+                self.runs[self.todayString]["run_" + str(self.currentRun)]["end"] = time.mktime(dt.strptime(self.todayString + " 23:59:59", "%Y-%m-%d %H:%M:%S").timetuple())
+            self.addDay()
+            self.today = dt.today()
+            self.todayString = dt.strftime(self.today, "%Y-%m-%d")
+            days = list(self.runs.keys())
+            days.sort()
+            while (dt.strptime(days[-1],"%Y-%m-%d") - dt.strptime(days[0], "%Y-%m-%d")).days > 30:
+                self.removeDay(day=days[0])
+                days = list(self.runs.keys())
+                days.sort()
+
+    def addHertzDataPoint(self, frequency):
+        if frequency > 0:
+            self.manageTime()
+            try:
+                self.runs[self.todayString]["run_" + str(self.currentRun)]["frequencies"].append(frequency)
+            except:
+                self.runs[self.todayString]["run_" + str(self.currentRun)]["frequencies"] = [frequency]
+
+    def startRun(self):
+        if self.checkRunning():
+            self.endRun()
+        self.runs[self.todayString]["run_" + str(self.currentRun)]["start"] = time.time()
+
+    def endRun(self):
+        self.runs[self.todayString]["run_" + str(self.currentRun)]["end"] = time.time()
+        self.currentRun += 1
+        self.runs[self.todayString]["run_" + str(self.currentRun)] = {"start":0, "end": 0, "frequencies":[]}    
+
+    def checkRunning(self):
+        if self.runs[self.todayString]["run_" + str(self.currentRun)]["start"] and not self.runs[self.todayString]["run_" + str(self.currentRun)]["end"]:
+            return True
+        return False
+
+    def addDay(self):
+        self.today = dt.today()
+        self.todayString = dt.strftime(self.today, "%Y-%m-%d")
+        self.currentRun = 1
+        self.runs[self.todayString] = {}
+        self.runs[self.todayString]["run_" + str(self.currentRun)] = {"start":0, "end": 0, "frequencies":[]}
+
+    def countRunsDay(self, day=None):
+        if not day:
+            day = self.todayString
+        return len(self.runs[day].keys())
+
+    def countRunsMultiDay(self, numDays=30):
+        total_runs = 0
+        for day in list(self.runs.keys()):
+            total_runs += self.countRunsDay(day=day)
+        return total_runs
+
+    def calculateAverageHertzDay(self, day=None, returnArray=False):
+        dayFrequencies = []
+        if not day:
+            day = self.todayString
+        for run in list(self.runs[day].keys()):
+            try:
+                dayFrequencies += self.runs[day][run]["frequencies"]
+            except Exception as e:
+                print("{} missing frequency data for {}".format(day,run))
+        if returnArray:
+            return dayFrequencies
+        return round(math.fsum(dayFrequencies)/len(dayFrequencies),2)
+
+    def calculateAverageHertzMultiDay(self, numDays=30):
+        self.manageTime()
+        frequencies = []
+        for day in list(self.runs.keys()):
+            if not day == self.todayString and (dt.strptime(self.todayString, "%Y-%m-%d") - dt.strptime(day, "%Y-%m-%d")).days <= numDays:
+                try:
+                    frequencies += self.calculateAverageHertzDay(day=day, returnArray=True)
+                except Exception as e:
+                    print("{} missing frequency data".format(day))
+        if len(frequencies):
+            return round(math.fsum(frequencies)/len(frequencies), 2)
+        return 0
+    
+    def calculateRunTimeDay(self, day=None, convertToHours=True):
+        total_time = 0
+        if not day:
+            day = self.todayString
+        for run in list(self.runs[day].keys()):
+            total_time = self.runs[day][run]["end"] - self.runs[day][run]["start"] + total_time
+        if convertToHours:
+            return self.convertSecondstoHours(total_time)
+        return total_time
+
+    def calculateRunTimeMultiDay(self, numDays=30, convertToHours=True):
+        total_time = 0
+        for day in list(self.runs.keys()):
+            if not day == self.todayString and (dt.strptime(self.todayString, "%Y-%m-%d") - dt.strptime(day, "%Y-%m-%d")).days <= numDays:
+                total_time += self.calculateRunTimeDay(day=day, convertToHours=False)
+        if convertToHours:
+            return self.convertSecondstoHours(total_time)
+        return total_time
+    
+    def calculateRunPercentDay(self, day=None, precise=False):
+        if not day:
+            day = self.todayString
+        if precise:
+            return (self.calculateRunTimeDay(day=day)/24) * 100
+        return round((self.calculateRunTimeDay(day=day)/24) * 100, 2)
+        
+
+    def calculateRunPercentMultiDay(self, numDays=30, precise=False):
+        self.manageTime()
+        if precise:
+            return (self.calculateRunTimeMultiDay()/(24*numDays)) * 100
+        return round((self.calculateRunTimeMultiDay()/(24*numDays)) * 100,2)
+
+    def removeDay(self, day=None):
+        if not day:
+            raise Exception("Day can not be None")
+        print("removing day {}".format(day))
+        del self.runs[day]
+    
+    def convertSecondstoHours(self, seconds):
+        return round(seconds / (60*60),2)
+
+    def loadDataFromFile(self, filePath="./runtimestats.json"):
+        try:
+            with open(filePath, "r") as f:
+                temp = json.load(f)
+                self.runs = temp["data"]
+                self.currentRun = temp["current_run"]
+                self.today = dt.strptime(temp["current_day"],  "%Y-%m-%d")
+                self.todayString = temp["current_day"]
+                self.manageTime()
+        except:
+            print("Could not find file at {}".format(filePath))
+            print("creating file")
+            self.addDay()
+            try:
+                with open(filePath, "w") as f:
+                    d = {
+                        "current_run": self.currentRun,
+                        "current_day": self.todayString,
+                        "data": self.runs
+                    }
+                    json.dump(d, f, indent=4)
+            except Exception as e:
+                print(e)
+
+    def saveDataToFile(self, filePath="./runtimestats.json"):
+        try:
+            print("Saving Runs")
+            with open(filePath, "w") as f:
+                d = {
+                    "current_run": self.currentRun,
+                    "current_day": self.todayString,
+                    "data": self.runs
+                }
+                json.dump(d, f, indent=4)
+        except Exception as e:
+            print(e)

meshifyDrivers/advvfdipp/utilities.py

@@ -0,0 +1,240 @@
+"""Utility functions for the driver."""
+import socket
+import struct
+from Channel import PLCChannel
+import urllib
+import contextlib
+
+def get_private_ip_address():
+    """Find the private IP Address of the host device."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.connect(("8.8.8.8", 80))
+    except Exception as e:
+        return e
+    ip_address = sock.getsockname()[0]
+    sock.close()
+    return ip_address
+
+def get_public_ip_address():
+    ip_address = "0.0.0.0"
+    try:
+        with contextlib.closing(urllib.urlopen("http://checkip.amazonaws.com")) as url:
+            ip_address = url.read()
+    except Exception as e:
+        print("could not resolve check IP: {}".format(e))
+        return ip_address
+    return ip_address[:-1]
+
+def int_to_float16(int_to_convert):
+    """Convert integer into float16 representation."""
+    bin_rep = ('0' * 16 + '{0:b}'.format(int_to_convert))[-16:]
+    sign = 1.0
+    if int(bin_rep[0]) == 1:
+        sign = -1.0
+    exponent = float(int(bin_rep[1:6], 2))
+    fraction = float(int(bin_rep[6:17], 2))
+
+    if exponent == float(0b00000):
+        return sign * 2 ** -14 * fraction / (2.0 ** 10.0)
+    elif exponent == float(0b11111):
+        if fraction == 0:
+            return sign * float("inf")
+        return float("NaN")
+    frac_part = 1.0 + fraction / (2.0 ** 10.0)
+    return sign * (2 ** (exponent - 15)) * frac_part
+
+
+def ints_to_float(int1, int2):
+    """Convert 2 registers into a floating point number."""
+    mypack = struct.pack('>HH', int1, int2)
+    f_unpacked = struct.unpack('>f', mypack)
+    print("[{}, {}] >> {}".format(int1, int2, f_unpacked[0]))
+    return f_unpacked[0]
+
+
+def degf_to_degc(temp_f):
+    """Convert deg F to deg C."""
+    return (temp_f - 32.0) * (5.0/9.0)
+
+
+def degc_to_degf(temp_c):
+    """Convert deg C to deg F."""
+    return temp_c * 1.8 + 32.0
+
+def get_additional_tags(tag_dict):
+    tags_array = tag_dict['additional_tags']
+    channel_array = []
+    for x in tags_array:
+        try:
+            print "Making channel {}".format(x)
+            channel_array.append(PLCChannel(tag_dict['ip_address'], x['mesh_name'], x['plc_tag'], x['data_type'],x['chg_threshold'],x['guarantee_sec'],plc_type='CLX'))
+        except Exception:
+            print "Nothing to write or bad key" 
+    return channel_array
+
+def convert_int(plc_tag, value):
+    well_status_codes = {
+        0: "Running",
+        1: "Pumped Off",
+        2: "Alarmed",
+        3: "Locked Out",
+        4: "Stopped"
+    }
+
+    pid_control_codes = {
+        0: "Flow",
+        1: "Fluid Level",
+        2: "Tubing Pressure",
+        3: "Manual"
+    }
+
+    downhole_codes = {
+        0: "OK",
+        1: "Connecting",
+        2: "Open Circuit",
+        3: "Shorted",
+        4: "Cannot Decode"
+    }
+
+    permissive_codes = {
+        0: "OK",
+        1: "Flow",
+        2: "Intake Pressure",
+        3: "Intake Temperature",
+        4: "Tubing Pressure",
+        5: "VFD",
+        6: "Fluid Level",
+        7: "Min. Downtime"
+    }
+
+    alarm_codes = {
+        0: "OK",
+        1: "Alarm"
+    }
+
+    alarm_vfd_codes = {
+        0: "OK",
+        1: "Locked Out"
+    }
+
+    vfd_fault_codes = {
+        0: "No Fault",
+        2: "Auxiliary Input",
+        3: "Power Loss",
+        4: "UnderVoltage",
+        5: "OverVoltage",
+        7: "Motor Overload",
+        8: "Heatsink OverTemp",
+        9: "Thermister OverTemp",
+        10: "Dynamic Brake OverTemp",
+        12: "Hardware OverCurrent",
+        13: "Ground Fault",
+        14: "Ground Warning",
+        15: "Load Loss",
+        17: "Input Phase Loss",
+        18: "Motor PTC Trip",
+        19: "Task Overrun",
+        20: "Torque Prove Speed Band",
+        21: "Output Phase Loss",
+        24: "Decel Inhibit",
+        25: "OverSpeed Limit",
+        26: "Brake Slipped",
+        27: "Torque Prove Conflict",
+        28: "TP Encls Confict",
+        29: "Analog In Loss",
+        33: "Auto Restarts Exhausted",
+        35: "IPM OverCurrent",
+        36: "SW OverCurrent",
+        38: "Phase U to Ground",
+        39: "Phase V to Ground",
+        40: "Phase W to Ground",
+        41: "Phase UV Short",
+        42: "Phase VW Short",
+        43: "Phase WU Short",
+        44: "Phase UNeg to Ground",
+        45: "Phase VNeg to Ground",
+        46: "Phase WNeg to Ground",
+        48: "System Defaulted",
+        49: "Drive Powerup",
+        51: "Clear Fault Queue",
+        55: "Control Board Overtemp",
+        59: "Invalid Code",
+        61: "Shear Pin 1",
+        62: "Shear Pin 2",
+        64: "Drive Overload",
+        66: "OW Torque Level",
+        67: "Pump Off",
+        71: "Port 1 Adapter",
+        72: "Port 2 Adapter",
+        73: "Port 3 Adapter",
+        74: "Port 4 Adapter",
+        75: "Port 5 Adapter",
+        76: "Port 6 Adapter",
+        77: "IR Volts Range",
+        78: "FluxAmps Ref Range",
+        79: "Excessive Load",
+        80: "AutoTune Aborted",
+        81: "Port 1 DPI Loss",
+        82: "Port 2 DPI Loss",
+        83: "Port 3 DPI Loss",
+        84: "Port 4 DPI Loss",
+        85: "Port 5 DPI Loss",
+        86: "Port 6 DPI Loss",
+        87: "IXo Voltage Range",
+        91: "Primary Velocity Feedback Loss",
+        93: "Hardware Enable Check",
+        94: "Alternate Velocity Feedback Loss",
+        95: "Auxiliary Velocity Feedback Loss",
+        96: "Position Feedback Loss",
+        97: "Auto Tach Switch",
+        100: "Parameter Checksum",
+        101: "Power Down NVS Blank",
+        102: "NVS Not Blank",
+        103: "Power Down NVS Incompatible",
+        104: "Power Board Checksum",
+        106: "Incompat MCB-PB",
+        107: "Replaced MCB-PB",
+        108: "Analog Calibration Checksum",
+        110: "Invalid Power Board Data",
+        111: "Power Board Invalid ID",
+        112: "Power Board App Min Version",
+        113: "Tracking DataError",
+        115: "Power Down Table Full",
+        116: "Power Down Entry Too Large",
+        117: "Power Down Data Checksum",
+        118: "Power Board Power Down Checksum",
+        124: "App ID Changed",
+        125: "Using Backup App",
+        134: "Start on Power Up",
+        137: "External Precharge Error",
+        138: "Precharge Open",
+        141: "Autotune Enc Angle",
+        142: "Autotune Speed Restricted",
+        143: "Autotune Current Regulator",
+        144: "Autotune Inertia",
+        145: "Autotune Travel",
+        13035: "Net IO Timeout",
+        13037: "Net IO Timeout"
+
+    }
+
+    plc_tags = {
+        "Device_Status_INT": well_status_codes.get(value, "Invalid Code"),
+        "sts_PID_Control": pid_control_codes.get(value, "Invalid Code"),
+        "Downhole_Sensor_Status_INT": downhole_codes.get(value, "Invalid Code"),
+        "alarm_Flowmeter": alarm_codes.get(value, "Invalid Code"),
+        "alarm_IntakePressure": alarm_codes.get(value, "Invalid Code"),
+        "alarm_IntakeTemperature": alarm_codes.get(value, "Invalid Code"),
+        "alarm_TubingPressure": alarm_codes.get(value, "Invalid Code"),
+        "alarm_VFD": alarm_codes.get(value, "Invalid Code"),
+        "alarm_Lockout": alarm_vfd_codes.get(value, "Invalid Code"),
+        "alarm_FluidLevel": alarm_codes.get(value, "Invalid Code"),
+        "Run_Permissive_INT": permissive_codes.get(value, "Invalid Code"),
+        "Start_Permissive_INT": permissive_codes.get(value, "Invalid Code"),
+        "PowerFlex755.Val_LastFaultCode": vfd_fault_codes.get(value, "Invalid Code"),
+        "sts_CurrentVFDFaultCode": vfd_fault_codes.get(value, "Invalid Code")
+    }
+
+    return plc_tags.get(plc_tag, "Invalid Tag")
+