+
+
+
diff --git a/pioneerfracskid/html-templates/NodeDetailHeader.html b/pioneerfracskid/html-templates/NodeDetailHeader.html
new file mode 100644
index 0000000..28262a3
--- /dev/null
+++ b/pioneerfracskid/html-templates/NodeDetailHeader.html
@@ -0,0 +1,6 @@
+
+
+Public IP Address
+<%= channels["pioneerfracskid.public_ip_address"].value %>
+
+
+
+
+
diff --git a/pioneerfracskid/html-templates/Nodelist.html b/pioneerfracskid/html-templates/Nodelist.html
new file mode 100644
index 0000000..756a869
--- /dev/null
+++ b/pioneerfracskid/html-templates/Nodelist.html
@@ -0,0 +1,31 @@
+
+
+<%= node.vanityname %>
+
+
diff --git a/pioneerfracskid/html-templates/Overview.html b/pioneerfracskid/html-templates/Overview.html
new file mode 100644
index 0000000..41e9634
--- /dev/null
+++ b/pioneerfracskid/html-templates/Overview.html
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+ 
+
+
+
+
+
+<%= node.vanityname %>
+
+
+
+
+
+
+
+
+
+
diff --git a/pioneerfracskid/html-templates/Sidebar.html b/pioneerfracskid/html-templates/Sidebar.html
new file mode 100644
index 0000000..7a7cd06
--- /dev/null
+++ b/pioneerfracskid/html-templates/Sidebar.html
@@ -0,0 +1,15 @@
+"
+ class="data-table btn-block btn btn-theme animated"
+ title="Device Log"> Device Log
+
+"
+ data-techname="<%=channels["pioneerfracskid.sync"].techName %>"
+ data-name="<%= channels["pioneerfracskid.sync"].name%>"
+ data-nodechannelcurrentId="<%= channels["pioneerfracskid.sync"].nodechannelcurrentId %>"
+ id="<%= channels["pioneerfracskid.sync"].channelId %>"
+ class="btn btn-large btn-block btn-theme animated setstatic mqtt">
+ Sync All Data
diff --git a/pioneerfracskid/html-templates/Trends.html b/pioneerfracskid/html-templates/Trends.html
new file mode 100644
index 0000000..77cf42f
--- /dev/null
+++ b/pioneerfracskid/html-templates/Trends.html
@@ -0,0 +1,37 @@
+
+
+ HEADER 1
+
+
+CHANNEL 1
+ +
+
+
+
+ to
+
+
+ Run
+
+
++
+
+
diff --git a/pioneerfracskid/python-driver/Channel.py b/pioneerfracskid/python-driver/Channel.py
new file mode 100644
index 0000000..fab3a3a
--- /dev/null
+++ b/pioneerfracskid/python-driver/Channel.py
@@ -0,0 +1,285 @@
+"""Define Meshify channel class."""
+from pycomm.ab_comm.clx import Driver as ClxDriver
+from pycomm.cip.cip_base import CommError, DataError
+import time
+
+
+def binarray(intval):
+ """Split an integer into its bits."""
+ bin_string = '{0:08b}'.format(intval)
+ bin_arr = [i for i in bin_string]
+ bin_arr.reverse()
+ return bin_arr
+
+
+def read_tag(addr, tag, plc_type="CLX"):
+ """Read a tag from the PLC."""
+ direct = plc_type == "Micro800"
+ c = ClxDriver()
+ try:
+ if c.open(addr, direct_connection=direct):
+ try:
+ v = c.read_tag(tag)
+ return v
+ except DataError as e:
+ c.close()
+ print("Data Error during readTag({}, {}): {}".format(addr, tag, e))
+ except CommError:
+ # err = c.get_status()
+ c.close()
+ print("Could not connect during readTag({}, {})".format(addr, tag))
+ # print err
+ except AttributeError as e:
+ c.close()
+ print("AttributeError during readTag({}, {}): \n{}".format(addr, tag, e))
+ c.close()
+ return False
+
+
+def read_array(addr, tag, start, end, plc_type="CLX"):
+ """Read an array from the PLC."""
+ direct = plc_type == "Micro800"
+ c = ClxDriver()
+ if c.open(addr, direct_connection=direct):
+ arr_vals = []
+ try:
+ for i in range(start, end):
+ tag_w_index = tag + "[{}]".format(i)
+ v = c.read_tag(tag_w_index)
+ # print('{} - {}'.format(tag_w_index, v))
+ arr_vals.append(round(v[0], 4))
+ # print(v)
+ if len(arr_vals) > 0:
+ return arr_vals
+ else:
+ print("No length for {}".format(addr))
+ return False
+ except Exception:
+ print("Error during readArray({}, {}, {}, {})".format(addr, tag, start, end))
+ err = c.get_status()
+ c.close()
+ print err
+ pass
+ c.close()
+
+
+def write_tag(addr, tag, val, plc_type="CLX"):
+ """Write a tag value to the PLC."""
+ direct = plc_type == "Micro800"
+ c = ClxDriver()
+ if c.open(addr, direct_connection=direct):
+ try:
+ cv = c.read_tag(tag)
+ wt = c.write_tag(tag, val, cv[1])
+ return wt
+ except Exception:
+ print("Error during writeTag({}, {}, {})".format(addr, tag, val))
+ err = c.get_status()
+ c.close()
+ print err
+ c.close()
+
+
+class Channel(object):
+ """Holds the configuration for a Meshify channel."""
+
+ def __init__(self, mesh_name, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+ """Initialize the channel."""
+ self.mesh_name = mesh_name
+ self.data_type = data_type
+ self.last_value = None
+ self.value = None
+ self.last_send_time = 0
+ self.chg_threshold = chg_threshold
+ self.guarantee_sec = guarantee_sec
+ self.map_ = map_
+ self.write_enabled = write_enabled
+
+ def __str__(self):
+ """Create a string for the channel."""
+ return "{}\nvalue: {}, last_send_time: {}".format(self.mesh_name, self.value, self.last_send_time)
+
+ def check(self, new_value, force_send=False):
+ """Check to see if the new_value needs to be stored."""
+ send_needed = False
+ send_reason = ""
+ if self.data_type == 'BOOL' or self.data_type == 'STRING':
+ if self.last_send_time == 0:
+ send_needed = True
+ send_reason = "no send time"
+ elif self.value is None:
+ send_needed = True
+ send_reason = "no value"
+ elif not (self.value == new_value):
+ if self.map_:
+ if not self.value == self.map_[new_value]:
+ send_needed = True
+ send_reason = "value change"
+ else:
+ send_needed = True
+ send_reason = "value change"
+ elif (time.time() - self.last_send_time) > self.guarantee_sec:
+ send_needed = True
+ send_reason = "guarantee sec"
+ elif force_send:
+ send_needed = True
+ send_reason = "forced"
+ else:
+ if self.last_send_time == 0:
+ send_needed = True
+ send_reason = "no send time"
+ elif self.value is None:
+ send_needed = True
+ send_reason = "no value"
+ elif abs(self.value - new_value) > self.chg_threshold:
+ send_needed = True
+ send_reason = "change threshold"
+ elif (time.time() - self.last_send_time) > self.guarantee_sec:
+ send_needed = True
+ send_reason = "guarantee sec"
+ elif force_send:
+ send_needed = True
+ send_reason = "forced"
+ if send_needed:
+ self.last_value = self.value
+ if self.map_:
+ try:
+ self.value = self.map_[new_value]
+ except KeyError:
+ print("Cannot find a map value for {} in {} for {}".format(new_value, self.map_, self.mesh_name))
+ self.value = new_value
+ else:
+ self.value = new_value
+ self.last_send_time = time.time()
+ print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+ return send_needed
+
+ def read(self):
+ """Read the value."""
+ pass
+
+
+def identity(sent):
+ """Return exactly what was sent to it."""
+ return sent
+
+
+class ModbusChannel(Channel):
+ """Modbus channel object."""
+
+ def __init__(self, mesh_name, register_number, data_type, chg_threshold, guarantee_sec, channel_size=1, map_=False, write_enabled=False, transformFn=identity):
+ """Initialize the channel."""
+ super(ModbusChannel, self).__init__(mesh_name, data_type, chg_threshold, guarantee_sec, map_, write_enabled)
+ self.mesh_name = mesh_name
+ self.register_number = register_number
+ self.channel_size = channel_size
+ self.data_type = data_type
+ self.last_value = None
+ self.value = None
+ self.last_send_time = 0
+ self.chg_threshold = chg_threshold
+ self.guarantee_sec = guarantee_sec
+ self.map_ = map_
+ self.write_enabled = write_enabled
+ self.transformFn = transformFn
+
+ def read(self, mbsvalue):
+ """Return the transformed read value."""
+ return self.transformFn(mbsvalue)
+
+
+class PLCChannel(Channel):
+ """PLC Channel Object."""
+
+ def __init__(self, ip, mesh_name, plc_tag, data_type, chg_threshold, guarantee_sec, map_=False, write_enabled=False):
+ """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
+ self.mesh_name = mesh_name
+ self.plc_tag = plc_tag
+ self.data_type = data_type
+ self.last_value = None
+ self.value = None
+ self.last_send_time = 0
+ self.chg_threshold = chg_threshold
+ self.guarantee_sec = guarantee_sec
+ self.map_ = map_
+ self.write_enabled = write_enabled
+
+ def compare_values(self, new_val_dict):
+ """Compare new values to old values to see if the values need storing."""
+ send = False
+ for idx in new_val_dict:
+ try:
+ if new_val_dict[idx] != self.last_value[idx]:
+ send = True
+ except KeyError:
+ print("Key Error in self.compare_values for index {}".format(idx))
+ send = True
+ return send
+
+ def read(self, force_send=False):
+ """Read the value and check to see if needs to be stored."""
+ send_needed = False
+ send_reason = ""
+ if self.plc_tag:
+ v = read_tag(self.plc_ip, self.plc_tag)
+ if v:
+ bool_arr = binarray(v[0])
+ new_val = {}
+ for idx in self.map_:
+ try:
+ new_val[self.map_[idx]] = bool_arr[idx]
+ except KeyError:
+ print("Not able to get value for index {}".format(idx))
+
+ if self.last_send_time == 0:
+ send_needed = True
+ send_reason = "no send time"
+ elif self.value is None:
+ send_needed = True
+ send_reason = "no value"
+ elif self.compare_values(new_val):
+ send_needed = True
+ send_reason = "value change"
+ elif (time.time() - self.last_send_time) > self.guarantee_sec:
+ send_needed = True
+ send_reason = "guarantee sec"
+ elif force_send:
+ send_needed = True
+ send_reason = "forced"
+
+ if send_needed:
+ self.value = new_val
+ self.last_value = self.value
+ self.last_send_time = time.time()
+ print("Sending {} for {} - {}".format(self.value, self.mesh_name, send_reason))
+ return send_needed
diff --git a/pioneerfracskid/python-driver/Channel.pyc b/pioneerfracskid/python-driver/Channel.pyc
new file mode 100644
index 0000000..b356c89
Binary files /dev/null and b/pioneerfracskid/python-driver/Channel.pyc differ
diff --git a/pioneerfracskid/python-driver/config.txt b/pioneerfracskid/python-driver/config.txt
new file mode 100644
index 0000000..207a718
--- /dev/null
+++ b/pioneerfracskid/python-driver/config.txt
@@ -0,0 +1,12 @@
+{
+ "files": {
+ "file3": "persistence.py",
+ "file2": "utilities.py",
+ "file1": "fracskid.py",
+ "file4": "Channel.py"
+ },
+ "deviceName": "fracskid",
+ "driverId": "0200",
+ "releaseVersion": "1",
+ "driverFileName": "fracskid.py"
+}
\ No newline at end of file
diff --git a/pioneerfracskid/python-driver/driverConfig.json b/pioneerfracskid/python-driver/driverConfig.json
new file mode 100644
index 0000000..0baf6d2
--- /dev/null
+++ b/pioneerfracskid/python-driver/driverConfig.json
@@ -0,0 +1,12 @@
+{
+ "name": "fracskid",
+ "driverFilename": "fracskid.py",
+ "driverId": "0000",
+ "additionalDriverFiles": [
+ "utilities.py",
+ "persistence.py",
+ "Channel.py"
+ ],
+ "version": 1,
+ "s3BucketName": "fracskid"
+}
\ No newline at end of file
diff --git a/pioneerfracskid/python-driver/fracskid.py b/pioneerfracskid/python-driver/fracskid.py
new file mode 100644
index 0000000..e59da5a
--- /dev/null
+++ b/pioneerfracskid/python-driver/fracskid.py
@@ -0,0 +1,142 @@
+"""Driver for fracskid"""
+
+import threading
+import sys
+from device_base import deviceBase
+from Channel import Channel, read_tag, write_tag
+import persistence
+from random import randint
+from utilities import get_public_ip_address
+import json
+import time
+import logging
+
+
+# LOGGING SETUP
+from logging.handlers import RotatingFileHandler
+
+_ = None
+
+
+log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(%(lineno)d) %(message)s')
+logFile = './fracskid.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('fracskid')
+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("fracskid startup")
+
+# GLOBAL VARIABLES
+WATCHDOG_SEND_PERIOD = 3600 # Seconds, the longest amount of time before sending the watchdog status
+PLC_IP_ADDRESS = "10.20.4.40"
+CHANNELS = []
+
+# 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.forceSend = False
+ threading.Thread.start(self)
+
+ # this is a required function for all drivers, its goal is to upload some piece of data
+ # about your device so it can be seen on the web
+ def register(self):
+ """Register the driver."""
+ # self.sendtodb("log", "BOOM! Booted.", 0)
+ pass
+
+ def run(self):
+ """Actually run the driver."""
+ global persist
+ wait_sec = 60
+ for i in range(0, wait_sec):
+ print("fracskid driver will start in {} seconds".format(wait_sec - i))
+ time.sleep(1)
+ logger.info("BOOM! Starting fracskid driver...")
+
+ public_ip_address = get_public_ip_address()
+ self.sendtodbDev(1, 'public_ip_address', public_ip_address, 0, 'fracskid')
+ watchdog = self.fracskid_watchdog()
+ self.sendtodbDev(1, 'watchdog', watchdog, 0, 'fracskid')
+ watchdog_send_timestamp = time.time()
+
+ send_loops = 0
+ watchdog_loops = 0
+ watchdog_check_after = 5000
+ while True:
+ if self.forceSend:
+ logger.warning("FORCE SEND: TRUE")
+
+ gps = self.mcu.gps.split(',')
+ latitude = float(gps[0])
+ longitude = float(gps[1])
+ write_tag(PLC_IP_ADDRESS, "skid_latitude", latitude, plc_type="Micro800")
+ write_tag(PLC_IP_ADDRESS, "skid_longitude", longitude, plc_type="Micro800")
+ logger.info("Wrote {},{} to PLC at {}.".format(latitude, longitude, PLC_IP_ADDRESS))
+ if self.forceSend:
+ if send_loops > 2:
+ logger.warning("Turning off forceSend")
+ self.forceSend = False
+ send_loops = 0
+ else:
+ send_loops += 1
+
+ watchdog_loops += 1
+ if (watchdog_loops >= watchdog_check_after):
+ test_watchdog = self.fracskid_watchdog()
+ if not test_watchdog == watchdog or (time.time() - watchdog_send_timestamp) > WATCHDOG_SEND_PERIOD:
+ self.sendtodbDev(1, 'watchdog', test_watchdog, 0, 'fracskid')
+ watchdog = test_watchdog
+
+ test_public_ip = get_public_ip_address()
+ if not test_public_ip == public_ip_address:
+ self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, 'fracskid')
+ public_ip_address = test_public_ip
+ watchdog_loops = 0
+ time.sleep(10)
+
+ def fracskid_watchdog(self):
+ """Write a random integer to the PLC and then 1 seconds later check that it has been decremented by 1."""
+ randval = randint(0, 32767)
+ write_tag(str(PLC_IP_ADDRESS), 'watchdog_INT', randval)
+ time.sleep(1)
+ watchdog_val = read_tag(str(PLC_IP_ADDRESS), 'watchdog_INT')
+ try:
+ return (randval - 1) == watchdog_val[0]
+ except (KeyError, TypeError):
+ return False
+
+ def fracskid_sync(self, name, value):
+ """Sync all data from the driver."""
+ self.forceSend = True
+ # self.sendtodb("log", "synced", 0)
+ return True
+
+ def fracskid_writeplctag(self, name, value):
+ """Write a value to the PLC."""
+ new_val = json.loads(str(value).replace("'", '"'))
+ tag_n = str(new_val['tag']) # "cmd_Start"
+ val_n = new_val['val']
+ w = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n)
+ print("Result of fracskid_writeplctag(self, {}, {}) = {}".format(name, value, w))
+ if w is None:
+ w = "Error writing to PLC..."
+ return w
diff --git a/pioneerfracskid/python-driver/persistence.py b/pioneerfracskid/python-driver/persistence.py
new file mode 100644
index 0000000..ed65271
--- /dev/null
+++ b/pioneerfracskid/python-driver/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)
+ except Exception:
+ return False
diff --git a/pioneerfracskid/python-driver/utilities.py b/pioneerfracskid/python-driver/utilities.py
new file mode 100644
index 0000000..70ae1bf
--- /dev/null
+++ b/pioneerfracskid/python-driver/utilities.py
@@ -0,0 +1,54 @@
+"""Utility functions for the driver."""
+import socket
+import struct
+
+
+def get_public_ip_address():
+ """Find the public IP Address of the host device."""
+ s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ s.connect(("8.8.8.8", 80))
+ ip = s.getsockname()[0]
+ s.close()
+ return ip
+
+
+def int_to_float16(int_to_convert):
+ """Convert integer into float16 representation."""
+ bin_rep = ('0' * 16 + '{0:b}'.format(int_to_convert))[-16:]
+ sign = 1.0
+ if int(bin_rep[0]) == 1:
+ sign = -1.0
+ exponent = float(int(bin_rep[1:6], 2))
+ if exponent == 30:
+ fraction = float(int("1" + bin_rep[7:17], 2))
+ else:
+ fraction = float(int(bin_rep[7: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
diff --git a/pioneerfracskid/python-driver/utilities.pyc b/pioneerfracskid/python-driver/utilities.pyc
new file mode 100644
index 0000000..32a598c
Binary files /dev/null and b/pioneerfracskid/python-driver/utilities.pyc differ