610 lines
31 KiB
Python
610 lines
31 KiB
Python
#!/usr/bin/python
|
|
|
|
import threading
|
|
import time
|
|
import pickle
|
|
from device_base import deviceBase
|
|
import micro800 as u800
|
|
|
|
min_upload_time = 30
|
|
addr = '10.20.4.5'
|
|
|
|
|
|
class start(threading.Thread, deviceBase):
|
|
channels = {}
|
|
|
|
def updateGPS(self):
|
|
gps = self.mcu.gps
|
|
print("GPS found me at {0}".format(gps))
|
|
self.sendtodb("gps", gps, 0)
|
|
|
|
def setupChannels(self):
|
|
with open('drivers/ipp_channels.p', 'rb') as ch_f:
|
|
self.channels = pickle.load(ch_f)
|
|
print("Channel List\n================")
|
|
for x in self.channels.keys():
|
|
print x
|
|
print("================")
|
|
|
|
def __init__(self, name=None, number=None, mac=None, Q=None, mcu=None, companyId=None, offset=None, mqtt=None, Nodes=None):
|
|
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.device_address = addr
|
|
self.finished = threading.Event()
|
|
threading.Thread.start(self)
|
|
self.sendtodbJSON("device_address", self.device_address, 0)
|
|
self.setupChannels()
|
|
# self.updateGPS()
|
|
|
|
# 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):
|
|
self.channels["status"]["last_value"] = ""
|
|
|
|
def run(self):
|
|
print("****************\n*************\nEXECUTING RUN\n********************\n****************")
|
|
self.runLoopStatus = ""
|
|
last_OK_state = 0
|
|
while True:
|
|
if len(self.channels) > 0:
|
|
try:
|
|
for i in self.channels:
|
|
runLoopStatus = i
|
|
print("reading {0}".format(i))
|
|
valData = u800.readMicroTag(self.device_address, self.channels[i]['tag'])
|
|
print(valData)
|
|
if valData:
|
|
nowVal = round(valData[0], 4)
|
|
ch = self.channels[i]
|
|
if ch['data_type'] == "BOOL":
|
|
if ch['last_value'] == "":
|
|
self.sendtodbJSON(i, nowVal, 0)
|
|
ch['last_time_uploaded'] = time.time()
|
|
ch['last_value'] = nowVal
|
|
elif (not (ch['last_value'] == nowVal)) or ((time.time() - ch['last_time_uploaded']) > ch['max_time_between_uploads']):
|
|
self.sendtodbJSON(i, nowVal, 0)
|
|
ch['last_time_uploaded'] = time.time()
|
|
ch['last_value'] = nowVal
|
|
if (ch['data_type'] == "REAL") or (ch['data_type'][-3:] == "INT"):
|
|
if ch['last_value'] == "":
|
|
self.sendtodbJSON(i, nowVal, 0)
|
|
ch['last_time_uploaded'] = time.time()
|
|
ch['last_value'] = nowVal
|
|
elif (abs(ch['last_value'] - nowVal) > ch['change_amount']) or ((time.time() - ch['last_time_uploaded']) > ch['max_time_between_uploads']):
|
|
self.sendtodbJSON(i, nowVal, 0)
|
|
ch['last_time_uploaded'] = time.time()
|
|
ch['last_value'] = nowVal
|
|
|
|
runLoopStatus = "Complete"
|
|
OK_state = 1
|
|
if not OK_state == last_OK_state:
|
|
self.sendtodbJSON("driver_ok", OK_state, 0)
|
|
last_OK_state = OK_state
|
|
time.sleep(10)
|
|
except Exception, e:
|
|
OK_state = 0
|
|
if not OK_state == last_OK_state:
|
|
self.sendtodbJSON("driver_ok", OK_state, 0)
|
|
last_OK_state = OK_state
|
|
sleep_timer = 30
|
|
print "Error during {0} of run loop: {1}\nWill try again in {2} seconds...".format(runLoopStatus, e, sleep_timer)
|
|
time.sleep(sleep_timer)
|
|
else:
|
|
print("Apparently no self.channels... length shows {0}".format(len(self.channels)))
|
|
print self.channels
|
|
self.setupChannels()
|
|
time.sleep(30)
|
|
|
|
def write_vfdconfig(self):
|
|
print("Writing config to drive")
|
|
return u800.writeMicroTag(addr, 'VFD_Write', 1)
|
|
|
|
def vfdipp_sync(self, name, value):
|
|
self.sendtodb("connected", "true", 0)
|
|
return True
|
|
|
|
def vfdipp_address(self, name, value):
|
|
self.device_address = value
|
|
return True
|
|
|
|
def vfdipp_gpsUpdate(self, name, value):
|
|
self.updateGPS()
|
|
return True
|
|
|
|
# ======== AUTOMATICALLY GENERATED TAG WRITE FUNCTIONS BELOW HERE ===========
|
|
|
|
def vfdipp_cfgCFLASetting(self, name, value):
|
|
print('trying to set cfg_C_FLASetting to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_C_FLASetting', float(value))
|
|
|
|
def vfdipp_cfgCTripEnableControl(self, name, value):
|
|
print('trying to set cfg_C_TripEnableControl to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_C_TripEnableControl', int(value))
|
|
|
|
def vfdipp_cfgCWarningEnableControl(self, name, value):
|
|
print('trying to set cfg_C_WarningEnableControl to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_C_WarningEnableControl', int(value))
|
|
|
|
def vfdipp_cfgClearTripCountAfter(self, name, value):
|
|
print('trying to set cfg_ClearTripCountAfter to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_ClearTripCountAfter', int(value))
|
|
|
|
def vfdipp_cfgGFGroundFaultInhibitTime(self, name, value):
|
|
print('trying to set cfg_GF_GroundFaultInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgGFGroundFaultTripDelay(self, name, value):
|
|
print('trying to set cfg_GF_GroundFaultTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultTripDelay', float(value))
|
|
|
|
def vfdipp_cfgGFGroundFaultTripLevel(self, name, value):
|
|
print('trying to set cfg_GF_GroundFaultTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultTripLevel', float(value))
|
|
|
|
def vfdipp_cfgGFGroundFaultWarningDelay(self, name, value):
|
|
print('trying to set cfg_GF_GroundFaultWarningDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultWarningDelay', float(value))
|
|
|
|
def vfdipp_cfgGFGroundFaultWarningLevel(self, name, value):
|
|
print('trying to set cfg_GF_GroundFaultWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultWarningLevel', float(value))
|
|
|
|
def vfdipp_cfgICTPrimary(self, name, value):
|
|
print('trying to set cfg_I_CTPrimary to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CTPrimary', int(value))
|
|
|
|
def vfdipp_cfgICTSecondary(self, name, value):
|
|
print('trying to set cfg_I_CTSecondary to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CTSecondary', int(value))
|
|
|
|
def vfdipp_cfgICurrentImbalanceInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_CurrentImbalanceInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgICurrentImbalanceTripDelay(self, name, value):
|
|
print('trying to set cfg_I_CurrentImbalanceTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceTripDelay', int(value))
|
|
|
|
def vfdipp_cfgICurrentImbalanceTripLevel(self, name, value):
|
|
print('trying to set cfg_I_CurrentImbalanceTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceTripLevel', int(value))
|
|
|
|
def vfdipp_cfgICurrentImbalanceWarningLevel(self, name, value):
|
|
print('trying to set cfg_I_CurrentImbalanceWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgIJamInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_JamInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_JamInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgIJamTripDelay(self, name, value):
|
|
print('trying to set cfg_I_JamTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_JamTripDelay', int(value))
|
|
|
|
def vfdipp_cfgIJamWarningLevel(self, name, value):
|
|
print('trying to set cfg_I_JamWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_JamWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgILineLossInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_LineLossInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_LineLossInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgILineLossTripDelay(self, name, value):
|
|
print('trying to set cfg_I_LineLossTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_LineLossTripDelay', float(value))
|
|
|
|
def vfdipp_cfgIOvercurrentInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_OvercurrentInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_OvercurrentInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgIOvercurrentTripDelay(self, name, value):
|
|
print('trying to set cfg_I_OvercurrentTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_OvercurrentTripDelay', float(value))
|
|
|
|
def vfdipp_cfgIOvercurrentTripLevel(self, name, value):
|
|
print('trying to set cfg_I_OvercurrentTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_OvercurrentTripLevel', int(value))
|
|
|
|
def vfdipp_cfgIOvercurrentWarningLevel(self, name, value):
|
|
print('trying to set cfg_I_OvercurrentWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_OvercurrentWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgIStallEnabledTime(self, name, value):
|
|
print('trying to set cfg_I_StallEnabledTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_StallEnabledTime', int(value))
|
|
|
|
def vfdipp_cfgIStallTripLevel(self, name, value):
|
|
print('trying to set cfg_I_StallTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_StallTripLevel', int(value))
|
|
|
|
def vfdipp_cfgIUndercurrentInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_UndercurrentInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UndercurrentInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgIUndercurrentTripDelay(self, name, value):
|
|
print('trying to set cfg_I_UndercurrentTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UndercurrentTripDelay', float(value))
|
|
|
|
def vfdipp_cfgIUndercurrentTripLevel(self, name, value):
|
|
print('trying to set cfg_I_UndercurrentTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UndercurrentTripLevel', int(value))
|
|
|
|
def vfdipp_cfgIUndercurrentWarningLevel(self, name, value):
|
|
print('trying to set cfg_I_UndercurrentWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UndercurrentWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgIUnderloadInhibitTime(self, name, value):
|
|
print('trying to set cfg_I_UnderloadInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UnderloadInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgIUnderloadTripDelay(self, name, value):
|
|
print('trying to set cfg_I_UnderloadTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UnderloadTripDelay', float(value))
|
|
|
|
def vfdipp_cfgIUnderloadTripLevel(self, name, value):
|
|
print('trying to set cfg_I_UnderloadTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UnderloadTripLevel', int(value))
|
|
|
|
def vfdipp_cfgIUnderloadWarningLevel(self, name, value):
|
|
print('trying to set cfg_I_UnderloadWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_I_UnderloadWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgOverloadTripCountLimit(self, name, value):
|
|
print('trying to set cfg_OverloadTripCountLimit to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_OverloadTripCountLimit', int(value))
|
|
|
|
def vfdipp_cfgPLPhaseLossInhibitTime(self, name, value):
|
|
print('trying to set cfg_PL_PhaseLossInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_PL_PhaseLossInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgPLPhaseLossTripDelay(self, name, value):
|
|
print('trying to set cfg_PL_PhaseLossTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_PL_PhaseLossTripDelay', float(value))
|
|
|
|
def vfdipp_cfgREAD(self, name, value):
|
|
print('trying to set cfg_READ to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_READ', int(value))
|
|
|
|
def vfdipp_cfgSpecificGravity(self, name, value):
|
|
print('trying to set cfg_SpecificGravity to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_SpecificGravity', float(value))
|
|
|
|
def vfdipp_cfgTCUTripClass(self, name, value):
|
|
print('trying to set cfg_TCU_TripClass to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_TCU_TripClass', int(value))
|
|
|
|
def vfdipp_cfgTimerModeEnabled(self, name, value):
|
|
print('trying to set cfg_TimerModeEnabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_TimerModeEnabled', int(value))
|
|
|
|
def vfdipp_cfgTimerRunTime(self, name, value):
|
|
print('trying to set cfg_TimerRunTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_TimerRunTime', int(value))
|
|
|
|
def vfdipp_cfgTimerWaitTime(self, name, value):
|
|
print('trying to set cfg_TimerWaitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_TimerWaitTime', int(value))
|
|
|
|
def vfdipp_cfgTripCountLimit(self, name, value):
|
|
print('trying to set cfg_TripCountLimit to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_TripCountLimit', int(value))
|
|
|
|
def vfdipp_cfgVOverfrequencyInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_OverfrequencyInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVOverfrequencyTripDelay(self, name, value):
|
|
print('trying to set cfg_V_OverfrequencyTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyTripDelay', float(value))
|
|
|
|
def vfdipp_cfgVOverfrequencyTripLevel(self, name, value):
|
|
print('trying to set cfg_V_OverfrequencyTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyTripLevel', int(value))
|
|
|
|
def vfdipp_cfgVOverfrequencyWarningLevel(self, name, value):
|
|
print('trying to set cfg_V_OverfrequencyWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgVOvervoltageInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_OvervoltageInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OvervoltageInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVOvervoltageTripDelay(self, name, value):
|
|
print('trying to set cfg_V_OvervoltageTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OvervoltageTripDelay', float(value))
|
|
|
|
def vfdipp_cfgVOvervoltageTripLevel(self, name, value):
|
|
print('trying to set cfg_V_OvervoltageTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OvervoltageTripLevel', float(value))
|
|
|
|
def vfdipp_cfgVOvervoltageWarningLevel(self, name, value):
|
|
print('trying to set cfg_V_OvervoltageWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_OvervoltageWarningLevel', float(value))
|
|
|
|
def vfdipp_cfgVPTPrimary(self, name, value):
|
|
print('trying to set cfg_V_PTPrimary to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_PTPrimary', int(value))
|
|
|
|
def vfdipp_cfgVPTSecondary(self, name, value):
|
|
print('trying to set cfg_V_PTSecondary to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_PTSecondary', int(value))
|
|
|
|
def vfdipp_cfgVPhaseRotationInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_PhaseRotationInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_PhaseRotationInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVPhaseRotationTripType(self, name, value):
|
|
print('trying to set cfg_V_PhaseRotationTripType to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_PhaseRotationTripType', int(value))
|
|
|
|
def vfdipp_cfgVUnderfrequencyInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_UnderfrequencyInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVUnderfrequencyTripDelay(self, name, value):
|
|
print('trying to set cfg_V_UnderfrequencyTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyTripDelay', float(value))
|
|
|
|
def vfdipp_cfgVUnderfrequencyTripLevel(self, name, value):
|
|
print('trying to set cfg_V_UnderfrequencyTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyTripLevel', int(value))
|
|
|
|
def vfdipp_cfgVUnderfrequencyWarningLevel(self, name, value):
|
|
print('trying to set cfg_V_UnderfrequencyWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgVUndervoltageInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_UndervoltageInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UndervoltageInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVUndervoltageTripDelay(self, name, value):
|
|
print('trying to set cfg_V_UndervoltageTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UndervoltageTripDelay', float(value))
|
|
|
|
def vfdipp_cfgVUndervoltageTripLevel(self, name, value):
|
|
print('trying to set cfg_V_UndervoltageTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UndervoltageTripLevel', float(value))
|
|
|
|
def vfdipp_cfgVUndervoltageWarningLevel(self, name, value):
|
|
print('trying to set cfg_V_UndervoltageWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_UndervoltageWarningLevel', float(value))
|
|
|
|
def vfdipp_cfgVVoltageImbalanceInhibitTime(self, name, value):
|
|
print('trying to set cfg_V_VoltageImbalanceInhibitTime to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceInhibitTime', int(value))
|
|
|
|
def vfdipp_cfgVVoltageImbalanceTripDelay(self, name, value):
|
|
print('trying to set cfg_V_VoltageImbalanceTripDelay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceTripDelay', float(value))
|
|
|
|
def vfdipp_cfgVVoltageImbalanceTripLevel(self, name, value):
|
|
print('trying to set cfg_V_VoltageImbalanceTripLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceTripLevel', int(value))
|
|
|
|
def vfdipp_cfgVVoltageImbalanceWarningLevel(self, name, value):
|
|
print('trying to set cfg_V_VoltageImbalanceWarningLevel to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceWarningLevel', int(value))
|
|
|
|
def vfdipp_cfgVVoltageMode(self, name, value):
|
|
print('trying to set cfg_V_VoltageMode to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_V_VoltageMode', int(value))
|
|
|
|
def vfdipp_cfgWRITE(self, name, value):
|
|
print('trying to set cfg_WRITE to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'cfg_WRITE', int(value))
|
|
|
|
def vfdipp_downtimeTimeParameter(self, name, value):
|
|
print('trying to set Downtime_Time_Parameter to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Downtime_Time_Parameter', int(value))
|
|
|
|
def vfdipp_downtimeTimeParameterOL(self, name, value):
|
|
print('trying to set Downtime_Time_Parameter_OL to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Downtime_Time_Parameter_OL', int(value))
|
|
|
|
def vfdipp_pressureAlarmDelay(self, name, value):
|
|
print('trying to set Pressure_Alarm_Delay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Alarm_Delay', int(value))
|
|
|
|
def vfdipp_pressureAlarmStartupDelay(self, name, value):
|
|
print('trying to set Pressure_Alarm_Startup_Delay to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Alarm_Startup_Delay', int(value))
|
|
|
|
def vfdipp_pressureEUMax(self, name, value):
|
|
print('trying to set Pressure_EU_Max to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_EU_Max', float(value))
|
|
|
|
def vfdipp_pressureEUMin(self, name, value):
|
|
print('trying to set Pressure_EU_Min to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_EU_Min', float(value))
|
|
|
|
def vfdipp_pressureHiSP(self, name, value):
|
|
print('trying to set Pressure_Hi_SP to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Hi_SP', float(value))
|
|
|
|
def vfdipp_pressureLoSP(self, name, value):
|
|
print('trying to set Pressure_Lo_SP to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Lo_SP', float(value))
|
|
|
|
def vfdipp_pressureShutdown(self, name, value):
|
|
print('trying to set Pressure_Shutdown to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Shutdown', float(value))
|
|
|
|
def vfdipp_pressureShutdownEnabled(self, name, value):
|
|
print('trying to set Pressure_Shutdown_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Shutdown_Enabled', int(value))
|
|
|
|
def vfdipp_pressureStartup(self, name, value):
|
|
print('trying to set Pressure_Startup to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Startup', float(value))
|
|
|
|
def vfdipp_pressureStartupEnabled(self, name, value):
|
|
print('trying to set Pressure_Startup_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Startup_Enabled', int(value))
|
|
|
|
def vfdipp_pressureSwitchEnabled(self, name, value):
|
|
print('trying to set Pressure_Switch_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Switch_Enabled', int(value))
|
|
|
|
def vfdipp_pressureTransducerEnabled(self, name, value):
|
|
print('trying to set Pressure_Transducer_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Pressure_Transducer_Enabled', int(value))
|
|
|
|
def vfdipp_startCommand(self, name, value):
|
|
print('trying to set Start_Command to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Start_Command', int(value))
|
|
|
|
def vfdipp_stopCommand(self, name, value):
|
|
print('trying to set Stop_Command to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Stop_Command', int(value))
|
|
|
|
def vfdipp_tempShutdown(self, name, value):
|
|
print('trying to set Temp_Shutdown to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Temp_Shutdown', float(value))
|
|
|
|
def vfdipp_tempShutdownEnabled(self, name, value):
|
|
print('trying to set Temp_Shutdown_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Temp_Shutdown_Enabled', int(value))
|
|
|
|
def vfdipp_tempStartup(self, name, value):
|
|
print('trying to set Temp_Startup to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Temp_Startup', float(value))
|
|
|
|
def vfdipp_tempStartupEnabled(self, name, value):
|
|
print('trying to set Temp_Startup_Enabled to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'Temp_Startup_Enabled', int(value))
|
|
|
|
def vfdipp_tripEnableVOverfrequency(self, name, value):
|
|
print('trying to set TripEnable_V_Overfrequency to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_Overfrequency', int(value))
|
|
|
|
def vfdipp_tripEnableVOvervoltage(self, name, value):
|
|
print('trying to set TripEnable_V_Overvoltage to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_Overvoltage', int(value))
|
|
|
|
def vfdipp_tripEnableVPhaseRotation(self, name, value):
|
|
print('trying to set TripEnable_V_PhaseRotation to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_PhaseRotation', int(value))
|
|
|
|
def vfdipp_tripEnableVUnderfrequency(self, name, value):
|
|
print('trying to set TripEnable_V_Underfrequency to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_Underfrequency', int(value))
|
|
|
|
def vfdipp_tripEnableVUndervoltage(self, name, value):
|
|
print('trying to set TripEnable_V_Undervoltage to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_Undervoltage', int(value))
|
|
|
|
def vfdipp_tripEnableVVoltageUnbalance(self, name, value):
|
|
print('trying to set TripEnable_V_VoltageUnbalance to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnable_V_VoltageUnbalance', int(value))
|
|
|
|
def vfdipp_tripEnabledICurrentImbalance(self, name, value):
|
|
print('trying to set TripEnabled_I_CurrentImbalance to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_CurrentImbalance', int(value))
|
|
|
|
def vfdipp_tripEnabledIGroundFault(self, name, value):
|
|
print('trying to set TripEnabled_I_GroundFault to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_GroundFault', int(value))
|
|
|
|
def vfdipp_tripEnabledIJam(self, name, value):
|
|
print('trying to set TripEnabled_I_Jam to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Jam', int(value))
|
|
|
|
def vfdipp_tripEnabledILineLoss(self, name, value):
|
|
print('trying to set TripEnabled_I_LineLoss to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_LineLoss', int(value))
|
|
|
|
def vfdipp_tripEnabledIOvercurrent(self, name, value):
|
|
print('trying to set TripEnabled_I_Overcurrent to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Overcurrent', int(value))
|
|
|
|
def vfdipp_tripEnabledIOverload(self, name, value):
|
|
print('trying to set TripEnabled_I_Overload to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Overload', int(value))
|
|
|
|
def vfdipp_tripEnabledIPhaseLoss(self, name, value):
|
|
print('trying to set TripEnabled_I_PhaseLoss to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_PhaseLoss', int(value))
|
|
|
|
def vfdipp_tripEnabledIStall(self, name, value):
|
|
print('trying to set TripEnabled_I_Stall to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Stall', int(value))
|
|
|
|
def vfdipp_tripEnabledIUndercurrent(self, name, value):
|
|
print('trying to set TripEnabled_I_Undercurrent to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Undercurrent', int(value))
|
|
|
|
def vfdipp_tripEnabledIUnderload(self, name, value):
|
|
print('trying to set TripEnabled_I_Underload to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripEnabled_I_Underload', int(value))
|
|
|
|
def vfdipp_tripResetCmd(self, name, value):
|
|
print('trying to set TripResetCmd to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'TripResetCmd', int(value))
|
|
|
|
def vfdipp_warningEnableVOverfrequency(self, name, value):
|
|
print('trying to set WarningEnable_V_Overfrequency to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_Overfrequency', int(value))
|
|
|
|
def vfdipp_warningEnableVOvervoltage(self, name, value):
|
|
print('trying to set WarningEnable_V_Overvoltage to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_Overvoltage', int(value))
|
|
|
|
def vfdipp_warningEnableVPhaseRotation(self, name, value):
|
|
print('trying to set WarningEnable_V_PhaseRotation to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_PhaseRotation', int(value))
|
|
|
|
def vfdipp_warningEnableVUnderfrequency(self, name, value):
|
|
print('trying to set WarningEnable_V_Underfrequency to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_Underfrequency', int(value))
|
|
|
|
def vfdipp_warningEnableVUndervoltage(self, name, value):
|
|
print('trying to set WarningEnable_V_Undervoltage to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_Undervoltage', int(value))
|
|
|
|
def vfdipp_warningEnableVVoltageUnbalance(self, name, value):
|
|
print('trying to set WarningEnable_V_VoltageUnbalance to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnable_V_VoltageUnbalance', int(value))
|
|
|
|
def vfdipp_warningEnabledICurrentImbalance(self, name, value):
|
|
print('trying to set WarningEnabled_I_CurrentImbalance to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_CurrentImbalance', int(value))
|
|
|
|
def vfdipp_warningEnabledIGroundFault(self, name, value):
|
|
print('trying to set WarningEnabled_I_GroundFault to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_GroundFault', int(value))
|
|
|
|
def vfdipp_warningEnabledIJam(self, name, value):
|
|
print('trying to set WarningEnabled_I_Jam to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Jam', int(value))
|
|
|
|
def vfdipp_warningEnabledILineLoss(self, name, value):
|
|
print('trying to set WarningEnabled_I_LineLoss to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_LineLoss', int(value))
|
|
|
|
def vfdipp_warningEnabledIOvercurrent(self, name, value):
|
|
print('trying to set WarningEnabled_I_Overcurrent to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Overcurrent', int(value))
|
|
|
|
def vfdipp_warningEnabledIOverload(self, name, value):
|
|
print('trying to set WarningEnabled_I_Overload to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Overload', int(value))
|
|
|
|
def vfdipp_warningEnabledIPhaseLoss(self, name, value):
|
|
print('trying to set WarningEnabled_I_PhaseLoss to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_PhaseLoss', int(value))
|
|
|
|
def vfdipp_warningEnabledIStall(self, name, value):
|
|
print('trying to set WarningEnabled_I_Stall to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Stall', int(value))
|
|
|
|
def vfdipp_warningEnabledIUndercurrent(self, name, value):
|
|
print('trying to set WarningEnabled_I_Undercurrent to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Undercurrent', int(value))
|
|
|
|
def vfdipp_warningEnabledIUnderload(self, name, value):
|
|
print('trying to set WarningEnabled_I_Underload to {}'.format(value))
|
|
return u800.writeMicroTag(addr, 'WarningEnabled_I_Underload', int(value))
|