Driver Updates

tanktransfer/python-driver/Channel.py

@@ -12,17 +12,18 @@ def binarray(intval):
     return bin_arr
 
 
-def read_tag(addr, tag):
+def read_tag(addr, tag, plc_type="CLX"):
     """Read a tag from the PLC."""
+    direct = plc_type == "Micro800"
     c = ClxDriver()
     try:
-        if c.open(addr):
+        if c.open(addr, direct_connection=direct):
             try:
                 v = c.read_tag(tag)
                 return v
-            except DataError:
+            except DataError as e:
                 c.close()
-                print("Data Error during readTag({}, {})".format(addr, tag))
+                print("Data Error during readTag({}, {}): {}".format(addr, tag, e))
     except CommError:
         # err = c.get_status()
         c.close()
@@ -35,10 +36,11 @@ def read_tag(addr, tag):
     return False
 
 
-def read_array(addr, tag, start, end):
+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):
+    if c.open(addr, direct_connection=direct):
         arr_vals = []
         try:
             for i in range(start, end):
@@ -61,12 +63,14 @@ def read_array(addr, tag, start, end):
         c.close()
 
 
-def write_tag(addr, tag, val):
+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):
+    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:
@@ -77,9 +81,146 @@ def write_tag(addr, tag, val):
         c.close()
 
 
-class Channel:
+class Channel(object):
     """Holds the configuration for a Meshify channel."""
 
+    def __init__(self, mesh_name, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+        """Initialize the channel."""
+        self.mesh_name = mesh_name
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+
+    def __str__(self):
+        """Create a string for the channel."""
+        return "{}\nvalue: {},  last_send_time: {}".format(self.mesh_name, self.value, self.last_send_time)
+
+    def check(self, new_value, force_send=False):
+        """Check to see if the new_value needs to be stored."""
+        send_needed = False
+        send_reason = ""
+        if self.data_type == 'BOOL' or self.data_type == 'STRING':
+            if self.last_send_time == 0:
+                send_needed = True
+                send_reason = "no send time"
+            elif self.value is None:
+                send_needed = True
+                send_reason = "no value"
+            elif not (self.value == new_value):
+                if self.map_:
+                    if not self.value == self.map_[new_value]:
+                        send_needed = True
+                        send_reason = "value change"
+                else:
+                    send_needed = True
+                    send_reason = "value change"
+            elif (time.time() - self.last_send_time) > self.guarantee_sec:
+                send_needed = True
+                send_reason = "guarantee sec"
+            elif force_send:
+                send_needed = True
+                send_reason = "forced"
+        else:
+            if self.last_send_time == 0:
+                send_needed = True
+                send_reason = "no send time"
+            elif self.value is None:
+                send_needed = True
+                send_reason = "no value"
+            elif abs(self.value - new_value) > self.chg_threshold:
+                send_needed = True
+                send_reason = "change threshold"
+            elif (time.time() - self.last_send_time) > self.guarantee_sec:
+                send_needed = True
+                send_reason = "guarantee sec"
+            elif force_send:
+                send_needed = True
+                send_reason = "forced"
+        if send_needed:
+            self.last_value = self.value
+            if self.map_:
+                try:
+                    self.value = self.map_[new_value]
+                except KeyError:
+                    print("Cannot find a map value for {} in {} for {}".format(new_value, self.map_, self.mesh_name))
+                    self.value = new_value
+            else:
+                self.value = new_value
+            self.last_send_time = time.time()
+            print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+        return send_needed
+
+    def read(self):
+        """Read the value."""
+        pass
+
+
+def identity(sent):
+    """Return exactly what was sent to it."""
+    return sent
+
+
+class ModbusChannel(Channel):
+    """Modbus channel object."""
+
+    def __init__(self, mesh_name, register_number, data_type, chg_threshold, guarantee_sec, channel_size=1, map_=False, write_enabled=False, transformFn=identity):
+        """Initialize the channel."""
+        super(ModbusChannel, self).__init__(mesh_name, data_type, chg_threshold, guarantee_sec, map_, write_enabled)
+        self.mesh_name = mesh_name
+        self.register_number = register_number
+        self.channel_size = channel_size
+        self.data_type = data_type
+        self.last_value = None
+        self.value = None
+        self.last_send_time = 0
+        self.chg_threshold = chg_threshold
+        self.guarantee_sec = guarantee_sec
+        self.map_ = map_
+        self.write_enabled = write_enabled
+        self.transformFn = transformFn
+
+    def read(self, mbsvalue):
+        """Return the transformed read value."""
+        return self.transformFn(mbsvalue)
+
+
+class PLCChannel(Channel):
+    """PLC Channel Object."""
+
+    def __init__(self, ip, mesh_name, plc_tag, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+        """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
+
+    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)
+            if read_value:
+                plc_value = read_value[0]
+
+        return plc_value
+
+
+class BoolArrayChannels(Channel):
+    """Hold the configuration for a set of boolean array channels."""
+
     def __init__(self, ip, mesh_name, plc_tag, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
         """Initialize the channel."""
         self.plc_ip = ip
@@ -94,72 +235,6 @@ class Channel:
         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.plc_tag, self.value, self.last_send_time)
-
-    def read(self, force_send=False):
-        """Read the value and check to see if needs to be stored."""
-        send_needed = False
-        send_reason = ""
-        if self.plc_tag:
-            v = read_tag(self.plc_ip, self.plc_tag)
-            if v:
-                if self.data_type == 'BOOL' or self.data_type == 'STRING':
-                    if self.last_send_time == 0:
-                        send_needed = True
-                        send_reason = "no send time"
-                    elif self.value is None:
-                        send_needed = True
-                        send_reason = "no value"
-                    elif not (self.value == v[0]):
-                        if self.map_:
-                            if not self.value == self.map_[v[0]]:
-                                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 - v[0]) > 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_[v[0]]
-                        except KeyError:
-                            print("Cannot find a map value for {} in {} for {}".format(v[0], self.map_, self.mesh_name))
-                            self.value = v[0]
-                    else:
-                        self.value = v[0]
-                    self.last_send_time = time.time()
-                    print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
-        return send_needed
-
-
-class BoolArrayChannels(Channel):
-    """Hold the configuration for a set of boolean array channels."""
-
     def compare_values(self, new_val_dict):
         """Compare new values to old values to see if the values need storing."""
         send = False

tanktransfer/python-driver/Maps.py

@@ -1,10 +0,0 @@
-"""Holds map values for tanktransfer."""
-
-tanktransfer_map = {}
-
-def reverse_map(value, map_):
-    """Perform the opposite of mapping to an object."""
-    for x in map_:
-        if map_[x] == value:
-            return x
-    return None

tanktransfer/python-driver/config.txt

@@ -1,14 +0,0 @@
-{
-
-"driverFileName":"tanktransfer.py",
-"deviceName":"tanktransfer",
-"driverId":"150",
-"releaseVersion":"1",
-"files": {
-	"file1":"tanktransfer.py",
-	"file2":"Channel.py",
-	"file3":"Maps.py",
-	"file4":"Scheduler.py"
-	}
-
-}

tanktransfer/python-driver/driverConfig.json

@@ -1,13 +1,12 @@
 {
-    "name": "tanktransfer", 
+    "name": "tanktransfer",
-    "driverFilename": "tanktransfer.py", 
+    "driverFilename": "tanktransfer.py",
-    "driverId": "0000", 
+    "driverId": "0000",
     "additionalDriverFiles": [
         "utilities.py",
         "persistence.py",
-        "Channel.py",
+        "Channel.py"
-        "Maps.py"
+    ],
-    ], 
+    "version": 1,
-    "version": 1, 
     "s3BucketName": "tanktransfer"
-}
+}

tanktransfer/python-driver/tanktransfer.py

@@ -1,6 +1,7 @@
 """Driver for tanktransfer"""
 
 import threading
+import sys
 from device_base import deviceBase
 from Channel import Channel, read_tag, write_tag, BoolArrayChannels
 from Maps import tanktransfer_map as maps
@@ -10,9 +11,28 @@ from random import randint
 from utilities import get_public_ip_address
 import json
 import time
+import logging
 
 _ = None
 
+# LOGGING SETUP
+from logging.handlers import RotatingFileHandler
+
+log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
+logFile = './tanktransfer.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('tanktransfer')
+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("tanktransfer startup")
+
 # GLOBAL VARIABLES
 WATCHDOG_SEND_PERIOD = 3600  # Seconds, the longest amount of time before sending the watchdog status
 PLC_IP_ADDRESS = "192.168.1.10"
@@ -50,7 +70,7 @@ class start(threading.Thread, deviceBase):
         for i in range(0, wait_sec):
             print("tanktransfer driver will start in {} seconds".format(wait_sec - i))
             time.sleep(1)
-        print("BOOM! Starting tanktransfer driver...")
+        logger.info("BOOM! Starting tanktransfer driver...")
 
         public_ip_address = get_public_ip_address()
         self.sendtodbDev(1, 'public_ip_address', public_ip_address, 0, 'tanktransfer')
@@ -63,7 +83,7 @@ class start(threading.Thread, deviceBase):
         watchdog_check_after = 5000
         while True:
             if self.forceSend:
-                print "FORCE SEND: TRUE"
+                logger.warning("FORCE SEND: TRUE")
 
             for c in CHANNELS:
                 if c.read(self.forceSend):
@@ -73,7 +93,7 @@ class start(threading.Thread, deviceBase):
             # print("tanktransfer driver still alive...")
             if self.forceSend:
                 if send_loops > 2:
-                    print("Turning off forceSend")
+                    logger.warning("Turning off forceSend")
                     self.forceSend = False
                     send_loops = 0
                 else:

tanktransfer/python-driver/utilities.py

@@ -1,5 +1,6 @@
 """Utility functions for the driver."""
 import socket
+import struct
 
 
 def get_public_ip_address():
@@ -9,3 +10,42 @@ def get_public_ip_address():
     ip = s.getsockname()[0]
     s.close()
     return ip
+
+
+def int_to_float16(int_to_convert):
+    """Convert integer into float16 representation."""
+    bin_rep = ('0' * 16 + '{0:b}'.format(int_to_convert))[-16:]
+    sign = 1.0
+    if int(bin_rep[0]) == 1:
+        sign = -1.0
+    exponent = float(int(bin_rep[1:6], 2))
+    fraction = float(int(bin_rep[6:17], 2))
+
+    if exponent == float(0b00000):
+        return sign * 2 ** -14 * fraction / (2.0 ** 10.0)
+    elif exponent == float(0b11111):
+        if fraction == 0:
+            return sign * float("inf")
+        else:
+            return float("NaN")
+    else:
+        frac_part = 1.0 + fraction / (2.0 ** 10.0)
+        return sign * (2 ** (exponent - 15)) * frac_part
+
+
+def ints_to_float(int1, int2):
+    """Convert 2 registers into a floating point number."""
+    mypack = struct.pack('>HH', int1, int2)
+    f = struct.unpack('>f', mypack)
+    print("[{}, {}] >> {}".format(int1, int2, f[0]))
+    return f[0]
+
+
+def degf_to_degc(temp_f):
+    """Convert deg F to deg C."""
+    return (temp_f - 32.0) * (5.0/9.0)
+
+
+def degc_to_degf(temp_c):
+    """Convert deg C to deg F."""
+    return temp_c * 1.8 + 32.0