"""Driver for advvfdipp""" import threading import json import os import time from random import randint from datetime import datetime as dt # PERSISTENCE FILE import persistence PERSIST = persistence.load("extra_data.json") if not PERSIST: PERSIST = {'ip_address': '192.168.1.10', 'download_pycomm': True, 'flowmeter_units': 'GPM'} persistence.store(PERSIST, "extra_data.json") os.system('echo "" > /root/python_firmware/drivers/modbusMap.p') PLC_IP_ADDRESS = PERSIST['ip_address'] from device_base import deviceBase import urllib if PERSIST['download_pycomm']: try: urllib.urlretrieve('http://s3.amazonaws.com/pocloud-drivers/pycomm/clx.py', '/root/python_firmware/pycomm/ab_comm/clx.py') urllib.urlretrieve('http://s3.amazonaws.com/pocloud-drivers/pycomm/cip_base.py', '/root/python_firmware/pycomm/cip/cip_base.py') PERSIST['download_pycomm'] = False persistence.store(PERSIST, "extra_data.json") except Exception as e: print("Could not download latest pycomm update: {}".format(e)) from Channel import PLCChannel, ModbusChannel,read_tag, write_tag, TAG_DATAERROR_SLEEPTIME from utilities import get_public_ip_address, get_private_ip_address, get_additional_tags, convert_int from file_logger import filelogger as log from Tags import tags from runtimeStats import RuntimeStats as RTS path = "/root/python_firmware/drivers/additional_tags.py" print("Trying to make file?!?!?!") f = open(path, "a+") f.seek(0) if os.stat(path).st_size == 0: f.write("from Channel import PLCChannel, ModbusChannel\n") f.write("from advvfdipp import PLC_IP_ADDRESS\n") f.write("additional_tags = []") f.close() from additional_tags import additional_tags _ = None log.info("advvfdipp startup") # GLOBAL VARIABLES WAIT_FOR_CONNECTION_SECONDS = 5 IP_CHECK_PERIOD = 60 WATCHDOG_ENABLE = False WATCHDOG_CHECK_PERIOD = 60 WATCHDOG_SEND_PERIOD = 3600 # Seconds, the longest amount of time before sending the watchdog status CHANNELS = tags + additional_tags 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 = "20" self.finished = threading.Event() self.force_send = False self.public_ip_address = "" self.public_ip_address_last_checked = 0 self.private_ip_address = "" self.private_ip_address_last_checked = 0 self.watchdog = False self.watchdog_last_checked = 0 self.watchdog_last_sent = 0 self.ping_counter = 0 self.rts = RTS() self.rts.loadDataFromFile() self.rts.saveDataToFile() self.rts.manageTime() self.today = dt.now().date() 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("advvfdipp driver will start in {} seconds".format(WAIT_FOR_CONNECTION_SECONDS - i)) time.sleep(1) log.info("BOOM! Starting advvfdipp driver...") #self._check_watchdog() self._check_ip_address() self.nodes["advvfdipp_0199"] = self try: if PERSIST['flowmeter_units']: self.sendToTB(json.dumps({'flowunits': PERSIST['flowmeter_units']})) else: PERSIST['flowmeter_units'] = "GPM" persistence.store(PERSIST, "extra_data.json") self.sendToTB(json.dumps({'flowunits': PERSIST['flowmeter_units']})) except: PERSIST['flowmeter_units'] = "GPM" persistence.store(PERSIST, "extra_data.json") self.sendToTB(json.dumps({'flowunits': PERSIST['flowmeter_units']})) send_loops = 0 convert_list = ["Device_Status_INT","sts_PID_Control","Downhole_Sensor_Status_INT","alarm_Flowmeter","alarm_IntakePressure", "alarm_IntakeTemperature","alarm_TubingPressure","alarm_VFD","alarm_Lockout","alarm_FluidLevel","Run_Permissive_INT", "Start_Permissive_INT","PowerFlex755.Val_LastFaultCode","sts_CurrentVFDFaultCode"] while True: now = time.time() if self.force_send: log.warning("FORCE SEND: TRUE") if int(time.time()) % 600 == 0 or self.force_send: if self.force_send: payload = {"ts": time.time()*1000, "values": {}} else: payload = {"ts": round(time.time()/600)*600*1000, "values": {}} for chan in CHANNELS: try: val = chan.read() if "hart" in chan.mesh_name and val == None: val = 0.0 if chan.plc_tag in convert_list: converted_value = convert_int(chan.plc_tag, val) payload["values"][chan.mesh_name] = converted_value if chan.mesh_name == "wellstatus": if converted_value == "Running" and not self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["start"]: self.rts.startRun() self.rts.saveDataToFile() elif self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["start"] and not self.rts.runs[self.rts.todayString]["run_" + str(self.rts.currentRun)]["end"]: self.rts.endRun() self.rts.saveDataToFile() payload["values"]["percentRunTime30Days"] = self.rts.calculateRunPercentMultiDay() elif chan.mesh_name == "vfdfrequency": if val > 0: self.rts.addHertzDataPoint(val) self.rts.saveDataToFile() payload["values"][chan.mesh_name] = val payload["values"]["avgFrequency30Days"] = self.rts.calculateAverageHertzMultiDay() else: payload["values"][chan.mesh_name] = val except Exception as e: log.info("Error: {}".format(e)) try: self.rts.manageTime() if dt.now().date() != self.today: payload["values"]["avgFrequency30Days"] = self.rts.calculateAverageHertzMultiDay() payload["values"]["percentRunTime30Days"] = self.rts.calculateRunPercentMultiDay() self.today = dt.now().date() except Exception as e: log.error("Error: {}".format(e)) self._check_ip_address() payload["values"]["public_ip_address"] = self.public_ip_address payload["values"]["private_ip_address"] = self.private_ip_address self.sendToTB(json.dumps(payload)) self.sendToTBAttributes(json.dumps({"latestReportTime": round(time.time()/600)*600*1000})) time.sleep(10) #sleep for 30 seconds after a full poll # print("advvfdipp 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 WATCHDOG_ENABLE: if (now - self.watchdog_last_checked) > WATCHDOG_CHECK_PERIOD: self._check_watchdog() 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.advvfdipp_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, 'advvfdipp') 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() test_public_ip = test_public_ip test_private_ip = get_private_ip_address() if not test_public_ip == self.public_ip_address and not test_public_ip == "0.0.0.0": #self.sendtodbDev(1, 'public_ip_address', test_public_ip, 0, 'tankalarms') self.public_ip_address = test_public_ip if not test_private_ip == self.private_ip_address: #self.sendtodbDev(1, 'private_ip_address', test_private_ip, 0, 'tankalarms') self.private_ip_address = test_private_ip hostname = "8.8.8.8" response = 1 try: response = os.system("ping -c 1 " + hostname + " > /dev/null 2>&1") except Exception as e: print("Something went wrong in ping: {}".format(e)) #and then check the response... if response == 0: print(hostname, 'is up!') self.ping_counter = 0 else: print(hostname, 'is down!') self.ping_counter += 1 if self.ping_counter >= 3: print("Rebooting because no internet detected") os.system('reboot') def advvfdipp_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, plc_type="CLX") time.sleep(1) watchdog_val = read_tag(str(PLC_IP_ADDRESS), 'watchdog_INT', plc_type="CLX") try: return (randval - 1) == watchdog_val[0] except (KeyError, TypeError): return False def advvfdipp_sync(self, name, value): """Sync all data from the driver.""" self.force_send = True # self.sendtodb("log", "synced", 0) return True def advvfdipp_writeplctag(self, name, value): """Write a value to the PLC.""" new_val = json.loads(str(value).replace("'", '"')) tag_n = str(new_val['tag']) # "cmd_Start" val_n = new_val['val'] write_res = write_tag(str(PLC_IP_ADDRESS), tag_n, val_n, plc_type="CLX") print("Result of advvfdipp_writeplctag(self, {}, {}) = {}".format(name, value, write_res)) if write_res is None: write_res = "Error writing to PLC..." return write_res def advvfdipp_flowunits(self, name, value): new_val = json.loads(str(value).replace("'", '"')) PERSIST['flowmeter_units'] = new_val persistence.store(PERSIST, "extra_data.json") self.sendToTB(json.dumps({'flowunits': PERSIST['flowmeter_units']}))