diff --git a/POCloud_Driver/ipp.py b/POCloud_Driver/ipp.py
index dd66b7e..db6ad8e 100644
--- a/POCloud_Driver/ipp.py
+++ b/POCloud_Driver/ipp.py
@@ -13,6 +13,23 @@ addr = '10.20.4.5'
 class start(threading.Thread, deviceBase):
     channels = {}
 
+    def writeTag_WriteE300(self, addr, tag, val):
+        c = u800.Driver()
+        if c.open(addr):
+            # try:
+            # typ = getTagType(addr, tag)
+            cv = c.read_tag(tag)
+            wt = c.write_tag(tag, val, cv[1])
+            write_E300 = c.write_tag("cfg_WRITE", 1, "BOOL")
+            print("wt= {}, write_E300 = {}".format(wt, write_E300))
+            return wt and write_E300
+            # except Exception:
+            #     err = c.get_status()
+            #     c.close()
+            #     print err
+            #     pass
+        c.close()
+
     def updateGPS(self):
         gps = self.mcu.gps
         print("GPS found me at {0}".format(gps))
@@ -118,7 +135,7 @@ class start(threading.Thread, deviceBase):
 
     def ipp_cfgcflasetting(self, name, value):
         print('trying to set cfg_C_FLASetting to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_C_FLASetting', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_C_FLASetting', float(value))
 
     def ipp_cfgcleartripcountafter(self, name, value):
         print('trying to set cfg_ClearTripCountAfter to {}'.format(value))
@@ -126,143 +143,143 @@ class start(threading.Thread, deviceBase):
 
     def ipp_cfgctripenablecontrol(self, name, value):
         print('trying to set cfg_C_TripEnableControl to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_C_TripEnableControl', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_C_TripEnableControl', int(value))
 
     def ipp_cfgcwarningenablecontrol(self, name, value):
         print('trying to set cfg_C_WarningEnableControl to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_C_WarningEnableControl', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_C_WarningEnableControl', int(value))
 
     def ipp_cfggfgroundfaultinhibittime(self, name, value):
         print('trying to set cfg_GF_GroundFaultInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_GF_GroundFaultInhibitTime', int(value))
 
     def ipp_cfggfgroundfaulttripdelay(self, name, value):
         print('trying to set cfg_GF_GroundFaultTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_GF_GroundFaultTripDelay', float(value))
 
     def ipp_cfggfgroundfaulttriplevel(self, name, value):
         print('trying to set cfg_GF_GroundFaultTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultTripLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_GF_GroundFaultTripLevel', float(value))
 
     def ipp_cfggfgroundfaultwarningdelay(self, name, value):
         print('trying to set cfg_GF_GroundFaultWarningDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultWarningDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_GF_GroundFaultWarningDelay', float(value))
 
     def ipp_cfggfgroundfaultwarninglevel(self, name, value):
         print('trying to set cfg_GF_GroundFaultWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_GF_GroundFaultWarningLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_GF_GroundFaultWarningLevel', float(value))
 
     def ipp_cfgictprimary(self, name, value):
         print('trying to set cfg_I_CTPrimary to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CTPrimary', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CTPrimary', int(value))
 
     def ipp_cfgictsecondary(self, name, value):
         print('trying to set cfg_I_CTSecondary to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CTSecondary', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CTSecondary', int(value))
 
     def ipp_cfgicurrentimbalanceinhibittim(self, name, value):
         print('trying to set cfg_I_CurrentImbalanceInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CurrentImbalanceInhibitTime', int(value))
 
     def ipp_cfgicurrentimbalancetripdelay(self, name, value):
         print('trying to set cfg_I_CurrentImbalanceTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceTripDelay', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CurrentImbalanceTripDelay', int(value))
 
     def ipp_cfgicurrentimbalancetriplevel(self, name, value):
         print('trying to set cfg_I_CurrentImbalanceTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CurrentImbalanceTripLevel', int(value))
 
     def ipp_cfgicurrentimbalancewarninglev(self, name, value):
         print('trying to set cfg_I_CurrentImbalanceWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_CurrentImbalanceWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_CurrentImbalanceWarningLevel', int(value))
 
     def ipp_cfgijaminhibittime(self, name, value):
         print('trying to set cfg_I_JamInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_JamInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_JamInhibitTime', int(value))
 
     def ipp_cfgijamtripdelay(self, name, value):
         print('trying to set cfg_I_JamTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_JamTripDelay', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_JamTripDelay', int(value))
 
     def ipp_cfgijamwarninglevel(self, name, value):
         print('trying to set cfg_I_JamWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_JamWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_JamWarningLevel', int(value))
 
     def ipp_cfgilinelossinhibittime(self, name, value):
         print('trying to set cfg_I_LineLossInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_LineLossInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_LineLossInhibitTime', int(value))
 
     def ipp_cfgilinelosstripdelay(self, name, value):
         print('trying to set cfg_I_LineLossTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_LineLossTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_LineLossTripDelay', float(value))
 
     def ipp_cfgiovercurrentinhibittime(self, name, value):
         print('trying to set cfg_I_OvercurrentInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_OvercurrentInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_OvercurrentInhibitTime', int(value))
 
     def ipp_cfgiovercurrenttripdelay(self, name, value):
         print('trying to set cfg_I_OvercurrentTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_OvercurrentTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_OvercurrentTripDelay', float(value))
 
     def ipp_cfgiovercurrenttriplevel(self, name, value):
         print('trying to set cfg_I_OvercurrentTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_OvercurrentTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_OvercurrentTripLevel', int(value))
 
     def ipp_cfgiovercurrentwarninglevel(self, name, value):
         print('trying to set cfg_I_OvercurrentWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_OvercurrentWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_OvercurrentWarningLevel', int(value))
 
     def ipp_cfgistallenabledtime(self, name, value):
         print('trying to set cfg_I_StallEnabledTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_StallEnabledTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_StallEnabledTime', int(value))
 
     def ipp_cfgistalltriplevel(self, name, value):
         print('trying to set cfg_I_StallTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_StallTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_StallTripLevel', int(value))
 
     def ipp_cfgiundercurrentinhibittime(self, name, value):
         print('trying to set cfg_I_UndercurrentInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UndercurrentInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UndercurrentInhibitTime', int(value))
 
     def ipp_cfgiundercurrenttripdelay(self, name, value):
         print('trying to set cfg_I_UndercurrentTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UndercurrentTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UndercurrentTripDelay', float(value))
 
     def ipp_cfgiundercurrenttriplevel(self, name, value):
         print('trying to set cfg_I_UndercurrentTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UndercurrentTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UndercurrentTripLevel', int(value))
 
     def ipp_cfgiundercurrentwarninglevel(self, name, value):
         print('trying to set cfg_I_UndercurrentWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UndercurrentWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UndercurrentWarningLevel', int(value))
 
     def ipp_cfgiunderloadinhibittime(self, name, value):
         print('trying to set cfg_I_UnderloadInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UnderloadInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UnderloadInhibitTime', int(value))
 
     def ipp_cfgiunderloadtripdelay(self, name, value):
         print('trying to set cfg_I_UnderloadTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UnderloadTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UnderloadTripDelay', float(value))
 
     def ipp_cfgiunderloadtriplevel(self, name, value):
         print('trying to set cfg_I_UnderloadTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UnderloadTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UnderloadTripLevel', int(value))
 
     def ipp_cfgiunderloadwarninglevel(self, name, value):
         print('trying to set cfg_I_UnderloadWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_I_UnderloadWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_I_UnderloadWarningLevel', int(value))
 
     def ipp_cfgoverloadtripcountlimit(self, name, value):
         print('trying to set cfg_OverloadTripCountLimit to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_OverloadTripCountLimit', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_OverloadTripCountLimit', int(value))
 
     def ipp_cfgplphaselossinhibittime(self, name, value):
         print('trying to set cfg_PL_PhaseLossInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_PL_PhaseLossInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_PL_PhaseLossInhibitTime', int(value))
 
     def ipp_cfgplphaselosstripdelay(self, name, value):
         print('trying to set cfg_PL_PhaseLossTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_PL_PhaseLossTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_PL_PhaseLossTripDelay', float(value))
 
     def ipp_cfgread(self, name, value):
         print('trying to set cfg_READ to {}'.format(value))
@@ -274,7 +291,7 @@ class start(threading.Thread, deviceBase):
 
     def ipp_cfgtcutripclass(self, name, value):
         print('trying to set cfg_TCU_TripClass to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_TCU_TripClass', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_TCU_TripClass', int(value))
 
     def ipp_cfgtimermodeenabled(self, name, value):
         print('trying to set cfg_TimerModeEnabled to {}'.format(value))
@@ -294,103 +311,103 @@ class start(threading.Thread, deviceBase):
 
     def ipp_cfgvoverfrequencyinhibittime(self, name, value):
         print('trying to set cfg_V_OverfrequencyInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OverfrequencyInhibitTime', int(value))
 
     def ipp_cfgvoverfrequencytripdelay(self, name, value):
         print('trying to set cfg_V_OverfrequencyTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OverfrequencyTripDelay', float(value))
 
     def ipp_cfgvoverfrequencytriplevel(self, name, value):
         print('trying to set cfg_V_OverfrequencyTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OverfrequencyTripLevel', int(value))
 
     def ipp_cfgvoverfrequencywarninglevel(self, name, value):
         print('trying to set cfg_V_OverfrequencyWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OverfrequencyWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OverfrequencyWarningLevel', int(value))
 
     def ipp_cfgvovervoltageinhibittime(self, name, value):
         print('trying to set cfg_V_OvervoltageInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OvervoltageInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OvervoltageInhibitTime', int(value))
 
     def ipp_cfgvovervoltagetripdelay(self, name, value):
         print('trying to set cfg_V_OvervoltageTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OvervoltageTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OvervoltageTripDelay', float(value))
 
     def ipp_cfgvovervoltagetriplevel(self, name, value):
         print('trying to set cfg_V_OvervoltageTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OvervoltageTripLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OvervoltageTripLevel', float(value))
 
     def ipp_cfgvovervoltagewarninglevel(self, name, value):
         print('trying to set cfg_V_OvervoltageWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_OvervoltageWarningLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_OvervoltageWarningLevel', float(value))
 
     def ipp_cfgvphaserotationinhibittime(self, name, value):
         print('trying to set cfg_V_PhaseRotationInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_PhaseRotationInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_PhaseRotationInhibitTime', int(value))
 
     def ipp_cfgvphaserotationtriptype(self, name, value):
         print('trying to set cfg_V_PhaseRotationTripType to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_PhaseRotationTripType', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_PhaseRotationTripType', int(value))
 
     def ipp_cfgvptprimary(self, name, value):
         print('trying to set cfg_V_PTPrimary to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_PTPrimary', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_PTPrimary', int(value))
 
     def ipp_cfgvptsecondary(self, name, value):
         print('trying to set cfg_V_PTSecondary to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_PTSecondary', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_PTSecondary', int(value))
 
     def ipp_cfgvunderfrequencyinhibittime(self, name, value):
         print('trying to set cfg_V_UnderfrequencyInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UnderfrequencyInhibitTime', int(value))
 
     def ipp_cfgvunderfrequencytripdelay(self, name, value):
         print('trying to set cfg_V_UnderfrequencyTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UnderfrequencyTripDelay', float(value))
 
     def ipp_cfgvunderfrequencytriplevel(self, name, value):
         print('trying to set cfg_V_UnderfrequencyTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UnderfrequencyTripLevel', int(value))
 
     def ipp_cfgvunderfrequencywarninglevel(self, name, value):
         print('trying to set cfg_V_UnderfrequencyWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UnderfrequencyWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UnderfrequencyWarningLevel', int(value))
 
     def ipp_cfgvundervoltageinhibittime(self, name, value):
         print('trying to set cfg_V_UndervoltageInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UndervoltageInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UndervoltageInhibitTime', int(value))
 
     def ipp_cfgvundervoltagetripdelay(self, name, value):
         print('trying to set cfg_V_UndervoltageTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UndervoltageTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UndervoltageTripDelay', float(value))
 
     def ipp_cfgvundervoltagetriplevel(self, name, value):
         print('trying to set cfg_V_UndervoltageTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UndervoltageTripLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UndervoltageTripLevel', float(value))
 
     def ipp_cfgvundervoltagewarninglevel(self, name, value):
         print('trying to set cfg_V_UndervoltageWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_UndervoltageWarningLevel', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_UndervoltageWarningLevel', float(value))
 
     def ipp_cfgvvoltageimbalanceinhibittim(self, name, value):
         print('trying to set cfg_V_VoltageImbalanceInhibitTime to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceInhibitTime', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_VoltageImbalanceInhibitTime', int(value))
 
     def ipp_cfgvvoltageimbalancetripdelay(self, name, value):
         print('trying to set cfg_V_VoltageImbalanceTripDelay to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceTripDelay', float(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_VoltageImbalanceTripDelay', float(value))
 
     def ipp_cfgvvoltageimbalancetriplevel(self, name, value):
         print('trying to set cfg_V_VoltageImbalanceTripLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceTripLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_VoltageImbalanceTripLevel', int(value))
 
     def ipp_cfgvvoltageimbalancewarninglev(self, name, value):
         print('trying to set cfg_V_VoltageImbalanceWarningLevel to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_VoltageImbalanceWarningLevel', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_VoltageImbalanceWarningLevel', int(value))
 
     def ipp_cfgvvoltagemode(self, name, value):
         print('trying to set cfg_V_VoltageMode to {}'.format(value))
-        return u800.writeMicroTag(addr, 'cfg_V_VoltageMode', int(value))
+        return self.writeTag_WriteE300(addr, 'cfg_V_VoltageMode', int(value))
 
     def ipp_cfgwrite(self, name, value):
         print('trying to set cfg_WRITE to {}'.format(value))
@@ -478,67 +495,67 @@ class start(threading.Thread, deviceBase):
 
     def ipp_tripenabledicurrentimbalance(self, name, value):
         print('trying to set TripEnabled_I_CurrentImbalance to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_CurrentImbalance', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_CurrentImbalance', int(value))
 
     def ipp_tripenabledigroundfault(self, name, value):
         print('trying to set TripEnabled_I_GroundFault to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_GroundFault', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_GroundFault', int(value))
 
     def ipp_tripenabledijam(self, name, value):
         print('trying to set TripEnabled_I_Jam to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Jam', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Jam', int(value))
 
     def ipp_tripenabledilineloss(self, name, value):
         print('trying to set TripEnabled_I_LineLoss to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_LineLoss', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_LineLoss', int(value))
 
     def ipp_tripenablediovercurrent(self, name, value):
         print('trying to set TripEnabled_I_Overcurrent to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Overcurrent', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Overcurrent', int(value))
 
     def ipp_tripenabledioverload(self, name, value):
         print('trying to set TripEnabled_I_Overload to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Overload', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Overload', int(value))
 
     def ipp_tripenablediphaseloss(self, name, value):
         print('trying to set TripEnabled_I_PhaseLoss to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_PhaseLoss', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_PhaseLoss', int(value))
 
     def ipp_tripenabledistall(self, name, value):
         print('trying to set TripEnabled_I_Stall to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Stall', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Stall', int(value))
 
     def ipp_tripenablediundercurrent(self, name, value):
         print('trying to set TripEnabled_I_Undercurrent to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Undercurrent', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Undercurrent', int(value))
 
     def ipp_tripenablediunderload(self, name, value):
         print('trying to set TripEnabled_I_Underload to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnabled_I_Underload', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnabled_I_Underload', int(value))
 
     def ipp_tripenablevoverfrequency(self, name, value):
         print('trying to set TripEnable_V_Overfrequency to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_Overfrequency', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_Overfrequency', int(value))
 
     def ipp_tripenablevovervoltage(self, name, value):
         print('trying to set TripEnable_V_Overvoltage to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_Overvoltage', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_Overvoltage', int(value))
 
     def ipp_tripenablevphaserotation(self, name, value):
         print('trying to set TripEnable_V_PhaseRotation to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_PhaseRotation', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_PhaseRotation', int(value))
 
     def ipp_tripenablevunderfrequency(self, name, value):
         print('trying to set TripEnable_V_Underfrequency to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_Underfrequency', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_Underfrequency', int(value))
 
     def ipp_tripenablevundervoltage(self, name, value):
         print('trying to set TripEnable_V_Undervoltage to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_Undervoltage', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_Undervoltage', int(value))
 
     def ipp_tripenablevvoltageunbalance(self, name, value):
         print('trying to set TripEnable_V_VoltageUnbalance to {}'.format(value))
-        return u800.writeMicroTag(addr, 'TripEnable_V_VoltageUnbalance', int(value))
+        return self.writeTag_WriteE300(addr, 'TripEnable_V_VoltageUnbalance', int(value))
 
     def ipp_tripresetcmd(self, name, value):
         print('trying to set TripResetCmd to {}'.format(value))
@@ -546,64 +563,64 @@ class start(threading.Thread, deviceBase):
 
     def ipp_warningenabledicurrentimbalanc(self, name, value):
         print('trying to set WarningEnabled_I_CurrentImbalance to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_CurrentImbalance', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_CurrentImbalance', int(value))
 
     def ipp_warningenabledigroundfault(self, name, value):
         print('trying to set WarningEnabled_I_GroundFault to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_GroundFault', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_GroundFault', int(value))
 
     def ipp_warningenabledijam(self, name, value):
         print('trying to set WarningEnabled_I_Jam to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Jam', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Jam', int(value))
 
     def ipp_warningenabledilineloss(self, name, value):
         print('trying to set WarningEnabled_I_LineLoss to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_LineLoss', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_LineLoss', int(value))
 
     def ipp_warningenablediovercurrent(self, name, value):
         print('trying to set WarningEnabled_I_Overcurrent to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Overcurrent', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Overcurrent', int(value))
 
     def ipp_warningenabledioverload(self, name, value):
         print('trying to set WarningEnabled_I_Overload to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Overload', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Overload', int(value))
 
     def ipp_warningenablediphaseloss(self, name, value):
         print('trying to set WarningEnabled_I_PhaseLoss to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_PhaseLoss', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_PhaseLoss', int(value))
 
     def ipp_warningenabledistall(self, name, value):
         print('trying to set WarningEnabled_I_Stall to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Stall', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Stall', int(value))
 
     def ipp_warningenablediundercurrent(self, name, value):
         print('trying to set WarningEnabled_I_Undercurrent to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Undercurrent', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Undercurrent', int(value))
 
     def ipp_warningenablediunderload(self, name, value):
         print('trying to set WarningEnabled_I_Underload to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnabled_I_Underload', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnabled_I_Underload', int(value))
 
     def ipp_warningenablevoverfrequency(self, name, value):
         print('trying to set WarningEnable_V_Overfrequency to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_Overfrequency', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_Overfrequency', int(value))
 
     def ipp_warningenablevovervoltage(self, name, value):
         print('trying to set WarningEnable_V_Overvoltage to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_Overvoltage', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_Overvoltage', int(value))
 
     def ipp_warningenablevphaserotation(self, name, value):
         print('trying to set WarningEnable_V_PhaseRotation to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_PhaseRotation', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_PhaseRotation', int(value))
 
     def ipp_warningenablevunderfrequency(self, name, value):
         print('trying to set WarningEnable_V_Underfrequency to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_Underfrequency', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_Underfrequency', int(value))
 
     def ipp_warningenablevundervoltage(self, name, value):
         print('trying to set WarningEnable_V_Undervoltage to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_Undervoltage', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_Undervoltage', int(value))
 
     def ipp_warningenablevvoltageunbalance(self, name, value):
         print('trying to set WarningEnable_V_VoltageUnbalance to {}'.format(value))
-        return u800.writeMicroTag(addr, 'WarningEnable_V_VoltageUnbalance', int(value))
+        return self.writeTag_WriteE300(addr, 'WarningEnable_V_VoltageUnbalance', int(value))