diff --git a/{{cookiecutter.driver_name}}/python-driver/Channel.py b/{{cookiecutter.driver_name}}/python-driver/Channel.py
index adb6680..b25020a 100644
--- a/{{cookiecutter.driver_name}}/python-driver/Channel.py
+++ b/{{cookiecutter.driver_name}}/python-driver/Channel.py
@@ -1,9 +1,13 @@
 """Define Meshify channel class."""
+import time
 from pycomm.ab_comm.clx import Driver as ClxDriver
 from pycomm.cip.cip_base import CommError, DataError
-import time
+from file_logger import filelogger as log
 
 
+
+TAG_DATAERROR_SLEEPTIME = 5
+
 def binarray(intval):
     """Split an integer into its bits."""
     bin_string = '{0:08b}'.format(intval)
@@ -15,70 +19,71 @@ def binarray(intval):
 def read_tag(addr, tag, plc_type="CLX"):
     """Read a tag from the PLC."""
     direct = plc_type == "Micro800"
-    c = ClxDriver()
+    clx = ClxDriver()
     try:
-        if c.open(addr, direct_connection=direct):
+        if clx.open(addr, direct_connection=direct):
             try:
-                v = c.read_tag(tag)
-                return v
-            except DataError as e:
-                c.close()
-                print("Data Error during readTag({}, {}): {}".format(addr, tag, e))
+                val = clx.read_tag(tag)
+                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()
-        c.close()
-        print("Could not connect during readTag({}, {})".format(addr, tag))
-        # print err
-    except AttributeError as e:
-        c.close()
-        print("AttributeError during readTag({}, {}): \n{}".format(addr, tag, e))
-    c.close()
+        clx.close()
+        log.error("Could not connect during readTag({}, {})".format(addr, tag))
+    except AttributeError as err:
+        clx.close()
+        log.error("AttributeError during readTag({}, {}): \n{}".format(addr, tag, err))
+    clx.close()
     return False
 
 
 def read_array(addr, tag, start, end, plc_type="CLX"):
     """Read an array from the PLC."""
     direct = plc_type == "Micro800"
-    c = ClxDriver()
-    if c.open(addr, direct_connection=direct):
+    clx = ClxDriver()
+    if clx.open(addr, direct_connection=direct):
         arr_vals = []
         try:
             for i in range(start, end):
                 tag_w_index = tag + "[{}]".format(i)
-                v = c.read_tag(tag_w_index)
-                # print('{} - {}'.format(tag_w_index, v))
-                arr_vals.append(round(v[0], 4))
-            # print(v)
-            if len(arr_vals) > 0:
+                val = clx.read_tag(tag_w_index)
+                arr_vals.append(round(val[0], 4))
+            if arr_vals:
                 return arr_vals
             else:
-                print("No length for {}".format(addr))
+                log.error("No length for {}".format(addr))
                 return False
         except Exception:
-            print("Error during readArray({}, {}, {}, {})".format(addr, tag, start, end))
-            err = c.get_status()
-            c.close()
-            print err
-            pass
-        c.close()
+            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"
-    c = ClxDriver()
-    if c.open(addr, direct_connection=direct):
-        try:
-            cv = c.read_tag(tag)
-            print(cv)
-            wt = c.write_tag(tag, val, cv[1])
-            return wt
-        except Exception:
-            print("Error during writeTag({}, {}, {})".format(addr, tag, val))
-            err = c.get_status()
-            c.close()
-            print err
-        c.close()
+    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])
+                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):
@@ -111,7 +116,7 @@ class Channel(object):
             elif self.value is None:
                 send_needed = True
                 send_reason = "no value"
-            elif not (self.value == new_value):
+            elif self.value != new_value:
                 if self.map_:
                     if not self.value == self.map_[new_value]:
                         send_needed = True
@@ -147,12 +152,12 @@ class Channel(object):
                 try:
                     self.value = self.map_[new_value]
                 except KeyError:
-                    print("Cannot find a map value for {} in {} for {}".format(new_value, self.map_, self.mesh_name))
+                    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()
-            print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+            log.info("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
         return send_needed
 
     def read(self):
@@ -168,7 +173,7 @@ def identity(sent):
 class ModbusChannel(Channel):
     """Modbus channel object."""
 
-    def __init__(self, mesh_name, register_number, data_type, chg_threshold, guarantee_sec, channel_size=1, map_=False, write_enabled=False, transformFn=identity):
+    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
@@ -182,11 +187,11 @@ class ModbusChannel(Channel):
         self.guarantee_sec = guarantee_sec
         self.map_ = map_
         self.write_enabled = write_enabled
-        self.transformFn = transformFn
+        self.transform_fn = transform_fn
 
     def read(self, mbsvalue):
         """Return the transformed read value."""
-        return self.transformFn(mbsvalue)
+        return self.transform_fn(mbsvalue)
 
 
 class PLCChannel(Channel):
@@ -224,6 +229,7 @@ class BoolArrayChannels(Channel):
 
     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
@@ -244,7 +250,7 @@ class BoolArrayChannels(Channel):
                 if new_val_dict[idx] != self.last_value[idx]:
                     send = True
             except KeyError:
-                print("Key Error in self.compare_values for index {}".format(idx))
+                log.error("Key Error in self.compare_values for index {}".format(idx))
                 send = True
         return send
 
@@ -253,15 +259,15 @@ class BoolArrayChannels(Channel):
         send_needed = False
         send_reason = ""
         if self.plc_tag:
-            v = read_tag(self.plc_ip, self.plc_tag)
-            if v:
-                bool_arr = binarray(v[0])
+            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:
-                        print("Not able to get value for index {}".format(idx))
+                        log.error("Not able to get value for index {}".format(idx))
 
                 if self.last_send_time == 0:
                     send_needed = True
@@ -283,5 +289,5 @@ class BoolArrayChannels(Channel):
                     self.value = new_val
                     self.last_value = self.value
                     self.last_send_time = time.time()
-                    print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+                    log.info("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
         return send_needed
diff --git a/{{cookiecutter.driver_name}}/python-driver/device_base.py b/{{cookiecutter.driver_name}}/python-driver/device_base.py
index 6c08ea0..6e4a3e4 100644
--- a/{{cookiecutter.driver_name}}/python-driver/device_base.py
+++ b/{{cookiecutter.driver_name}}/python-driver/device_base.py
@@ -1,12 +1,360 @@
-"""Dummy class for device Base."""
+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)))
+
 
-class deviceBase(object):
-    """Dummy class for device Base."""
 
-    def sendtodbDev(self, idnum, name, value, timestamp, drivername):
-        """Dummy sendtodbDev function."""
-        pass
 
-    def sendtodb(self, name, value, timestamp):
-        """Dummy sendtodb function."""
-        pass
diff --git a/{{cookiecutter.driver_name}}/python-driver/driverConfig.json b/{{cookiecutter.driver_name}}/python-driver/driverConfig.json
index 3687826..74a5e9f 100644
--- a/{{cookiecutter.driver_name}}/python-driver/driverConfig.json
+++ b/{{cookiecutter.driver_name}}/python-driver/driverConfig.json
@@ -5,7 +5,8 @@
     "additionalDriverFiles": [
         "utilities.py",
         "persistence.py",
-        "Channel.py"
+        "channel.py",
+        "logger.py"
     ],
     "version": 1,
     "s3BucketName": "{{cookiecutter.driver_name}}"
diff --git a/{{cookiecutter.driver_name}}/python-driver/file_logger.py b/{{cookiecutter.driver_name}}/python-driver/file_logger.py
new file mode 100644
index 0000000..bf47f8e
--- /dev/null
+++ b/{{cookiecutter.driver_name}}/python-driver/file_logger.py
@@ -0,0 +1,18 @@
+"""Logging setup for {{cookiecutter.driver_name}}"""
+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 = './{{cookiecutter.driver_name}}.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('{{cookiecutter.driver_name}}')
+filelogger.setLevel(logging.INFO)
+filelogger.addHandler(my_handler)
+
+console_out = logging.StreamHandler(sys.stdout)
+console_out.setFormatter(log_formatter)
+filelogger.addHandler(console_out)
diff --git a/{{cookiecutter.driver_name}}/python-driver/{{cookiecutter.driver_name}}.py b/{{cookiecutter.driver_name}}/python-driver/{{cookiecutter.driver_name}}.py
index 29961df..ab46bff 100644
--- a/{{cookiecutter.driver_name}}/python-driver/{{cookiecutter.driver_name}}.py
+++ b/{{cookiecutter.driver_name}}/python-driver/{{cookiecutter.driver_name}}.py
@@ -1,45 +1,31 @@
 """Driver for {{cookiecutter.driver_name}}"""
 
 import threading
-import sys
 import json
 import time
-import logging
 from random import randint
 
 from device_base import deviceBase
-from Channel import Channel, read_tag, write_tag
+from channel import Channel, read_tag, write_tag
 import persistence
 from utilities import get_public_ip_address
+from file_logger import filelogger as log
 
 _ = None
 
-# LOGGING SETUP
-from logging.handlers import RotatingFileHandler
-
-log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
-logFile = './{{cookiecutter.driver_name}}.log'
-my_handler = RotatingFileHandler(logFile, mode='a', maxBytes=500*1024,
-                                 backupCount=2, encoding=None, delay=0)
-my_handler.setFormatter(log_formatter)
-my_handler.setLevel(logging.INFO)
-logger = logging.getLogger('{{cookiecutter.driver_name}}')
-logger.setLevel(logging.INFO)
-logger.addHandler(my_handler)
-
-console_out = logging.StreamHandler(sys.stdout)
-console_out.setFormatter(log_formatter)
-logger.addHandler(console_out)
-
-logger.info("{{cookiecutter.driver_name}} startup")
+log.info("{{cookiecutter.driver_name}} startup")
 
 # GLOBAL VARIABLES
+WAIT_FOR_CONNECTION_SECONDS = 60
+IP_CHECK_PERIOD = 60
+WATCHDOG_ENABLE = True
+WATCHDOG_CHECK_PERIOD = 60
 WATCHDOG_SEND_PERIOD = 3600  # Seconds, the longest amount of time before sending the watchdog status
 PLC_IP_ADDRESS = "192.168.1.10"
 CHANNELS = []
 
 # PERSISTENCE FILE
-persist = persistence.load()
+PERSIST = persistence.load()
 
 
 class start(threading.Thread, deviceBase):
@@ -57,6 +43,11 @@ class start(threading.Thread, deviceBase):
         self.version = "1"
         self.finished = threading.Event()
         self.force_send = False
+        self.public_ip_address = ""
+        self.public_ip_address_last_checked = 0
+        self.watchdog = False
+        self.watchdog_last_checked = 0
+        self.watchdog_last_sent = 0
         threading.Thread.start(self)
 
     # this is a required function for all drivers, its goal is to upload some piece of data
@@ -68,53 +59,62 @@ class start(threading.Thread, deviceBase):
 
     def run(self):
         """Actually run the driver."""
-        global persist
-        wait_sec = 60
-        for i in range(0, wait_sec):
-            print("{{cookiecutter.driver_name}} driver will start in {} seconds".format(wait_sec - i))
+        for i in range(0, WAIT_FOR_CONNECTION_SECONDS):
+            print("{{cookiecutter.driver_name}} driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i))
             time.sleep(1)
-        logger.info("BOOM! Starting {{cookiecutter.driver_name}} driver...")
+        log.info("BOOM! Starting {{cookiecutter.driver_name}} driver...")
 
-        public_ip_address = get_public_ip_address()
-        self.sendtodbDev(1, 'public_ip_address', public_ip_address, 0, '{{cookiecutter.driver_name}}')
-        watchdog = self.{{cookiecutter.driver_name}}_watchdog()
-        self.sendtodbDev(1, 'watchdog', watchdog, 0, '{{cookiecutter.driver_name}}')
-        watchdog_send_timestamp = time.time()
+        self._check_watchdog()
+        self._check_ip_address()
+
+        self.nodes["{{cookiecutter.driver_name}}_0199"] = self
 
         send_loops = 0
-        watchdog_loops = 0
-        watchdog_check_after = 5000
+
         while True:
+            now = time.time()
             if self.force_send:
-                logger.warning("FORCE SEND: TRUE")
-
-            for c in CHANNELS:
-                v = c.read()
-                if c.check(self.force_send):
-                    self.sendtodbDev(1, c.mesh_name, c.value, 0, '{{cookiecutter.driver_name}}')
+                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, '{{cookiecutter.driver_name}}')
 
             # print("{{cookiecutter.driver_name}} driver still alive...")
             if self.force_send:
                 if send_loops > 2:
-                    logger.warning("Turning off force_send")
+                    log.warning("Turning off force_send")
                     self.force_send = False
                     send_loops = 0
                 else:
                     send_loops += 1
 
-            watchdog_loops += 1
-            if (watchdog_loops >= watchdog_check_after):
-                test_watchdog = self.{{cookiecutter.driver_name}}_watchdog()
-                if not test_watchdog == watchdog or (time.time() - watchdog_send_timestamp) > WATCHDOG_SEND_PERIOD:
-                    self.sendtodbDev(1, 'watchdog', test_watchdog, 0, '{{cookiecutter.driver_name}}')
-                    watchdog = test_watchdog
+            if WATCHDOG_ENABLE:
+                if (now - self.watchdog_last_checked) > WATCHDOG_CHECK_PERIOD:
+                    self._check_watchdog()
 
-                test_public_ip = get_public_ip_address()
-                if not test_public_ip == public_ip_address:
-                    self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, '{{cookiecutter.driver_name}}')
-                    public_ip_address = test_public_ip
-                watchdog_loops = 0
+            if (now - self.public_ip_address_last_checked) > IP_CHECK_PERIOD:
+                self._check_ip_address()
+
+    def _check_watchdog(self):
+        """Check the watchdog and send to Meshify if changed or stale."""
+        test_watchdog = self.{{cookiecutter.driver_name}}_watchdog()
+        now = time.time()
+        self.watchdog_last_checked = now
+        if test_watchdog != self.watchdog or (now - self.watchdog_last_sent) > WATCHDOG_SEND_PERIOD:
+            self.sendtodbDev(1, 'watchdog', test_watchdog, 0, '{{cookiecutter.driver_name}}')
+            self.watchdog = test_watchdog
+            self.watchdog_last_sent = now
+
+
+    def _check_ip_address(self):
+        """Check the public IP address and send to Meshify if changed."""
+        self.public_ip_address_last_checked = time.time()
+        test_public_ip = get_public_ip_address()
+        if not test_public_ip == self.public_ip_address:
+            self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, '{{cookiecutter.driver_name}}')
+            self.public_ip_address = test_public_ip
 
     def {{cookiecutter.driver_name}}_watchdog(self):
         """Write a random integer to the PLC and then 1 seconds later check that it has been decremented by 1."""
@@ -138,8 +138,8 @@ class start(threading.Thread, deviceBase):
         new_val = json.loads(str(value).replace("'", '"'))
         tag_n = str(new_val['tag'])  # "cmd_Start"
         val_n = new_val['val']
-        w = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n)
-        print("Result of {{cookiecutter.driver_name}}_writeplctag(self, {}, {}) = {}".format(name, value, w))
-        if w is None:
-            w = "Error writing to PLC..."
-        return w
+        write_res = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n)
+        print("Result of {{cookiecutter.driver_name}}_writeplctag(self, {}, {}) = {}".format(name, value, write_res))
+        if write_res is None:
+            write_res = "Error writing to PLC..."
+        return write_res