added meshify converted drivers

Thingsboard Gateway/installtbg.sh

@@ -0,0 +1,50 @@
+apt update
+apt upgrade
+#download thingsboard-gateway
+wget https://github.com/thingsboard/thingsboard-gateway/releases/latest/download/python3-thingsboard-gateway.deb
+apt install ./python3-thingsboard-gateway.deb -y
+systemctl status thingsboard-gateway
+#stop thingsboard-gateway
+systemctl stop thingsboard-gateway
+
+#download ethernetip extension
+curl -H 'Authorization: token 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' \
+  -H 'Accept: application/vnd.github.v3.raw' \
+  -O \
+  -L https://github.com/Henry-Pump/ThingsBoard/raw/main/Thingsboard%20Gateway/ethernetip_converter.py
+
+curl -H 'Authorization: token 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' \
+  -H 'Accept: application/vnd.github.v3.raw' \
+  -O \
+  -L https://github.com/Henry-Pump/ThingsBoard/raw/main/Thingsboard%20Gateway/ethernetip_connector.py
+
+curl -H 'Authorization: token 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' \
+  -H 'Accept: application/vnd.github.v3.raw' \
+  -O \
+  -L https://github.com/Henry-Pump/ThingsBoard/raw/main/Thingsboard%20Gateway/ethernetip.json
+
+curl -H 'Authorization: token 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' \
+  -H 'Accept: application/vnd.github.v3.raw' \
+  -O \
+  -L https://github.com/Henry-Pump/ThingsBoard/raw/main/Thingsboard%20Gateway/tb_gateway.yaml?token=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
+
+wget https://hp-thingsboard.s3.amazonaws.com/ethernetip_connector.py
+wget https://hp-thingsboard.s3.amazonaws.com/ethernetip_converter.py
+wget https://hp-thingsboard.s3.amazonaws.com/ethernetip.json
+wget https://hp-thingsboard.s3.amazonaws.com/tb_gateway.yaml
+
+
+#move to proper location
+mkdir /var/lib/thingsboard_gateway/extensions/ethernetip
+mv ethernetip_converter.py /var/lib/thingsboard_gateway/extensions/ethernetip
+mv ethernetip_connector.py /var/lib/thingsboard_gateway/extensions/ethernetip
+
+mv tb_gateway.yaml /etc/thingsboard-gateway/config
+mv ethernetip.json /etc/thingsboard-gateway/config
+
+#install pycomm3 for thingsboard
+sudo pip3  install --target=/usr/lib/python3/dist-packages pycomm3
+
+
+systemctl start thingsboard-gateway
+rm installtbg.sh python3-thingsboard-gateway.deb

meshifyDrivers/mainHP/config.txt

@@ -0,0 +1,13 @@
+{
+
+"driverFileName":"mainMeshify.py",
+"deviceName":"mainMeshify",
+"driverId":"0000",
+"releaseVersion":"17",
+"files": {
+	"file1":"mainMeshify.py",
+	"file2":"main.py",
+	"file3":"meshifyData.py"
+	}
+
+}

meshifyDrivers/mainHP/device_base.py

@@ -0,0 +1,200 @@
+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 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/mainHP/mainMeshify.py

@@ -0,0 +1,133 @@
+import time
+import os
+try:
+    import json
+except:
+    import simplejson as json
+import thread
+import threading
+import re
+
+
+
+
+
+class start(threading.Thread):
+
+    def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None, companyId=None, offset=None, mqtt=None, Nodes=None):
+        threading.Thread.__init__(self)
+        self.daemon = True
+        self.offset = offset
+        self.company = companyId
+        self.name = name
+        self.number = number
+        self.q = Q
+        self.deviceName = name + '_[' + mac +  ':' + number[0:2] + ':' + number[2:] + ']!'
+        print 'device name is:'
+        print self.deviceName
+        mac2 = mac.replace(":", "")
+        self.mac = mac2.upper()
+        self.version = "17" #hp device management
+        self.finished = threading.Event()
+        
+        threading.Thread.start(self)
+
+
+
+    #this is a required function for all drivers, its goal is to upload some piece of data
+    #about your device so it can be seen on the web
+    def register(self):
+        #self.mainMistaway_hb('hb', 'On')
+        self.sendtodb("connected", "true", 0)
+
+    def stop (self):
+        self.finished.set()
+        self.join()
+
+    def sendtodb(self, channel, value, timestamp):
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+            if timestamp < 1400499858:
+                return
+        csplit = re.split(r"(.*?)_\[(.*?)\]", self.deviceName)
+        nodeTypeName = csplit[1]
+        uniqueID = csplit[2]
+        company = "194"
+
+        
+        try:
+            topic = 'meshify/db/%s/%s/%s/%s/%s' % (company, "_", nodeTypeName, uniqueID, channel)
+            print topic
+            if channel == "files":
+                #for the file structure I had to take off the " " around the value
+                msg = """[{"value":%s}]""" % (str(value))
+            else:
+                msg = """[{"value":"%s"}]""" % (str(value))
+            print msg
+            self.q.put([topic, msg, 0])
+        except:
+            print "didn't work to send up MQTT data"
+
+    def run(self):
+        #on startup send the version number
+        self.sendtodb("version", str(self.version), 0)
+        while True:
+            try:
+                self.mainMeshify_hb('hb', 'On')
+                self.sendtodb("connected", "true", 0)
+                time.sleep(3600 * 4)
+            except Exception, e:
+                print e
+                
+    def mainMeshify_files(self, name, value):
+        name = 'files'
+
+        
+
+        
+        
+        dict = {}
+        for dirname, dirnames, filenames in os.walk(str(value)):
+            # print path to all subdirectories first.
+            
+            
+            print "##########################################"
+            print "new directory: " + dirname
+            print "##########################################"
+            # print path to all filenames.
+            tempDictParent = {}
+            for filename in filenames:
+                tempDict = {}
+                filepath = os.path.join(dirname, filename)
+                try:
+                    fileMem = os.stat(filepath).st_size
+                    fileDate = os.stat(filepath).st_mtime
+                except:
+                    fileMem = ""
+                    fileDate = ""
+                print filepath, fileMem, fileDate
+                tempDict["mem"] = fileMem
+                tempDict["date"] = fileDate
+                tempDictParent[filename] = tempDict
+            
+            dict[dirname] = tempDictParent
+
+            
+            # Advanced usage:
+            # editing the 'dirnames' list will stop os.walk() from recursing into there.
+            if '.git' in dirnames:
+                # don't go into any .git directories.
+                dirnames.remove('.git')
+
+        value = json.dumps(dict)
+        self.sendtodb(name, value, 0)
+        return True
+        
+
+    def mainMeshify_hb(self, name, value):
+        self.sendtodb(name, value, 0)
+        
+        
+    def getTime(self):
+        return str(int(time.time() + int(self.offset)))
+    

meshifyDrivers/mainHP/meshifyData.py

@@ -0,0 +1,112 @@
+
+
+
+import urllib
+try:
+    import json
+except:
+    import simplejson as json
+import pickle
+
+MAC = "00409D53168A"
+
+class meshifyData():
+    
+    def __init__(self, MAC):
+        self.mac = MAC[0:6] + "FF-FF" + MAC[6:]
+        print "here is the mac: " + self.mac
+        #set the defaults
+        self.param_dict = {}
+        
+    def checkConfig(self):
+
+        url = "https://f5rrbd3r45.execute-api.us-east-1.amazonaws.com/device_config?mac=" + self.mac
+         
+        try:
+            f = urllib.urlopen(url)
+        except:
+           print "Error opening url for remote config"
+           #return the defaults 
+           return None
+
+        try: 
+            s = f.read()
+            #print s
+            if len(s) < 5:
+                return None
+            s = s[1:-1].replace("'", '"')
+            print s
+            data = json.loads(s)
+            #if we get there then replace the deviceList.txt
+            with open('/root/python_firmware/deviceList.txt', 'w') as myfile:
+                json.dump(data, myfile, indent=4)
+            return data 
+        except Exception as e:
+            print e
+            #return the defaults 
+            return None
+
+    def checkAPI(self):
+    
+          
+        offset = -21600
+        dst = False
+        companyId = "1"
+
+
+        url = "https://machines.meshify.com/api/gateway?macaddressForTimezone=" + self.mac
+         
+        try:
+            f = urllib.urlopen(url)
+        except:
+           print "Error opening url"
+           #return the defaults 
+           return offset, dst, companyId
+
+        try: 
+            s = f.read()
+            print s
+            data = json.loads(s)
+            offset = int(data["offset"])
+            dst = bool(int(data["dst"]))
+            print bool(int("0"))
+            companyId = data["companyId"]
+            return offset, dst, companyId
+        except Exception,e:
+            print e
+            #return the defaults 
+            return -21600, False, "1"
+
+    def getdata(self):
+        #if the API fails and the company ID of 1 is returned then you need to
+        #check and see if you have pickled anything.
+        #if it doesn't fail, and it gives you something other than 1
+        #then you need to repickle the object
+        self.offset, self.dst, self.companyId = self.checkAPI()
+        if self.companyId == "1":
+            try:
+                self.param_dict = pickle.load( open( "params.p", "rb" ) )
+            except:
+                print self.offset, self.dst, self.companyId
+                return self.offset, self.dst, self.companyId
+            try:
+                self.offset = self.param_dict["offset"]
+                self.dst = self.param_dict["dst"]
+                self.companyId = self.param_dict["companyId"]
+            except:
+                return -21600, False, "1"
+
+            return self.offset, self.dst, self.companyId
+
+            
+        else:
+            self.param_dict["offset"] = self.offset
+            self.param_dict["dst"] = self.dst
+            self.param_dict["companyId"] = self.companyId
+            pickle.dump( self.param_dict, open( "params.p", "wb" ) )
+            print self.param_dict
+            print self.offset, self.dst, self.companyId
+            return self.offset, self.dst, self.companyId
+        
+
+

meshifyDrivers/mainHPRPI/config.txt

@@ -0,0 +1,14 @@
+{
+
+"driverFileName":"mainMeshify.py",
+"deviceName":"mainMeshify",
+"driverId":"0000",
+"releaseVersion":"16",
+"files": {
+	"file1":"mainMeshify.py",
+	"file2":"main.py",
+	"file3":"device_base.py",
+	"file4":"meshifyData.py"
+	}
+	
+}

meshifyDrivers/mainHPRPI/device_base.py

@@ -0,0 +1,200 @@
+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 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/mainHPRPI/mainMeshify.py

@@ -0,0 +1,133 @@
+import time
+import os
+try:
+    import json
+except:
+    import simplejson as json
+import thread
+import threading
+import re
+
+
+
+
+
+class start(threading.Thread):
+
+    def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None, companyId=None, offset=None, mqtt=None, Nodes=None):
+        threading.Thread.__init__(self)
+        self.daemon = True
+        self.offset = offset
+        self.company = companyId
+        self.name = name
+        self.number = number
+        self.q = Q
+        self.deviceName = name + '_[' + mac +  ':' + number[0:2] + ':' + number[2:] + ']!'
+        print 'device name is:'
+        print self.deviceName
+        mac2 = mac.replace(":", "")
+        self.mac = mac2.upper()
+        self.version = "17" #hp device management
+        self.finished = threading.Event()
+        
+        threading.Thread.start(self)
+
+
+
+    #this is a required function for all drivers, its goal is to upload some piece of data
+    #about your device so it can be seen on the web
+    def register(self):
+        #self.mainMistaway_hb('hb', 'On')
+        self.sendtodb("connected", "true", 0)
+
+    def stop (self):
+        self.finished.set()
+        self.join()
+
+    def sendtodb(self, channel, value, timestamp):
+        if int(timestamp) == 0:
+            timestamp = self.getTime()
+            if timestamp < 1400499858:
+                return
+        csplit = re.split(r"(.*?)_\[(.*?)\]", self.deviceName)
+        nodeTypeName = csplit[1]
+        uniqueID = csplit[2]
+        company = "194"
+
+        
+        try:
+            topic = 'meshify/db/%s/%s/%s/%s/%s' % (company, "_", nodeTypeName, uniqueID, channel)
+            print topic
+            if channel == "files":
+                #for the file structure I had to take off the " " around the value
+                msg = """[{"value":%s}]""" % (str(value))
+            else:
+                msg = """[{"value":"%s"}]""" % (str(value))
+            print msg
+            self.q.put([topic, msg, 0])
+        except:
+            print "didn't work to send up MQTT data"
+
+    def run(self):
+        #on startup send the version number
+        self.sendtodb("version", str(self.version), 0)
+        while True:
+            try:
+                self.mainMeshify_hb('hb', 'On')
+                self.sendtodb("connected", "true", 0)
+                time.sleep(3600 * 4)
+            except Exception, e:
+                print e
+                
+    def mainMeshify_files(self, name, value):
+        name = 'files'
+
+        
+
+        
+        
+        dict = {}
+        for dirname, dirnames, filenames in os.walk(str(value)):
+            # print path to all subdirectories first.
+            
+            
+            print "##########################################"
+            print "new directory: " + dirname
+            print "##########################################"
+            # print path to all filenames.
+            tempDictParent = {}
+            for filename in filenames:
+                tempDict = {}
+                filepath = os.path.join(dirname, filename)
+                try:
+                    fileMem = os.stat(filepath).st_size
+                    fileDate = os.stat(filepath).st_mtime
+                except:
+                    fileMem = ""
+                    fileDate = ""
+                print filepath, fileMem, fileDate
+                tempDict["mem"] = fileMem
+                tempDict["date"] = fileDate
+                tempDictParent[filename] = tempDict
+            
+            dict[dirname] = tempDictParent
+
+            
+            # Advanced usage:
+            # editing the 'dirnames' list will stop os.walk() from recursing into there.
+            if '.git' in dirnames:
+                # don't go into any .git directories.
+                dirnames.remove('.git')
+
+        value = json.dumps(dict)
+        self.sendtodb(name, value, 0)
+        return True
+        
+
+    def mainMeshify_hb(self, name, value):
+        self.sendtodb(name, value, 0)
+        
+        
+    def getTime(self):
+        return str(int(time.time() + int(self.offset)))
+    

meshifyDrivers/mainHPRPI/meshifyData.py

@@ -0,0 +1,112 @@
+
+
+
+import urllib
+try:
+    import json
+except:
+    import simplejson as json
+import pickle
+
+MAC = "00409D53168A"
+
+class meshifyData():
+    
+    def __init__(self, MAC):
+        self.mac = MAC[0:6] + "FF-FF" + MAC[6:]
+        print "here is the mac: " + self.mac
+        #set the defaults
+        self.param_dict = {}
+        
+    def checkConfig(self):
+
+        url = "https://f5rrbd3r45.execute-api.us-east-1.amazonaws.com/device_config?mac=" + self.mac
+         
+        try:
+            f = urllib.urlopen(url)
+        except:
+           print "Error opening url for remote config"
+           #return the defaults 
+           return None
+
+        try: 
+            s = f.read()
+            #print s
+            if len(s) < 5:
+                return None
+            s = s[1:-1].replace("'", '"')
+            print s
+            data = json.loads(s)
+            #if we get there then replace the deviceList.txt
+            with open('/root/python_firmware/deviceList.txt', 'w') as myfile:
+                json.dump(data, myfile, indent=4)
+            return data 
+        except Exception as e:
+            print e
+            #return the defaults 
+            return None
+
+    def checkAPI(self):
+    
+          
+        offset = -21600
+        dst = False
+        companyId = "1"
+
+
+        url = "https://machines.meshify.com/api/gateway?macaddressForTimezone=" + self.mac
+         
+        try:
+            f = urllib.urlopen(url)
+        except:
+           print "Error opening url"
+           #return the defaults 
+           return offset, dst, companyId
+
+        try: 
+            s = f.read()
+            print s
+            data = json.loads(s)
+            offset = int(data["offset"])
+            dst = bool(int(data["dst"]))
+            print bool(int("0"))
+            companyId = data["companyId"]
+            return offset, dst, companyId
+        except Exception,e:
+            print e
+            #return the defaults 
+            return -21600, False, "1"
+
+    def getdata(self):
+        #if the API fails and the company ID of 1 is returned then you need to
+        #check and see if you have pickled anything.
+        #if it doesn't fail, and it gives you something other than 1
+        #then you need to repickle the object
+        self.offset, self.dst, self.companyId = self.checkAPI()
+        if self.companyId == "1":
+            try:
+                self.param_dict = pickle.load( open( "params.p", "rb" ) )
+            except:
+                print self.offset, self.dst, self.companyId
+                return self.offset, self.dst, self.companyId
+            try:
+                self.offset = self.param_dict["offset"]
+                self.dst = self.param_dict["dst"]
+                self.companyId = self.param_dict["companyId"]
+            except:
+                return -21600, False, "1"
+
+            return self.offset, self.dst, self.companyId
+
+            
+        else:
+            self.param_dict["offset"] = self.offset
+            self.param_dict["dst"] = self.dst
+            self.param_dict["companyId"] = self.companyId
+            pickle.dump( self.param_dict, open( "params.p", "wb" ) )
+            print self.param_dict
+            print self.offset, self.dst, self.companyId
+            return self.offset, self.dst, self.companyId
+        
+
+

meshifyDrivers/tankalarms/Channel.py

@@ -0,0 +1,299 @@
+"""Define Meshify channel class."""
+import time
+from pycomm.ab_comm.clx import Driver as ClxDriver
+from pycomm.cip.cip_base import CommError, DataError
+from file_logger import filelogger as log
+import minimalmodbus
+
+minimalmodbus.BAUDRATE = 9600
+minimalmodbus.STOPBITS = 1
+
+
+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()
+        
+        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"
+                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/tankalarms/Tags.py

@@ -0,0 +1,24 @@
+from Channel import PLCChannel, ModbusChannel
+from tankalarms import PLC_IP_ADDRESS
+
+tags = [ 
+	PLCChannel(PLC_IP_ADDRESS, "water_level","WaterTxLevel","REAL", 0.5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_batt_volts","WaterTxBatVolts","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_rssi","WaterTxRSSI","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_hihi_spt","WaterTx_HHSP","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_hi_spt","WaterTx_HSP ","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_hihi_alm","WaterTx_HHAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_hi_alm","WaterTx_HAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_batt_lolo_alm","WaterTxBatVolts_LLAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "water_comm_fail_alm","WaterTx_RF_CommFail","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_level","OilTxLevel","REAL", 0.5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_batt_volts","OilTxBatVolts","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_rssi","OilTxRSSI","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_hihi_spt","OilTx_HHSP","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_hi_spt","OilTx_HSP ","REAL", 5, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_hihi_alm","OilTx_HHAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_hi_alm","OilTx_HAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_batt_lolo_alm","OilTxBatVolts_LLAlrm","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "oil_comm_fail_alm","OilTx_RF_CommFail","BOOL", 0, 3600, plc_type="Micro800"),
+	PLCChannel(PLC_IP_ADDRESS, "alarmreset","Reset","BOOL", 0, 3600, plc_type="Micro800")
+]

meshifyDrivers/tankalarms/config.txt

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

meshifyDrivers/tankalarms/device_base.py

@@ -0,0 +1,200 @@
+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 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/tankalarms/file_logger.py

@@ -0,0 +1,18 @@
+"""Logging setup for tankalarms"""
+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 = './tankalarms.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('tankalarms')
+filelogger.setLevel(logging.INFO)
+filelogger.addHandler(my_handler)
+
+console_out = logging.StreamHandler(sys.stdout)
+console_out.setFormatter(log_formatter)
+filelogger.addHandler(console_out)

meshifyDrivers/tankalarms/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/tankalarms/tankalarms.py

@@ -0,0 +1,197 @@
+"""Driver for tankalarms"""
+
+import threading
+import json
+import time
+from random import randint
+import os
+from device_base import deviceBase
+from Channel import PLCChannel, ModbusChannel,read_tag, write_tag, TAG_DATAERROR_SLEEPTIME
+import persistence
+from utilities import get_public_ip_address, get_private_ip_address
+from file_logger import filelogger as log
+PLC_IP_ADDRESS = "192.168.1.12"
+from Tags import tags
+
+_ = None
+
+log.info("tankalarms startup")
+
+# GLOBAL VARIABLES
+WAIT_FOR_CONNECTION_SECONDS = 20
+IP_CHECK_PERIOD = 60
+
+
+CHANNELS = tags
+
+# PERSISTENCE FILE
+PERSIST = persistence.load()
+
+
+class start(threading.Thread, deviceBase):
+    """Start class required by Meshify."""
+
+    def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None,
+                 companyId=None, offset=None, mqtt=None, Nodes=None):
+        """Initialize the driver."""
+        threading.Thread.__init__(self)
+        deviceBase.__init__(self, name=name, number=number, mac=mac, Q=Q,
+                            mcu=mcu, companyId=companyId, offset=offset,
+                            mqtt=mqtt, Nodes=Nodes)
+
+        self.daemon = True
+        self.version = "3"
+        self.finished = threading.Event()
+        self.force_send = False
+        self.public_ip_address = ""
+        self.public_ip_address_last_checked = 0
+        self.private_ip_address = ""
+        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("tankalarms driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
+            time.sleep(1)
+        log.info("BOOM! Starting tankalarms driver...")
+
+        self._check_ip_address()
+
+        self.nodes["tankalarms_0199"] = self
+
+        send_loops = 0
+
+        while True:
+            try:
+                now = time.time()
+                if self.force_send:
+                    log.warning("FORCE SEND: TRUE")
+                if int(time.time()) % 600 == 0 or self.force_send:
+                    payload = {"ts": round(time.time()/600)*600*1000, "values": {}}
+                    for chan in CHANNELS:
+                        val = chan.read()
+                        payload["values"][chan.mesh_name] = val
+
+                    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))
+                    time.sleep(TAG_DATAERROR_SLEEPTIME) # sleep to allow Micro800 to handle ENET requests    
+
+                # print("tankalarms 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
+
+            
+                
+                
+            except Exception as e:
+                log.error(e)
+
+   
+    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 tankalarms_sync(self, name, value):
+        """Sync all data from the driver."""
+        self.force_send = True
+        # self.sendtodb("log", "synced", 0)
+        return True
+
+    def tankalarms_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="Micro800")
+        print("Result of tankalarms_writeplctag(self, {}, {}) = {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+
+    def tankalarms_alarmreset(self, name, value):
+        log.info("Value received is {}".format(value))
+        if value == 1 or value == "1":
+            write_res = write_tag(str(PLC_IP_ADDRESS), "Reset", 1, plc_type="Micro800")
+            log.info("Result of tankalarms_alarmreset {}, {}, {}".format(name, value, write_res))
+            if write_res is None:
+                write_res = "Error writing to PLC..."
+            return write_res
+        return False
+
+    def tankalarms_water_hihi_spt(self, name, value):
+        log.info("Value received is {}".format(value))
+        write_res = write_tag(str(PLC_IP_ADDRESS), "WaterTx_HHSP", float(value), plc_type="Micro800")
+        log.info("Result of tankalarms_water_hihi_spt {}, {}, {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+        
+    
+    def tankalarms_water_hi_spt(self, name, value):
+        log.info("Value received is {}".format(value))
+        write_res = write_tag(str(PLC_IP_ADDRESS), "WaterTx_HSP", float(value), plc_type="Micro800")
+        log.info("Result of tankalarms_water_hi_spt {}, {}, {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+
+    def tankalarms_oil_hihi_spt(self, name, value):
+        log.info("Value received is {}".format(value))
+        write_res = write_tag(str(PLC_IP_ADDRESS), "OilTx_HHSP", float(value), plc_type="Micro800")
+        log.info("Result of tankalarms_oil_hihi_spt {}, {}, {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+
+    
+    def tankalarms_oil_hi_spt(self, name, value):
+        log.info("Value received is {}".format(value))
+        write_res = write_tag(str(PLC_IP_ADDRESS), "OilTx_HSP", float(value), plc_type="Micro800")
+        log.info("Result of tankalarms_oil_hi_spt {}, {}, {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res
+   
+

meshifyDrivers/tankalarms/utilities.py

@@ -0,0 +1,62 @@
+"""Utility functions for the driver."""
+import socket
+import struct
+import urllib
+import contextlib
+def get_private_ip_address():
+    """Find the private IP Address of the host device."""
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.connect(("8.8.8.8", 80))
+        ip_address = sock.getsockname()[0]
+        sock.close()
+    except Exception as e:
+        return e
+    
+    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 address: {}".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