Initial python driver

converted parts from Multi-Pond

POCloud/channels_multisensor.csv

@@ -0,0 +1,42 @@
+id,name,deviceTypeId,fromMe,io,subTitle,helpExplanation,channelType,dataType,defaultValue,regex,regexErrMsg,units,min,max,change,guaranteedReportPeriod,minReportTime
+13902,log,465,FALSE,readwrite,Log,Device Log,device,string,Initialized,,,,,,,,
+,an0val,465,FALSE,readonly,Analog 0 Value,Scaled Value,device,float,0,,,,,,,,
+,an1val,465,FALSE,readonly,Analog 1 Value,Scaled Value,device,float,0,,,,,,,,
+,an2val,465,FALSE,readonly,Analog 2 Value,Scaled Value,device,float,0,,,,,,,,
+,an3val,465,FALSE,readonly,Analog 3 Value,Scaled Value,device,float,0,,,,,,,,
+,an4val,465,FALSE,readonly,Analog 4 Value,Scaled Value,device,float,0,,,,,,,,
+,an5val,465,FALSE,readonly,Analog 5 Value,Scaled Value,device,float,0,,,,,,,,
+,an6val,465,FALSE,readonly,Analog 6 Value,Scaled Value,device,float,0,,,,,,,,
+,an7val,465,FALSE,readonly,Analog 7 Value,Scaled Value,device,float,0,,,,,,,,
+,pond0volume,465,FALSE,readonly,Pond 0 Volume,BBL,device,float,0,,,,,,,,
+,pond1volume,465,FALSE,readonly,Pond 1 Volume,BBL,device,float,0,,,,,,,,
+,pond2volume,465,FALSE,readonly,Pond 2 Volume,BBL,device,float,0,,,,,,,,
+,pond3volume,465,FALSE,readonly,Pond 3 Volume,BBL,device,float,0,,,,,,,,
+,pond4volume,465,FALSE,readonly,Pond 4 Volume,BBL,device,float,0,,,,,,,,
+,pond5volume,465,FALSE,readonly,Pond 5 Volume,BBL,device,float,0,,,,,,,,
+,pond6volume,465,FALSE,readonly,Pond 6 Volume,BBL,device,float,0,,,,,,,,
+,pond7volume,465,FALSE,readonly,Pond 7 Volume,BBL,device,float,0,,,,,,,,
+,an0active,465,FALSE,readonly,Analog 0 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an1active,465,FALSE,readonly,Analog 1 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an2active,465,FALSE,readonly,Analog 2 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an3active,465,FALSE,readonly,Analog 3 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an4active,465,FALSE,readonly,Analog 4 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an5active,465,FALSE,readonly,Analog 5 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an6active,465,FALSE,readonly,Analog 6 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an7active,465,FALSE,readonly,Analog 7 Active,Signal Above 3.0 mA,device,boolean,FALSE,,,,,,,,
+,an0units,465,FALSE,readwrite,Analog 0 Units,Channel Units,user input,string,,,,,,,,,
+,an1units,465,FALSE,readwrite,Analog 1 Units,Channel Units,user input,string,,,,,,,,,
+,an2units,465,FALSE,readwrite,Analog 2 Units,Channel Units,user input,string,,,,,,,,,
+,an3units,465,FALSE,readwrite,Analog 3 Units,Channel Units,user input,string,,,,,,,,,
+,an4units,465,FALSE,readwrite,Analog 4 Units,Channel Units,user input,string,,,,,,,,,
+,an5units,465,FALSE,readwrite,Analog 5 Units,Channel Units,user input,string,,,,,,,,,
+,an6units,465,FALSE,readwrite,Analog 6 Units,Channel Units,user input,string,,,,,,,,,
+,an7units,465,FALSE,readwrite,Analog 7 Units,Channel Units,user input,string,,,,,,,,,
+,an0ispond,465,FALSE,readonly,Analog 0 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an1ispond,465,FALSE,readonly,Analog 1 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an2ispond,465,FALSE,readonly,Analog 2 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an3ispond,465,FALSE,readonly,Analog 3 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an4ispond,465,FALSE,readonly,Analog 4 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an5ispond,465,FALSE,readonly,Analog 5 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an6ispond,465,FALSE,readonly,Analog 6 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,
+,an7ispond,465,FALSE,readonly,Analog 7 Is Pond Level,Use the input for pond level monitoring,device,boolean,FALSE,,,,,,,,

POCloud/python-driver/Channel.py

@@ -0,0 +1,289 @@
+"""Define Meshify channel class."""
+from pycomm.ab_comm.clx import Driver as ClxDriver
+from pycomm.cip.cip_base import CommError, DataError
+import time
+
+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"
+    c = ClxDriver()
+    try:
+        if c.open(addr, direct_connection=direct):
+            try:
+                v = c.read_tag(tag)
+                return v
+            except DataError as e:
+                c.close()
+                time.sleep(TAG_DATAERROR_SLEEPTIME)
+                print("Data Error during readTag({}, {}): {}".format(addr, tag, e))
+    except CommError:
+        # err = c.get_status()
+        c.close()
+        print("Could not connect during readTag({}, {})".format(addr, tag))
+        # print err
+    except AttributeError as e:
+        c.close()
+        print("AttributeError during readTag({}, {}): \n{}".format(addr, tag, e))
+    c.close()
+    return False
+
+
+def read_array(addr, tag, start, end, plc_type="CLX"):
+    """Read an array from the PLC."""
+    direct = plc_type == "Micro800"
+    c = ClxDriver()
+    if c.open(addr, direct_connection=direct):
+        arr_vals = []
+        try:
+            for i in range(start, end):
+                tag_w_index = tag + "[{}]".format(i)
+                v = c.read_tag(tag_w_index)
+                # print('{} - {}'.format(tag_w_index, v))
+                arr_vals.append(round(v[0], 4))
+            # print(v)
+            if len(arr_vals) > 0:
+                return arr_vals
+            else:
+                print("No length for {}".format(addr))
+                return False
+        except Exception:
+            print("Error during readArray({}, {}, {}, {})".format(addr, tag, start, end))
+            err = c.get_status()
+            c.close()
+            print err
+            pass
+        c.close()
+
+
+def write_tag(addr, tag, val, plc_type="CLX"):
+    """Write a tag value to the PLC."""
+    direct = plc_type == "Micro800"
+    c = ClxDriver()
+    if c.open(addr, direct_connection=direct):
+        try:
+            cv = c.read_tag(tag)
+            print(cv)
+            wt = c.write_tag(tag, val, cv[1])
+            return wt
+        except Exception:
+            print("Error during writeTag({}, {}, {})".format(addr, tag, val))
+            err = c.get_status()
+            c.close()
+            print err
+        c.close()
+
+
+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 not (self.value == new_value):
+                if self.map_:
+                    if not self.value == self.map_[new_value]:
+                        send_needed = True
+                        send_reason = "value change"
+                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:
+                    print("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()
+            print("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, transformFn=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.transformFn = transformFn
+
+    def read(self, mbsvalue):
+        """Return the transformed read value."""
+        return self.transformFn(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."""
+        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:
+                print("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:
+            v = read_tag(self.plc_ip, self.plc_tag)
+            if v:
+                bool_arr = binarray(v[0])
+                new_val = {}
+                for idx in self.map_:
+                    try:
+                        new_val[self.map_[idx]] = bool_arr[idx]
+                    except KeyError:
+                        print("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()
+                    print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+        return send_needed

POCloud/python-driver/config.txt

@@ -0,0 +1,11 @@
+{
+    "driverFileName": "multisensor.py",
+    "deviceName": "multisensor",
+    "driverId": "0240",
+    "releaseVersion": "1",
+    "files": {
+        "file1": "multisensor.py",
+        "file2": "utilities.py",
+        "file3": "Channel.py"
+    }
+}

POCloud/python-driver/device_base.py

@@ -0,0 +1,360 @@
+import types
+import traceback
+import binascii
+import threading
+import time
+import thread
+import os
+import struct
+import sys
+import textwrap
+import Queue
+import json
+
+
+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")
+        #Queue for imcoming sets
+        self.loraQ = Queue.Queue()
+
+        self.knownIDs = []
+        thread.start_new_thread(self.getSetsThread, ())
+        
+    def getSetsThread(self):
+
+        while True:
+            try:
+                item = self.loraQ.get(block=True, timeout=600)
+                try:
+                    print "here is the item from the sets q"
+                    print item
+                    if len(item) == 2:
+                        techname = str(json.loads(item[1])[0]['payload']['name'].split(".")[0])
+                        channel = str(json.loads(item[1])[0]['payload']['name'].split(".")[1])
+                        name = techname.split("_")[0]
+                        id = techname.split("_")[1][1:-2].replace(":","").upper()
+                        value = json.loads(item[1])[0]['payload']['value']
+                        msgId = json.loads(item[1])[0]['msgId']
+
+                        print channel, value, id, name, msgId
+                        success = self.specificSets(channel, value, id, name)
+                                                  
+                        if success == True:
+                            print "SUCCESS ON SET"
+                            if int(msgId) == 0:
+                                return
+                            lc = self.getTime()
+
+                            value = str(self.mac) + " Success Setting: " + channel + " To: " + value
+                            msg = """[ { "value":"%s", "timestamp":"%s", "msgId":"%s" } ]""" % (value, str(lc), msgId)
+                            print value
+                            print msg
+                            topic = "meshify/responses/" + str(msgId)
+                            print topic
+                            self.q.put([topic, str(msg), 2])
+
+                
+                        else:
+
+                            lc = self.getTime()
+                            if success == False:
+                                reason = "(Internal Gateway/Device Error)"
+                            else:
+                                reason = success
+                            value = str(self.mac) + " Failed Setting: " + channel + " To: " + value + " " + reason
+                            msg = """[ { "value":"%s", "timestamp":"%s", "msgId":"%s" } ]""" % (value, str(lc), msgId)
+                            topic = "meshify/responses/" + msgId
+                            self.q.put([topic, str(msg), 2])
+                       
+                except:
+                    if int(msgId) == 0:
+                        return 
+                    lc = self.getTime()
+                    value = str(self.mac) + " Failed Setting: " + channel + " To: " + value + " (No Callback Found)"
+                    msg = """[ { "value":"%s", "timestamp":"%s", "msgId":"%s" } ]""" % (value, str(lc), msgId)
+                    topic = "meshify/responses/" + msgId
+                    self.q.put([topic, str(msg), 2])
+                    print 'no Set callback found for channel: ' + funcName
+
+            except:
+                print "sets queue timeout, restarting..."
+            
+
+    def sendtodbDevLora(self, id, channel, value, timestamp, deviceName):
+
+       
+
+        mac = self.mac
+        
+        if deviceName == "mainMeshify":
+            zigmac = "_[01:00:00:00:00:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        else:
+            zigmac = "_[00:00:00:00:00:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        dname = deviceName + zigmac
+
+        #define dname, make id into techname and mac
+        if id not in self.knownIDs:
+            self.knownIDs.append(id)
+            self.mcu.xbees[dname] = self.loraQ
+
+        #meshify/db/330/C493000354FB/ilora/c493000354fb2A6E/a1-v
+        #[ { "value":"0.5635", "timestamp":"1486039316" } ]
+
+        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 sendtodbLocLora(self, id, channel, value, timestamp, deviceName):
+
+       
+
+        mac = id
+        while len(mac) < 12:
+            mac = "0" + mac
+        if deviceName == "mainMeshify":
+            zigmac = "_[01:00:00:00:00:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        else:
+            zigmac = "_[00:00:00:00:00:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        dname = deviceName + zigmac
+
+         #define dname, make id into techname and mac
+        if id not in self.knownIDs:
+            self.knownIDs.append(id)
+            topic = str(("meshify/sets/" + str(self.company) + "/" + mac + "/#"))
+            self.mqtt.subscribe(topic, 0)
+            topic = str(("meshify/sets/" + "1" + "/" + mac + "/#"))
+            self.mqtt.subscribe(topic, 0)
+            self.mcu.xbees[dname] = self.loraQ
+
+        #meshify/db/330/C493000354FB/ilora/c493000354fb2A6E/a1-v
+        #[ { "value":"0.5635", "timestamp":"1486039316" } ]
+
+        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 sendtodbLocLoraCom(self, id, channel, value, timestamp, deviceName):
+
+       
+
+        mac = "1" + id
+        while len(mac) < 12:
+            mac = "0" + mac
+
+        if deviceName == "mainMeshify":
+            zigmac = "_[01:00:00:00:00:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        else:
+            zigmac = "_[00:00:00:00:01:" + id[0:2] + ":" + id[2:4] + ":" + id[4:6] + "]!"
+        dname = deviceName + zigmac
+
+         #define dname, make id into techname and mac
+        if id not in self.knownIDs:
+            self.knownIDs.append(id)
+            topic = str(("meshify/sets/" + str(self.company) + "/" + mac + "/#"))
+            self.mqtt.subscribe(topic, 0)
+            topic = str(("meshify/sets/" + "1" + "/" + mac + "/#"))
+            self.mqtt.subscribe(topic, 0)
+            self.mcu.xbees[dname] = self.loraQ
+
+        #meshify/db/330/C493000354FB/ilora/c493000354fb2A6E/a1-v
+        #[ { "value":"0.5635", "timestamp":"1486039316" } ]
+
+        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 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 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)))
+
+
+
+

POCloud/python-driver/driverConfig.json

@@ -0,0 +1,11 @@
+{
+    "name": "multisensor",
+    "driverFilename": "multisensor.py",
+    "driverId": "0000",
+    "additionalDriverFiles": [
+        "utilities.py",
+        "Channel.py"
+    ],
+    "version": 1,
+    "s3BucketName": "multisensor"
+}

POCloud/python-driver/logger.py

@@ -0,0 +1,18 @@
+# LOGGING SETUP
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+
+log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
+logFile = './multisensor.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)
+filelogger = logging.getLogger('multisensor')
+filelogger.setLevel(logging.INFO)
+filelogger.addHandler(my_handler)
+
+console_out = logging.StreamHandler(sys.stdout)
+console_out.setFormatter(log_formatter)
+filelogger.addHandler(console_out)

POCloud/python-driver/multisensor.py

@@ -0,0 +1,194 @@
+"""Driver for multisensor"""
+
+import threading
+import json
+import time
+from random import randint
+
+from device_base import deviceBase
+from Channel import PLCChannel, read_tag, write_tag
+from utilities import get_public_ip_address
+from logger import filelogger
+
+_ = None
+
+filelogger.info("multisensor startup")
+
+# GLOBAL VARIABLES
+WAIT_FOR_CONNECTION_SECONDS = 60
+WATCHDOG_ENABLE = True
+WATCHDOG_SEND_PERIOD = 3600  # Seconds, the longest amount of time before sending the watchdog status
+PLC_IP_ADDRESS = "192.168.1.12"
+
+CALIBRATION_TABLES = [[] for x in xrange(8)]
+
+CHANNELS = [
+    PLCChannel(PLC_IP_ADDRESS, 'an0val', 'input0.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an1val', 'input1.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an2val', 'input2.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an3val', 'input3.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an4val', 'input4.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an5val', 'input5.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an6val', 'input6.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an7val', 'input7.scaledValue', 'REAL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond0volume', 'input0.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond1volume', 'input1.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond2volume', 'input2.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond3volume', 'input3.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond4volume', 'input4.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond5volume', 'input5.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond6volume', 'input6.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'pond7volume', 'input7.pondVolume', 'REAL', 1000.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an0active', 'input0.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an1active', 'input1.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an2active', 'input2.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an3active', 'input3.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an4active', 'input4.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an5active', 'input5.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an6active', 'input6.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+    PLCChannel(PLC_IP_ADDRESS, 'an7active', 'input7.active', 'BOOL', 1.0, 600, map_=False, write_enabled=False, plc_type="Micro800"),
+]
+
+
+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 = "1"
+        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
+        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("multisensor driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
+            time.sleep(1)
+        filelogger.info("BOOM! Starting multisensor driver...")
+
+        self._check_watchdog()
+        self._check_ip_address()
+
+        self.nodes["multisensor_0199"] = self
+
+        send_loops = 0
+        watchdog_check_after = 60
+        ip_check_after = 60
+
+        while True:
+            now = time.time()
+            if self.force_send:
+                filelogger.warning("FORCE SEND: TRUE")
+
+            for chan in CHANNELS:
+                val = chan.read()
+                if chan.check(val, self.force_send):
+                    self.sendtodbDev(1, chan.mesh_name, chan.value, 0, 'multisensor')
+
+
+            # print("multisensor driver still alive...")
+            if self.force_send:
+                if send_loops > 2:
+                    filelogger.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_after:
+                    self._check_watchdog()
+
+            if (now - self.public_ip_address_last_checked) > ip_check_after:
+                self._check_ip_address()
+
+    def read_pond_calibration(self, input_number):
+        """Read all calibration values for a specific pond."""
+        last_read_height = -1.0
+        cal_values = []
+        cal_index = 1
+        while last_read_height != 0 and cal_index <=10:
+            cal_tag_height = "pond{}CalibrationHeight[{}]".format(input_number, cal_index)
+            cal_tag_volume = "pond{}CalibrationVolume[{}]".format(input_number, cal_index)
+            read_height = read_tag(PLC_IP_ADDRESS, cal_tag_height, plc_type="Micro800")
+            time.sleep(2)
+            read_volume = read_tag(PLC_IP_ADDRESS, cal_tag_volume, plc_type="Micro800")
+            time.sleep(2)
+            if read_height and read_volume:
+                if read_height[0] > 0.0:
+                    cal_values.append({"height": read_height[0], "volume": read_volume[0]})
+                last_read_height = read_height[0]
+            cal_index += 1
+
+        if cal_values != CALIBRATION_TABLES[input_number] or self.force_send:
+            calibration_channel = "pond{}calibration".format(input_number)
+            calibration_string = json.dumps(cal_values).replace('"', "'")
+            self.sendtodbDev(1, calibration_channel, calibration_string, 0, 'plcpond')
+            CALIBRATION_TABLES[input_number] = cal_values
+
+    def _check_watchdog(self):
+        """Check the watchdog and send to Meshify if changed or stale."""
+        test_watchdog = self.multisensor_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, 'multisensor')
+            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()
+        if not test_public_ip == self.public_ip_address:
+            self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, 'multisensor')
+            self.public_ip_address = test_public_ip
+
+    def multisensor_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)
+        time.sleep(1)
+        watchdog_val = read_tag(str(PLC_IP_ADDRESS), 'watchdog_INT')
+        try:
+            return (randval - 1) == watchdog_val[0]
+        except (KeyError, TypeError):
+            return False
+
+    def multisensor_sync(self, name, value):
+        """Sync all data from the driver."""
+        self.force_send = True
+        self.sendtodb("log", "synced", 0)
+        return True
+
+    def multisensor_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)
+        print("Result of multisensor_writeplctag(self, {}, {}) = {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res

POCloud/python-driver/plcpond.py

@@ -0,0 +1,247 @@
+"""Driver for plcpond"""
+
+import threading
+import sys
+import json
+import time
+import logging
+from random import randint
+from device_base import deviceBase
+from Channel import PLCChannel, read_tag, write_tag, TAG_DATAERROR_SLEEPTIME
+from utilities import get_public_ip_address
+
+
+_ = None
+
+# LOGGING SETUP
+from logging.handlers import RotatingFileHandler
+
+log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
+logFile = './plcpond.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('plcpond')
+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("plcpond startup")
+
+# GLOBAL VARIABLES
+WATCHDOG_SEND_PERIOD = 3600  # Seconds, the longest amount of time before sending the watchdog status
+PLC_IP_ADDRESS = "192.168.1.12"
+CHANNELS = [
+    PLCChannel(PLC_IP_ADDRESS, "cfgnumberofponds", "cfgNumberOfPonds", "REAL", 0.5, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+
+    PLCChannel(PLC_IP_ADDRESS, "pond1height", "pond1Height", "REAL", 0.5, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond2height", "pond2Height", "REAL", 0.5, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond3height", "pond3Height", "REAL", 0.5, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond4height", "pond4Height", "REAL", 0.5, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+
+    PLCChannel(PLC_IP_ADDRESS, "pond1volume", "pond1Volume", "REAL", 500.0, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond2volume", "pond2Volume", "REAL", 500.0, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond3volume", "pond3Volume", "REAL", 500.0, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+    PLCChannel(PLC_IP_ADDRESS, "pond4volume", "pond4Volume", "REAL", 500.0, 600, map_=False, write_enabled=False, plc_type='Micro800'),
+
+    PLCChannel(PLC_IP_ADDRESS, "pondvolumetotal", "pondVolumeTotal", "REAL", 500.0, 600, map_=False, write_enabled=False, plc_type='Micro800')
+]
+
+CALIBRATION_TABLES = [[],[], [], [], []]  # position 0 is a dummy table
+
+
+
+
+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 = "2"
+        self.finished = threading.Event()
+        self.force_send = False
+        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."""
+        wait_sec = 30
+        for i in range(0, wait_sec):
+            print("plcpond driver will start in {} seconds".format(wait_sec - i))
+            time.sleep(1)
+        logger.info("BOOM! Starting plcpond driver...")
+
+        public_ip_address = get_public_ip_address()
+        self.sendtodbDev(1, 'public_ip_address', public_ip_address, 0, 'plcpond')
+        watchdog = self.plcpond_watchdog()
+        self.sendtodbDev(1, 'watchdog', watchdog, 0, 'plcpond')
+        watchdog_send_timestamp = time.time()
+
+        self.nodes["plcpond_0199"] = self
+
+        send_loops = 0
+        watchdog_loops = 0
+        watchdog_check_after = 5000
+        while True:
+            if self.force_send:
+                logger.warning("FORCE SEND: TRUE")
+
+            for c in CHANNELS:
+                v = c.read()
+                if v is not None:  # read returns None if it fails
+                    if c.check(v, self.force_send):
+                        self.sendtodbDev(1, c.mesh_name, c.value, 0, 'plcpond')
+                time.sleep(TAG_DATAERROR_SLEEPTIME) # sleep to allow Micro800 to handle ENET requests
+
+            for pond_index in range(1, 5):
+                self.read_pond_calibration(pond_index)
+
+            # print("plcpond driver still alive...")
+            if self.force_send:
+                if send_loops > 2:
+                    logger.warning("Turning off force_send")
+                    self.force_send = False
+                    send_loops = 0
+                else:
+                    send_loops += 1
+
+            watchdog_loops += 1
+            if watchdog_loops >= watchdog_check_after:
+                test_watchdog = self.plcpond_watchdog()
+                if not test_watchdog == watchdog or (time.time() - watchdog_send_timestamp) > WATCHDOG_SEND_PERIOD:
+                    self.sendtodbDev(1, 'watchdog', test_watchdog, 0, 'plcpond')
+                    watchdog = test_watchdog
+
+                test_public_ip = get_public_ip_address()
+                if not test_public_ip == public_ip_address:
+                    self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, 'plcpond')
+                    public_ip_address = test_public_ip
+                watchdog_loops = 0
+
+
+    def read_pond_calibration(self, pond_number):
+        """Read all calibration values for a specific pond."""
+        last_read_height = -1.0
+        cal_values = []
+        cal_index = 1
+        while last_read_height != 0 and cal_index <=10:
+            cal_tag_height = "pond{}CalibrationHeight[{}]".format(pond_number, cal_index)
+            cal_tag_volume = "pond{}CalibrationVolume[{}]".format(pond_number, cal_index)
+            read_height = read_tag(PLC_IP_ADDRESS, cal_tag_height, plc_type="Micro800")
+            time.sleep(2)
+            read_volume = read_tag(PLC_IP_ADDRESS, cal_tag_volume, plc_type="Micro800")
+            time.sleep(2)
+            if read_height and read_volume:
+                if read_height[0] > 0.0:
+                    cal_values.append({"height": read_height[0], "volume": read_volume[0]})
+                last_read_height = read_height[0]
+            cal_index += 1
+
+        if cal_values != CALIBRATION_TABLES[pond_number] or self.force_send:
+            calibration_channel = "pond{}calibration".format(pond_number)
+            calibration_string = json.dumps(cal_values).replace('"', "'")
+            self.sendtodbDev(1, calibration_channel, calibration_string, 0, 'plcpond')
+            CALIBRATION_TABLES[pond_number] = cal_values
+
+    def plcpond_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="Micro800")
+        time.sleep(1)
+        watchdog_val = read_tag(str(PLC_IP_ADDRESS), 'watchdog_INT', plc_type="Micro800")
+        try:
+            return (randval - 1) == watchdog_val[0]
+        except (KeyError, TypeError):
+            return False
+
+    def plcpond_sync(self, name, value):
+        """Sync all data from the driver."""
+        self.force_send = True
+        # self.sendtodb("log", "synced", 0)
+        return True
+
+    def plcpond_deletecalibrationpoint(self, name, value):
+        """Delete a calibration point from a calibration table"""
+        # {"pond": int, "point": int}
+        value = value.replace("'", '"')
+        parsed = json.loads(value)
+        try:
+            pond_number = int(parsed['pond'])
+            point_number = int(parsed['point'])
+            write_pond = write_tag(PLC_IP_ADDRESS, "inpPondNumber", pond_number, plc_type="Micro800")
+            time.sleep(2)
+            write_point = write_tag(PLC_IP_ADDRESS, "inpDeletePointIndex", point_number, plc_type="Micro800")
+            time.sleep(2)
+            if write_pond and write_point:
+                write_cmd = write_tag(PLC_IP_ADDRESS, "cmdDeleteCalibrationPoint", 1, plc_type="Micro800")
+                time.sleep(2)
+                if write_cmd:
+                    read_val = read_tag(PLC_IP_ADDRESS, "deleteSuccess", plc_type="Micro800")
+                    if read_val[0] == 1:
+                        self.read_pond_calibration(pond_number)
+                        return True
+                    return "Wrote everything successfully, but delete didn't succeed (Check pond and point values)."
+                return "Didn't write delete command correctly."
+            return "Didn't write pond or point correctly."
+        except KeyError as e:
+            return "Couldn't parse input value: {} -- {}".format(value, e)
+
+    def plcpond_cfgnumberofponds(self, name, value):
+        """Write the number of ponds to the plc."""
+        value = int(value)
+        return write_tag(PLC_IP_ADDRESS, "cfgNumberOfPonds", value, plc_type="Micro800")
+
+    def plcpond_addcalibrationpoint(self, name, value):
+        """Add a calibration point to the calibration table"""
+        # value = {"pond": int, "height": float, "volume": float}
+        value = value.replace("'", '"')
+        parsed = json.loads(value)
+        try:
+            # parse json values, throw an error if one is missing
+            pond_number = int(parsed['pond'])
+            height = float(parsed['height'])
+            volume = float(parsed['volume'])
+            # write values to the tags
+            write_pond = write_tag(PLC_IP_ADDRESS, "inpPondNumber", pond_number, plc_type="Micro800")
+            time.sleep(2)
+            write_height = write_tag(PLC_IP_ADDRESS, "inpPondHeight", height, plc_type="Micro800")
+            time.sleep(2)
+            write_volume= write_tag(PLC_IP_ADDRESS, "inpPondVolume", volume, plc_type="Micro800")
+            time.sleep(2)
+            if write_pond and write_height and write_volume:
+                write_cmd = write_tag(PLC_IP_ADDRESS, "cmdAddCalibrationPoint", 1, plc_type="Micro800")
+                time.sleep(2)
+                if write_cmd:
+                    read_val = read_tag(PLC_IP_ADDRESS, "addSuccess", plc_type="Micro800")
+                    if read_val[0] == 1:
+                        self.read_pond_calibration(pond_number)
+                        return True
+                    return "Wrote everything successfully, but delete didn't succeed (Check pond and point values)."
+                return "Didn't write delete command correctly."
+            return "Didn't write pond or point correctly."
+        except KeyError as e:
+            return "Couldn't parse input value: {} -- {}".format(value, e)
+
+    def plcpond_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']
+        w = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n)
+        logger.info("Result of plcpond_writeplctag(self, {}, {}) = {}".format(name, value, w))
+        if w is None:
+            w = "Error writing to PLC..."
+        return w

POCloud/python-driver/test.py

@@ -0,0 +1,26 @@
+import json
+import time
+from Channel import read_tag, write_tag
+
+PLC_IP_ADDRESS = "192.168.1.12"
+
+def read_pond_calibration(pond_number):
+    """Read all calibration values for a specific pond."""
+    last_read_height = -1.0
+    cal_values = []
+    cal_index = 1
+    while last_read_height != 0 and cal_index <=10:
+        cal_tag_height = "pond{}CalibrationHeight[{}]".format(pond_number, cal_index)
+        cal_tag_volume = "pond{}CalibrationVolume[{}]".format(pond_number, cal_index)
+        print(cal_tag_height, cal_tag_volume)
+        read_height = read_tag(PLC_IP_ADDRESS, cal_tag_height, plc_type="Micro800")
+        time.sleep(2)
+        read_volume = read_tag(PLC_IP_ADDRESS, cal_tag_volume, plc_type="Micro800")
+        time.sleep(2)
+        print(read_height, read_volume)
+        if read_height and read_volume:
+            if read_height[0] > 0.0:
+                cal_values.append({"height": read_height[0], "volume": read_volume[0]})
+            last_read_height = read_height[0]
+        cal_index += 1
+    return cal_values

POCloud/python-driver/utilities.py

@@ -0,0 +1,51 @@
+"""Utility functions for the driver."""
+import socket
+import struct
+
+
+def get_public_ip_address():
+    """Find the public IP Address of the host device."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.connect(("8.8.8.8", 80))
+    ip = s.getsockname()[0]
+    s.close()
+    return ip
+
+
+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")
+        else:
+            return float("NaN")
+    else:
+        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 = struct.unpack('>f', mypack)
+    print("[{}, {}] >> {}".format(int1, int2, f[0]))
+    return f[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