"""Class definition for E300 overload relay.""" from cpppo.server.enip.get_attribute import proxy_simple import traceback from common import reverse_parameter_name, bitfield, CIP_value class E300(proxy_simple): """Specific parameters and their addresses, for the E300 Overload Relay.""" VOLTAGE_PARAMETERS = dict(l1_to_n_voltage=proxy_simple.parameter('@0x4F/1/15', 'REAL', 'Volts'), l2_to_n_voltage=proxy_simple.parameter('@0x4F/1/16', 'REAL', 'Volts'), l3_to_n_voltage=proxy_simple.parameter('@0x4F/1/17', 'REAL', 'Volts'), avg_l_to_n_voltage=proxy_simple.parameter('@0x4F/1/18', 'REAL', 'Volts'), l1_to_l2_voltage=proxy_simple.parameter('@0x4F/1/19', 'REAL', 'Volts'), l2_to_l3_voltage=proxy_simple.parameter('@0x4F/1/20', 'REAL', 'Volts'), l3_to_l1_voltage=proxy_simple.parameter('@0x4F/1/21', 'REAL', 'Volts'), avg_l_to_l_voltage=proxy_simple.parameter('@0x4F/1/22', 'REAL', 'Volts'), percent_voltage_unbalance=proxy_simple.parameter('@0x4F/1/23', 'REAL', '%'), line_frequency=proxy_simple.parameter('@0x4F/1/9', 'REAL', 'Hz'), phase_rotation=proxy_simple.parameter('@0x4F/1/40', 'INT', 'ABC/ACB'), ) CURRENT_PARAMETERS = dict(l1_current=proxy_simple.parameter('@0x4F/1/10', 'REAL', 'Amps'), l2_current=proxy_simple.parameter('@0x4F/1/11', 'REAL', 'Amps'), l3_current=proxy_simple.parameter('@0x4F/1/12', 'REAL', 'Amps'), average_current=proxy_simple.parameter('@0x4F/1/13', 'REAL', 'Amps'), percent_current_unbalance=proxy_simple.parameter('@0x4F/1/14', 'REAL', '%'), ) POWER_PARAMETERS = dict(l1_real_power=proxy_simple.parameter('@0x4F/1/24', 'REAL', 'kW'), l2_real_power=proxy_simple.parameter('@0x4F/1/25', 'REAL', 'kW'), l3_real_power=proxy_simple.parameter('@0x4F/1/26', 'REAL', 'kW'), total_real_power=proxy_simple.parameter('@0x4F/1/27', 'REAL', 'kW'), l1_reactive_power=proxy_simple.parameter('@0x4F/1/28', 'REAL', 'kVAR'), l2_reactive_power=proxy_simple.parameter('@0x4F/1/29', 'REAL', 'kVAR'), l3_reactive_power=proxy_simple.parameter('@0x4F/1/30', 'REAL', 'kVAR'), total_reactive_power=proxy_simple.parameter('@0x4F/1/31', 'REAL', 'kVAR'), l1_apparent_power=proxy_simple.parameter('@0x4F/1/32', 'REAL', 'kVA'), l2_apparent_power=proxy_simple.parameter('@0x4F/1/33', 'REAL', 'kVA'), l3_apparent_power=proxy_simple.parameter('@0x4F/1/34', 'REAL', 'kVA'), total_apparent_power=proxy_simple.parameter('@0x4F/1/35', 'REAL', 'kVA'), l1_true_power_factor=proxy_simple.parameter('@0x4F/1/36', 'REAL', '%'), l2_true_power_factor=proxy_simple.parameter('@0x4F/1/37', 'REAL', '%'), l3_true_power_factor=proxy_simple.parameter('@0x4F/1/38', 'REAL', '%'), three_phase_true_power_factor=proxy_simple.parameter('@0x4F/1/39', 'REAL', '%'), ) IO_PARAMETERS = dict(output_0=proxy_simple.parameter('@0x09/1/3', 'SINT', 'I/O'), output_1=proxy_simple.parameter('@0x09/2/3', 'SINT', 'I/O'), output_2=proxy_simple.parameter('@0x09/3/3', 'SINT', 'I/O'), input_0=proxy_simple.parameter('@0x08/1/3', 'SINT', 'I/O'), input_1=proxy_simple.parameter('@0x08/2/3', 'SINT', 'I/O'), input_2=proxy_simple.parameter('@0x08/3/3', 'SINT', 'I/O'), ) # CONFIGURATION_PARAMETERS = dict(motor_namplate_volts=proxy_simple.parameter('@0x93/25/9', 'REAL', 'VAC'), # motor_namplate_amps=proxy_simple.parameter('@0x93/26/9', 'REAL', 'Amps'), # motor_namplate_hertz=proxy_simple.parameter('@0x93/27/9', 'REAL', 'Hertz'), # motor_namplate_rpm=proxy_simple.parameter('@0x93/28/9', 'REAL', 'RPM'), # motor_namplate_powerunits=proxy_simple.parameter('@0x93/29/9', 'DINT', 'HP/kW'), # motor_namplate_power=proxy_simple.parameter('@0x93/30/9', 'REAL', 'HP/kW'), # motor_poles=proxy_simple.parameter('@0x93/31/9', 'DINT', 'Poles'), # pwm_frequency=proxy_simple.parameter('@0x93/38/9', 'REAL', 'kHz'), # rated_volts=proxy_simple.parameter('@0x93/20/9', 'REAL', 'VAC'), # rated_amps=proxy_simple.parameter('@0x93/21/9', 'REAL', 'Amps'), # rated_kw=proxy_simple.parameter('@0x93/22/9', 'REAL', 'kW'), # speed_units=proxy_simple.parameter('@0x93/300/9', 'DINT', 'Hz/RPM'), # duty_rating=proxy_simple.parameter('@0x93/306/9', 'DINT', 'ND/HD/LD'), # reset_meters=proxy_simple.parameter('@0x93/336/9', 'DINT', 'Ready/Energy/Time'), # db_resistor_type=proxy_simple.parameter('@0x93/382/9', 'DINT', 'Internal/External'), # db_resistor_ohms=proxy_simple.parameter('@0x93/383/9', 'REAL', 'Ohms'), # db_resistor_watts=proxy_simple.parameter('@0x93/384/9', 'REAL', 'Watts'), # speed_ref_a_sel=proxy_simple.parameter('@0x93/545/9', 'DINT', 'Param'), # ) # # COMMAND_PARAMETERS = dict(logic_status=proxy_simple.parameter('@0x07/3/4', 'DINT', 'Bits'), # logic_command=proxy_simple.parameter('@0x07/4/1', 'BOOL', 'Bits')) PARAMETERS = proxy_simple.PARAMETERS.copy() PARAMETERS.update(VOLTAGE_PARAMETERS) PARAMETERS.update(CURRENT_PARAMETERS) PARAMETERS.update(POWER_PARAMETERS) PARAMETERS.update(IO_PARAMETERS) # PARAMETERS.update(CONFIGURATION_PARAMETERS) # PARAMETERS.update(COMMAND_PARAMETERS) def __init__(self, hostname): """Intitialize the class.""" super().__init__(hostname, route_path=[], send_path='') self.PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.PARAMETERS] self.PARAMETER_NAMES = self.PARAMETER_NAMES[3:] self.VOLTAGE_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.VOLTAGE_PARAMETERS] self.CURRENT_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.CURRENT_PARAMETERS] self.POWER_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.POWER_PARAMETERS] self.IO_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.IO_PARAMETERS] # self.CONFIGURATION_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.CONFIGURATION_PARAMETERS] # self.COMMAND_PARAMETER_NAMES = [reverse_parameter_name(p) for p in self.COMMAND_PARAMETERS] self.voltage_values = {} self.current_values = {} self.power_values = {} self.io_values = {} # self.configuration_values = {} # self.command_values = {} for p in self.VOLTAGE_PARAMETERS: self.voltage_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.VOLTAGE_PARAMETERS[p][2]) for p in self.CURRENT_PARAMETERS: self.current_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.CURRENT_PARAMETERS[p][2]) for p in self.POWER_PARAMETERS: self.power_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.POWER_PARAMETERS[p][2]) for p in self.IO_PARAMETERS: self.io_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.IO_PARAMETERS[p][2]) # for p in self.CONFIGURATION_PARAMETERS: # self.configuration_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.CONFIGURATION_PARAMETERS[p][2]) # # for p in self.COMMAND_PARAMETERS: # self.command_values[reverse_parameter_name(p)] = CIP_value(reverse_parameter_name(p), self.COMMAND_PARAMETERS[p][2]) # print("Speed Ref A Set: {}".format(self.write_parameter("Speed Ref A Sel", 'DINT', 546))) # Set the Speed ref to read from Ethernet Adapter def get_all_values(self): """Retrieve all values stored for the VFD.""" temp = self.configuration_values.copy() temp.update(self.voltage_values) temp.update(self.current_values) temp.update(self.power_values) temp.update(self.io_values) return temp def write_parameter(self, param_name, param_type, value): """Write a parameter to the VFD.""" param = '%s = (%s)%s' % (param_name, param_type, value) print(param) try: via = self with via: # establish gateway, detects Exception (closing gateway) val, = via.write( via.parameter_substitution(param), checking=True) if val: return True else: return False except Exception as exc: print("Exception writing Parameter %s: %s, %s", param, exc, traceback.format_exc()) return False def read_all(self): """Read all values from the list of parameter names.""" self.read_voltage() self.read_current() self.read_power() # self.read_configuration() # self.read_command() return self.get_all_values() def read_voltage(self): """Read Voltage Parameter values from the list of parameter names.""" values = list(self.read(self.parameter_substitution(self.VOLTAGE_PARAMETER_NAMES))) for x in range(0, len(values)): if values[x] is not None: self.voltage_values[self.VOLTAGE_PARAMETER_NAMES[x]].update(values[x][0]) return self.voltage_values def read_current(self): """Read Current Parameter values from the list of parameter names.""" values = list(self.read(self.parameter_substitution(self.CURRENT_PARAMETER_NAMES))) for x in range(0, len(values)): if values[x] is not None: self.current_values[self.CURRENT_PARAMETER_NAMES[x]].update(values[x][0]) return self.current_values def read_power(self): """Read Power Parameter values from the list of parameter names.""" values = list(self.read(self.parameter_substitution(self.POWER_PARAMETER_NAMES))) for x in range(0, len(values)): if values[x] is not None: self.power_values[self.POWER_PARAMETER_NAMES[x]].update(values[x][0]) return self.power_values def read_io(self): """Read IO Parameter values from the list of parameter names.""" values = list(self.read(self.parameter_substitution(self.IO_PARAMETER_NAMES))) for x in range(0, len(values)): if values[x] is not None: self.io_values[self.IO_PARAMETER_NAMES[x]].update(values[x][0]) return self.io_values # def read_configuration(self): # """Read Running Parameter values from the list of parameter names.""" # values = list(self.read(self.parameter_substitution(self.CONFIGURATION_PARAMETER_NAMES))) # for x in range(0, len(values)): # if values[x] is not None: # self.configuration_values[self.CONFIGURATION_PARAMETER_NAMES[x]].update(values[x][0]) # return self.configuration_values # # def read_command(self): # """Read Command Parameter values from the list of parameter names.""" # values = list(self.read(self.parameter_substitution(self.COMMAND_PARAMETER_NAMES))) # for x in range(0, len(values)): # if values[x] is not None: # bit_map = bitfield(values[x][0]) # value_map = {} # for i in range(0, len(bit_map)): # try: # value_map[COMMAND_MAP[self.COMMAND_PARAMETER_NAMES[x]][i]] = bit_map[i] # except KeyError: # pass # self.command_values[self.COMMAND_PARAMETER_NAMES[x]].update(value_map) # return self.command_values # # def start(self): # """Start the VFD.""" # return self.write_parameter("Logic Command", "INT", 2) # # def stop(self): # """Start the VFD.""" # return self.write_parameter("Logic Command", "INT", 1)