added update for compulab device

abbflow/compulab/Channel.py

@@ -0,0 +1,340 @@
+"""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
+import serial
+
+
+TAG_DATAERROR_SLEEPTIME = 1
+
+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'  or type(new_value) == str:
+            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, unit_number=1, scaling=0):
+        """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
+        self.unit_number = unit_number
+        self.instrument = minimalmodbus.Instrument('/dev/ttymxc0', self.unit_number)
+        self.scaling= scaling
+        self.instrument.serial.baudrate = 9600
+        self.instrument.serial.stopbits = serial.STOPBITS_ONE 
+        self.instrument.serial.parity = serial.PARITY_NONE
+        self.instrument.serial.bytesize = 8
+        self.instrument.serial.timeout = 1 
+        self.instrument.handle_local_echo=False
+
+
+    def read(self):
+        """Return the transformed read value."""
+        if self.data_type == "FLOAT":
+            try:
+                read_value = self.instrument.read_float(self.register_number,4,self.channel_size)
+                time.sleep(TAG_DATAERROR_SLEEPTIME)
+            except IOError as e:
+                log.info(e)
+                return None
+
+        elif self.data_type == "INTEGER" or self.data_type == "STRING":
+            try:
+                read_value = self.instrument.read_register(self.register_number, self.scaling, 4)
+                time.sleep(TAG_DATAERROR_SLEEPTIME)
+            except IOError as e:
+                log.info(e)
+                return None
+        read_value = self.transform_fn(read_value)
+        return read_value
+
+    def write(self, value):
+        """Write a value to a register"""
+        if self.data_type == "FLOAT":
+            value = float(value)
+        elif self.data_type == "INTEGER":
+            value = int(value)
+        else:
+            value = str(value)
+        try:
+            self.instrument.write_register(self.register_number,value, self.scaling, 16 if self.channel_size > 1 else 6 )
+            time.sleep(TAG_DATAERROR_SLEEPTIME)
+            return True
+        except Exception as e:
+            log.info("Failed to write value: {}".format(e))
+            return False
+
+
+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

abbflow/compulab/Tags.py

@@ -0,0 +1,14 @@
+from Channel import PLCChannel, ModbusChannel
+
+tags = [ 
+	ModbusChannel("volume_flow",4003,"FLOAT", 20, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("today_volume",4005,"FLOAT", 10, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("battery_voltage",4001,"FLOAT", 5, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("last_calculation_period_volume",4011,"FLOAT", 10, 86400,channel_size=2, unit_number=1),
+	ModbusChannel("differential_pressure",4013,"FLOAT", 5, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("yesterday_volume",4007,"FLOAT", 10, 21600,channel_size=2, unit_number=1),
+	ModbusChannel("accumulated_volume",4009,"FLOAT", 10, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("static_pressure",4015,"FLOAT", 5, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("temperature",4017,"FLOAT", 5, 3600,channel_size=2, unit_number=1),
+	ModbusChannel("charger_voltage",4019,"FLOAT", 5, 3600,channel_size=2, unit_number=1)
+]

abbflow/compulab/abbflow.py

@@ -0,0 +1,122 @@
+"""Driver for abbflow"""
+
+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
+from file_logger import filelogger as log
+from Tags import tags
+
+_ = None
+log.info("abbflow startup")
+
+# GLOBAL VARIABLES
+WAIT_FOR_CONNECTION_SECONDS = 5
+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 = "1"
+        self.finished = threading.Event()
+        self.force_send = False
+        self.public_ip_address = ""
+        self.public_ip_address_last_checked = 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("abbflow driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
+            time.sleep(1)
+        log.info("BOOM! Starting abbflow driver...")
+
+        self._check_ip_address()
+
+        self.nodes["abbflow_0199"] = self
+
+        send_loops = 0
+
+        while True:
+            now = time.time()
+            if self.force_send:
+                log.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, 'abbflow')
+                time.sleep(TAG_DATAERROR_SLEEPTIME) # sleep to allow Micro800 to handle ENET requests    
+
+            # print("abbflow driver still alive...")
+            if self.force_send:
+                if send_loops > 2:
+                    log.warning("Turning off force_send")
+                    self.force_send = False
+                    send_loops = 0
+                else:
+                    send_loops += 1
+
+           
+            if (now - self.public_ip_address_last_checked) > IP_CHECK_PERIOD:
+                self._check_ip_address()
+
+   
+    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, 'abbflow')
+            self.public_ip_address = test_public_ip
+        hostname = "google.com" 
+        response = os.system("ping -c 1 " + hostname)
+
+        #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:
+            log.info("Rebooting because no internet detected")
+            os.system('reboot')
+        
+    
+    def abbflow_sync(self, name, value):
+        """Sync all data from the driver."""
+        self.force_send = True
+        # self.sendtodb("log", "synced", 0)
+        return True
+
+   

abbflow/compulab/config.txt

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

abbflow/compulab/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)))
+
+
+
+

abbflow/compulab/file_logger.py

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

abbflow/compulab/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

abbflow/compulab/utilities.py

@@ -0,0 +1,65 @@
+"""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
+    
+
+
+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

piflow/PiFlow.py

@@ -9,7 +9,7 @@ from device_base import deviceBase
 import persistence
 from utilities import get_public_ip_address, get_private_ip_address
 from file_logger import filelogger as log
-import RPi.GPIO as GPIO
+"""import RPi.GPIO as GPIO
 
 Relay_Ch1 = 26
 Relay_Ch2 = 20
@@ -24,7 +24,7 @@ GPIO.setup(Relay_Ch2,GPIO.OUT)
 GPIO.output(Relay_Ch2, GPIO.HIGH)
 GPIO.setup(Relay_Ch3,GPIO.OUT)
 GPIO.output(Relay_Ch3, GPIO.HIGH)
-
+"""
 _ = None
 os.system('sudo timedatectl set-timezone America/Chicago')
 log.info("PiFlow startup")
@@ -56,6 +56,7 @@ if not PERSIST:
         'yesterday_total_midnight_totalizer_3': 0
         }
     persistence.store(PERSIST, 'persist.json')
+"""
 try:
     if time.time() - PERSIST['state_timer'] >= 60:
         GPIO.output(Relay_Ch1, GPIO.HIGH)
@@ -69,7 +70,7 @@ except:
     PERSIST['state'] = False
     PERSIST['state_time'] = time.time()
     persistence.store(PERSIST, "persist.json")
-
+"""
 drive_enabled = PERSIST['drive_enabled']
 try:
         isVFD = PERSIST['isVFD']
@@ -296,7 +297,7 @@ class start(threading.Thread, deviceBase):
                 
         log.info("Result of PiFlow_write(self, {}, {}) = {}".format(name, value, write_res))
         return write_res
-    
+    """
     def PiFlow_start(self, name, value):
         if isVFD:
             #do something with the plc
@@ -309,7 +310,7 @@ class start(threading.Thread, deviceBase):
             persistence.store(PERSIST,"persist.json")
 
         return True
-    
+   
     def PiFlow_stop(self, name, value):
         if isVFD:
             log.info("Sending STOP signal to PLC")
@@ -321,7 +322,7 @@ class start(threading.Thread, deviceBase):
             PERSIST["state_timer"] = time.time()
             persistence.store(PERSIST, "persist.json")
         return True
-        
+        """
     def totalize(self,val, yesterday, day, hour, minute, yesterday_total_midnight, yesterday_total,channel):
         if (yesterday_total == 0 and yesterday_total_midnight == 0) or (yesterday_total == None or yesterday_total_midnight == None):
             yesterday_total_midnight = val