class Koyo: def __init__(self, ip_address): self.ip_address = ip_address self._koyo = ModbusClient(ip_address) print("Connected:", self._koyo.connect()) if self._koyo.connect(): self._getversions() self._get_device_info() def _getversions(self): data = self._koyo.read_input_registers(17500, 6) self.os_version = '.'.join(map(str, data.registers[0:3])) self.boot_version = '.'.join(map(str, data.registers[3:6])) def _get_device_info(self): data = self._koyo.read_input_registers(17510, 19) self.device_version = data.registers[0] self.family = data.registers[1] def disconnect(self): self._koyo.close() def read_register(self, x): read = self._koyo.read_holding_registers(x, count=1, unit=1) return read.registers[0]
def main(): ur_ctrl = rtde_control.RTDEControlInterface(rsd_conf.UR_IP) ur_ctrl.moveJ(q.IDLE) ur_modbus_client = ModbusTcpClient(rsd_conf.UR_IP) ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, False) pi_modbus_client = ModbusTcpClient(rsd_conf.PI_IP, rsd_conf.PI_MODBUS_PORT) def gripper_grasp(grasp_q, pre_post_q): ur_ctrl.moveJ(pre_post_q) ur_ctrl.moveJ(grasp_q) ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, True) ur_ctrl.moveJ(pre_post_q) def gripper_release(): ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, False) order = {"blue": 0, "red": 0, "yellow": 20} for brick_color_id in range(len(rsd_conf.BRICK_COLORS)): brick_color = rsd_conf.BRICK_COLORS[brick_color_id] q_grasp_brick, q_above_brick = q.GRASP_BRICKS[ brick_color_id], q.ABOVE_BRICKS[brick_color_id] count = order[brick_color] for _ in range(count): gripper_grasp(q_grasp_brick, q_above_brick) ur_ctrl.moveJ(q.ABOVE_CAMERA) pi_modbus_client.read_input_registers(0, 1) ur_ctrl.moveJ(q.BRICK_DROP_ORDER_BOX) gripper_release() ur_ctrl.moveJ(q.IDLE)
def upmu(upmu, sw_value): IP = '131.243.41.14' PORT = 503 id = 2 if upmu == '123p': register = int(2) if upmu == '4': register = int(3) client = ModbusClient(IP, port=PORT) try: client.write_registers(register, int(sw_value), unit=id) print(f'uPMU{upmu} to {sw_value} ~~ time:', client.read_input_registers(1, count=1, unit=id).registers[0]) print('epoch:', time.time()) print(dt.datetime.fromtimestamp(time.time())) print('All Done.', client.read_input_registers(1, count=1, unit=id).registers[0]) except Exception as e: print(e) finally: client.close() print('client closed [uPMU]') return
class Koyo: def __init__(self, ip_address): self.ip_address = ip_address self._koyo = ModbusClient(ip_address) print self._koyo.connect() if self._koyo.connect(): self._getversions() self._get_device_info() def _getversions(self): data = self._koyo.read_input_registers(17500, 6) self.os_version = '.'.join(map(str, data.registers[0:3])) self.boot_version = '.'.join(map(str, data.registers[3:6])) def _get_device_info(self): data = self._koyo.read_input_registers(17510, 19) self.device_version = data.registers[0] self.family = data.registers[1] def outputs(self, max=16): pass def write_output(self, output, value): pass def inputs(self, max=24): pass def memory_bits(self, bit): pass def disconnect(self): self._koyo.close()
def update(seradd: str, sdmid: int): client = ModbusTcpClient(seradd, port=8899) with client: resp = client.read_input_registers(0x0006, 2, unit=sdmid) al1 = struct.unpack('>f', struct.pack('>HH', *resp.registers)) al1 = float("%.3f" % al1[0]) f = open("/var/www/html/openWB/ramdisk/pva1", 'w') f.write(str(al1)) f.close() resp = client.read_input_registers(0x000C, 2, unit=sdmid) watt = struct.unpack('>f', struct.pack('>HH', *resp.registers)) watt = int(watt[0]) f = open("/var/www/html/openWB/ramdisk/pvwatt", 'w') f.write(str(watt)) f.close() resp = client.read_input_registers(0x004a, 2, unit=sdmid) vwh = struct.unpack('>f', struct.pack('>HH', *resp.registers)) vwh1 = float("%.3f" % vwh[0]) vwhk = str(vwh1) f = open("/var/www/html/openWB/ramdisk/pvkwhk", 'w') f.write(str(vwhk)) f.close() vwh2 = float(vwh1) * int(1000) vwh3 = str(vwh2) f = open("/var/www/html/openWB/ramdisk/pvkwh", 'w') f.write(str(vwh3)) f.close()
def get_b100_readings(address, port): global modbus_client if modbus_client is None: try: modbus_client = ModbusClient(address, port=port, framer=ModbusFramer) except: raise ValueError ltc_tank_temp = None top_oil_temp = None # read LTC Tank Temperature try: ltc_tank_temp_read = modbus_client.read_input_registers(LTC_TANK_TEMP_REGISTER,2,unit=1) ltc_tank_temp_raw = ltc_tank_temp_read.registers[0] ltc_tank_temp = convert_to_scaled_signedint(val,1000) except Exception as ex: ltc_tank_temp = f'error: {ex}' try: top_oil_temp_read = modbus_client.read_input_registers(TOP_OIL_TEMP_REGISTER,2,unit=1) top_oil_temp_raw = top_oil_temp_read.registers[0] top_oil_temp = convert_to_scaled_signedint(ltc_tank_temp_raw,1000) except Exception as ex: top_oil_temp = f'error: {ex}' readings = { 'ltc_tank_temp': ltc_tank_temp, 'top_oil_temp': top_oil_temp } return readings
class ComModbusTcp: def __init__(self): self.client = None self.lock = threading.Lock() def connectToDevice(self, address): """ Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument. """ self.client = ModbusTcpClient(address) def disconnectFromDevice(self): """Close connection""" self.client.close() def sendCommand(self, data): """ Send a command to the Gripper - the method takes a list of int as an argument. The meaning of each variable depends on the Gripper model """ if (len(data) == 6): message = [] for i in range(0, len(data)): message.append(data[i]) with self.lock: self.client.write_register(52, message[0]) self.client.write_register(53, message[1]) self.client.write_register(54, message[2]) self.client.write_register(3006, message[3]) self.client.write_register(3007, message[4]) self.client.write_register(3008, message[5]) def getStatus(self, numRegs): """ Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument """ # TODO: Implement try/except # Get status from the device with self.lock: response1 = self.client.read_input_registers(51, numRegs) response2 = self.client.read_input_registers(3012, numRegs) # Instantiate output1 output2 as an empty list output1 = [] output2 = [] # Fill the output with the bytes in the appropriate order for i in range(0, numRegs): output1.append(response1.getRegister(i)) output2.append(response2.getRegister(i)) for i in range(0, numRegs): output1.append(output2[i]) # Output the result return output1
class communication: def __init__(self): self.client = None def connectToDevice(self, address): """Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument.""" self.client = ModbusTcpClient(address) def disconnectFromDevice(self): """Close connection""" self.client.close() def sendCommand(self, data): """Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)""" #make sure data has an even number of elements if (len(data) % 2 == 1): data.append(0) #Initiate message as an empty list message = [] #Fill message by combining two bytes in one register for i in range(0, int(len(data) / 2)): message.append((data[2 * i] << 8) + data[2 * i + 1]) #To do!: Implement try/except self.client.write_registers(0, message) def getStatus(self, numBytes): """Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument""" numRegs = int(ceil(numBytes / 2.0)) #To do!: Improve try/except to be more robust #Get status from the device response = self.client.read_input_registers(0, numRegs) connection_exception = False while isinstance(response, ModbusIOException) or connection_exception: try: response = self.client.read_input_registers(0, numRegs) connection_exception = False except ConnectionException: connection_exception = True print('WARNING: comModbusTCP.py ConnectionException, retrying') time.sleep(0.1) #Instantiate output as an empty list output = [] #Fill the output with the bytes in the appropriate order for i in range(0, numRegs): output.append((response.getRegister(i) & 0xFF00) >> 8) output.append(response.getRegister(i) & 0x00FF) #Output the result return output
class ChargeController(): def __init__(self, address): self.host,self.port = address self.device_name = '<unknown>' self.serial_number = '<unknown>' self.update_serial_number_and_device_name() self.readable_values = {} self.coil_register_indices = range(1, NUM_COIL_REGISTERS + 1) def update_serial_number_and_device_name(self): try: self.measure_eeprom() serial_number_bytes = [('%04x' % self.eeprom_measurement[k])[::-1] for k in range(57536, 57540)] self.serial_number = ''.join(serial_number_bytes)[::2] device_model = self.eeprom_measurement[0xE0CC] if device_model: self.device_name = 'TriStar-MPPT-60' else: self.device_name = 'TriStar-MPPT-45' except Exception: logger.exception("Could not get serial number or device name for %s:%d" % (self.host,self.port)) def measure(self): self.client = ModbusTcpClient(host=self.host, port=self.port) measurement = OrderedDict(epoch=time.time()) result = self.client.read_input_registers(0, NUM_REGISTERS, unit=0x01,) try: measurement.update(zip(range(NUM_REGISTERS), result.registers)) except AttributeError as e: print e, result raise self.measurement = measurement self.client.close() return self.measurement def measure_eeprom(self): self.client = ModbusTcpClient(host=self.host, port=self.port) self.eeprom_measurement = OrderedDict(epoch=time.time()) eeprom_measurement = self.client.read_input_registers(EEPROM_BATCH_1[0], EEPROM_BATCH_1[1] - EEPROM_BATCH_1[0], unit=0x01).registers eeprom_measurement += self.client.read_input_registers(EEPROM_BATCH_2[0], EEPROM_BATCH_2[1] - EEPROM_BATCH_2[0], unit=0x01).registers eeprom_measurement += self.client.read_input_registers(EEPROM_BATCH_3[0], EEPROM_BATCH_3[1] - EEPROM_BATCH_3[0], unit=0x01).registers self.eeprom_measurement.update(zip(EEPROM_REGISTER_INDICES, eeprom_measurement)) self.client.close() return self.eeprom_measurement def measure_coils(self): self.coil_measurement = OrderedDict(epoch=time.time()) self.coil_measurement.update( zip(range(NUM_COIL_REGISTERS), self.client.read_coils(0, NUM_COIL_REGISTERS, unit=0x01).bits)) return self.coil_measurement
def readMBinputregisters(clientIP, register, number=1): from pymodbus.client.sync import ModbusTcpClient, ConnectionException values = [] client = ModbusTcpClient(clientIP) try: rawresult = client.read_input_registers(register, number) except ConnectionException: # print('we were unable to connect to the host') statuscode = 7 else: # print(rawresult) try: resultregisters = rawresult.registers except AttributeError: statuscode = rawresult.exception_code else: statuscode = 0 values = resultregisters client.close() result = { 'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values': values } return result
def read_input_registers(self, command): parser = argument_parser() command = 'read_input_register ' + command spec = parser.parse_args(command.split()) response = _ModbusClient.read_input_registers( self, spec.address, spec.count, unit=spec.unit_id) return response
class VentboxClient(AbstractClient): def __init__(self) -> None: super().__init__() self.client = ModbusClient('192.168.1.92', port=502) self.client.connect() print("Connected") def getInputRegister(self, index) -> float: reg = self.client.read_input_registers(index, 2) s = struct.pack('<HH', reg.registers[0], reg.registers[1]) return struct.unpack('f', s)[0] def getTempExtIn(self) -> float: return self.getInputRegister(0) def getHeater(self) -> float: return self.getInputRegister(16) def getEngine1(self) -> float: return self.getInputRegister(12) def getEngine2(self) -> float: return self.getInputRegister(14) def setPower(self, power: int) -> None: self.power = power s = struct.pack('>f', power) i1, i2 = struct.unpack('>HH', s) self.client.write_register(6, i2) self.client.write_register(6 + 1, i1) def closeReku(self): self.client.close()
def wren_gw_modbus_read(config): ''' read a value from the peer. @param config the configuration in the key/value type. ''' try: m = ModbusTcpClient(host=config['node'], port=config['port']) m.connect() unit = 0xff if config.has_key('unit_id'): unit = config['unit_id'] # sed data value = None if config['table'] == 'InputRegister': result = m.read_input_registers(config['address'], 1, unit=unit) if result: value = result.registers[config['address']] if config['table'] == 'HoldingRegister': result = m.read_holding_registers(config['address'], 1, unit=unit) if result: value = result.registers[config['address']] # close it. m.close() return {"status":True, "value":str(value)}; except Exception as e: return {"status":False, "value":str(e)};
class ModbusDevice: def __init__(self, ip: str, port: int = 502): self.client = ModbusTcpClient(ip, port=502) def read(self, reg: Enum, count=2) -> List[int]: return self.client.read_input_registers(reg.value, count, unit=3).registers def write(self, reg: Enum, value: int) -> None: self.client.write_registers(reg.value, (value // 65536, value % 65536), unit=3) @staticmethod def decode_s32(value: List[int]) -> int: if value[0] == 32768 and value[1] == 0: return 0 # To enforce signed decoding, there seems to be no better way. return struct.unpack( '>i', bytes.fromhex(format(value[0], '04x') + format(value[1], '04x')))[0] @staticmethod def decode_u32(value: List[int]) -> int: if value[0] == 32768 and value[1] == 0: return 0 return int(format(value[0], '04x') + format(value[1], '04x'), 16)
class VisionClient: def __init__(self): self.modbus_conn = ModbusTcpClient(conf.PI_IP, conf.PI_MODBUS_PORT) def get_color_id(self): values = self.modbus_conn.read_input_registers(0, 1) return values.registers[0]
def get_device_class(host, port, modbusid): client = ModbusClient(host=host, port=port) try: client.connect() except: print('Modbus Connection Error', 'could not connect to target. Check your settings, please.') return None try: received = client.read_input_registers(address=30051, count=2, unit=3) except: thisdate = str(datetime.datetime.now()).partition('.')[0] thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.' print(thiserrormessage) return None message = BinaryPayloadDecoder.fromRegisters(received.registers, byteorder=Endian.Big, wordorder=Endian.Big) interpreted = message.decode_32bit_uint() dclass = pvenums["DeviceClass"].get(interpreted) client.close() return dclass
def main(): ### setup the client ### ipaddr = '192.168.201.21' port = 502 print 'Connecting to', (ipaddr, port) client = ModbusTcpClient(ipaddr, port=port) ### fetch data ### try: reg = client.read_input_registers(0, 8) # data request vlt = raw2volt(reg.registers) # convert bit to voltage (-10 -- 10[V]) except: print 'Data fetch error. Finishing...' client.close() return ### convert voltage to engineering values ### meas = vlt # TODO: CHANGE THIS ### show data ### print 'Raw measurement:', vlt print 'Engineering value:', meas ### finalizing ### client.close()
def run(self, measured_instrument): while self.running: c = ModbusTcpClient(measured_instrument.ip) start = time.time() while not c.connect(): log.debug("Can't connect, retry in 0.5s") self.measurements.append((time.time(), measured_instrument.ip, measured_instrument.name, ((time.time() - start) * 1000), -2)) time.sleep(0.5) if measured_instrument.type == "input_register": response = c.read_input_registers( measured_instrument.address, 1, unit=measured_instrument.unit) measured_instrument.setData(response.registers[0]) if measured_instrument.type == "coil": response = c.read_coils(measured_instrument.address, 1, unit=measured_instrument.unit) measured_instrument.setData(response.bits[0]) c.close() self.measurements.append( (time.time(), measured_instrument.ip, measured_instrument.name, ((time.time() - start) * 1000), 1)) log.debug("Tick: {}".format(self.tick)) time.sleep(self.tick)
class ModbusConnection(object): _max_retries_read = 10 _max_retries_write = 3 @property def max_retries_read(self): return self._max_retries_read @property def max_retries_write(self): return self._max_retries_write @property def client_address(self): return self.client.host @property def client_port(self): return str(self.client.port) def __init__(self, client_address, client_port): self.client = ModbusClient(host = client_address, port = int(client_port)) self.connect_to_client() def __del__(self): self.disconnect_from_client() def connect_to_client(self): self.client.connect() def disconnect_from_client(self): self.client.close() def read_input_registers(self, address, count, unit): k = 0 while k < self.max_retries_read: try: return self.client.read_input_registers(address = address, count = count, unit = unit).registers except: k += 1 sleep(1.5) def read_holding_registers(self, address, count, unit): k = 0 while k < self.max_retries_read: try: return self.client.read_holding_registers(address = address, count = count, unit = unit).registers except: k += 1 sleep(1.5) def write_register(self, address, unit, value): k = 0 while k < self.max_retries_write: try: return self.client.write_register(address = address, unit = unit, value = value) except: k += 1 sleep(1.5)
class P4AModBusDriver(): def __init__(self, server, port=502, Startup=True): self.client = MBC(server, port) if Startup: self.client.connect() def close(self): self.client.close() def get_ieee754_float(self, address): return int_to_floating_bin( self.client.read_input_registers(address).registers[0]) def get_integer(self, address): return self.client.read_input_registers(address).registers[0] def write_output(self, address, value): self.client.write_register(address, value)
class Client: def __init__(self): self.client = None self.handle = None self.ip = '127.0.0.1' self.port = 502 def setup(self, config): self.handle = config self.ip = config['ipv4']['value'] self.port = config['port']['value'] self.client = ModbusTcpClient(self.ip, self.port) def execute(self, fc, addr, length=1, values=None): result = None if fc == 1: temp = self.client.read_coils(addr, length) result = [] for i in range(temp.byte_count): t2 = temp.bits[i * 16:(i + 1) * 16] result.append(''.join([str(int(x)) for x in t2])) elif fc == 2: temp = self.client.read_discrete_inputs(addr, length) result = [] for i in range(temp.byte_count): t2 = temp.bits[i * 16:(i + 1) * 16] result.append(''.join([str(int(x)) for x in t2])) elif fc == 3: temp = self.client.read_holding_registers(addr, length).registers result = ['{0:016b}'.format(x) for x in temp] elif fc == 4: temp = self.client.read_input_registers(addr, length).registers result = ['{0:016b}'.format(x) for x in temp] elif fc == 5: if values: self.client.write_coil(addr, values[0]) elif fc == 6: if values: self.client.write_register(addr, values[0]) elif fc == 15: if values: self.client.write_coils(addr, values) elif fc == 16: if values: self.client.write_registers(addr, values) return result def update_config(self, conf): self.ip = conf['ipv4']['value'] self.port = conf['port']['value'] self.client = ModbusTcpClient(self.ip, self.port) self.handle = conf def connect(self): return self.client.connect()
def post(self): query = self.reqparse.parse_args() client = ModbusClient(query['ip'], query['port']) client.connect() data = None start_address = query['start_address'] count = query['count'] if query['type_prefix'] == ModbusTypePrefix.DISCRETE_INPUT.value: data = client.read_discrete_inputs(start_address, count, unit=1) elif query['type_prefix'] == ModbusTypePrefix.COIL.value: data = client.read_coils(start_address, count, unit=1) elif query['type_prefix'] == ModbusTypePrefix.INPUT_REGISTER.value: data = client.read_input_registers(start_address, count, unit=1) elif query['type_prefix'] == ModbusTypePrefix.HOLDING_REGISTER.value: data = client.read_holding_registers(start_address, count, unit=1) client.close() result = [] print(data.registers) # if hasattr(data, 'bits'): # d = data.bits # else: # d = data.registers decoder = BinaryPayloadDecoder.fromRegisters(data.registers, byteorder=Endian.Big, wordorder=Endian.Big) # decoder.reset() # decoded = { # 'string': decoder.decode_string(8), # 'float': decoder.decode_32bit_float(), # '16uint': decoder.decode_16bit_uint(), # 'ignored': decoder.skip_bytes(2), # '8int': decoder.decode_8bit_int(), # 'bits': decoder.decode_bits(), # } e = decoder.decode_16bit_int() i = 0 while e is not False: try: print e result.append({'address': i + start_address, 'value': e}) i += 1 e = decoder.decode_16bit_int() except: e = False # for i, v in enumerate(d): # result.append({'address': i+start_address, 'value': v}) reg_fields = {'address': fields.Integer, 'value': fields.Integer} return {'registers': [marshal(reg, reg_fields) for reg in result]}
def load_test_client(client: ModbusTcpClient, name: str): results_dict = {} config_thermocouple(client, name, AIN='AIN0') while True: results_dict[60000] = client.read_input_registers(60000, 2) results_dict[2800] = client.read_input_registers(2800, 2) results_dict[0] = client.read_input_registers(0, 2) resp = results_dict[60000] data = _convert_to_32_float(resp.registers[0], resp.registers[1]) print('{}: "read version id" trans: {}, unit: {}, registers: {}' .format(name, resp.transaction_id, resp.unit_id, data)) resp = results_dict[2800] data = hex(resp.registers[0]) + hex(resp.registers[1])[2:] print('{}: "DIO" trans: {}, unit: {}, registers: {}' .format(name, resp.transaction_id, resp.unit_id, data)) resp = results_dict[0] data = _convert_to_32_float(resp.registers[0], resp.registers[1]) print('{}: "read AIN0" trans: {}, unit: {}, registers: {}' .format(name, resp.transaction_id, resp.unit_id, data)) sleep(.500)
def run_sync_client(): client = ModbusClient('192.168.1.92', port=502) client.connect() print("Connected") # Reku for i in range(0, 4): print("Reading reg ", i) reg = client.read_input_registers(2 * i, 2) s = struct.pack('<HH', reg.registers[0], reg.registers[1]) print(i, ' ', struct.unpack('f', s))
def get_b100_readings(address, port): global modbus_client if modbus_client is None: try: modbus_client = ModbusClient(address, port=port, framer=ModbusFramer) except: raise ValueError ltc_tank_temp = None top_oil_temp = None LTC_TANK_TEMP_REG = 216 TOP_OIL_TEMP_REG = 268 UNIT = 1 NUM_REGISTERS_TO_READ = 2 SCALING_VALUE = 1000 # read LTC Tank Temperature try: ltc_tank_temp_read = modbus_client.read_input_registers( LTC_TANK_TEMP_REG, NUM_REGISTERS_TO_READ, unit=UNIT) ltc_tank_temp = decode_and_scale_registers( ltc_tank_temp_read.registers, SCALING_VALUE) except Exception as ex: print(ex) ltc_tank_temp = 'error' try: top_oil_temp_read = modbus_client.read_input_registers( TOP_OIL_TEMP_REG, NUM_REGISTERS_TO_READ, unit=UNIT) top_oil_temp = decode_and_scale_registers(top_oil_temp_read.registers, SCALING_VALUE) except: top_oil_temp = 'error' readings = {'ltc_tank_temp': ltc_tank_temp, 'top_oil_temp': top_oil_temp} return readings
def sim_start_pause_stop(sim_length_min): IP = '131.243.41.14' PORT = 503 id = 2 # Connect to client client = ModbusClient(IP, port=PORT) try: # Read simulaiton time sim_start = client.read_input_registers(1, count=1, unit=id).registers[0] print('simulation start time:', sim_start) # start recording data (sim flag on) client.write_registers(int(1), int(1), unit=id) client.write_registers(int(1), int(3), unit=id) #sets simulation flag to 1 (ON) w = 1 while w > 0: sim_cur = client.read_input_registers(1, count=1, unit=id).registers[0] if sim_cur - sim_start >= sim_length_min * 60: break print('simulation end time', sim_cur) client.write_registers(int(1), int(0), unit=id) print('All Done.', client.read_input_registers(1, count=1, unit=id).registers[0]) except Exception as e: print(e) finally: client.close() print('client closed') return
class Gripper: def __init__(self, address): self.client = ModbusTcpClient(address) self.lock = threading.Lock() def disconnect(self): self.client.close() def activate(self): self.send_cmd(self.gripper_cmd(1, 0, 0, 0, 0, 0)) sleep(5) def open(self): self.send_cmd(self.gripper_cmd(1, 1, 0, 0xFF, 0xFF, 0xFF)) def close(self): self.send_cmd(self.gripper_cmd(1, 1, 0, 0x00, 0xFF, 0xFF)) @staticmethod def gripper_cmd(ract, rgto, ratr, rpr, rsp, rfr): cmd = [0, 0, 0, 0, 0, 0] cmd[0] = (ract & 0x1) | ((rgto << 0x3) & 0x8) | ((ratr << 0x4) & 0x10) cmd[3] = rpr cmd[4] = rsp cmd[5] = rfr # for i in cmd: print(hex(i)) return cmd def send_cmd(self, data): if len(data) % 2 == 1: data.append(0) message = [] for i in range(0, int(len(data) / 2)): message.append((data[2 * i] << 8) + data[2 * i + 1]) with self.lock: self.client.write_registers(0, message) def get_status(self, nbytes): nregs = int(ceil(nbytes / 2.0)) with self.lock: response = self.client.read_input_registers(0, nregs) output = [] for i in range(0, nregs): output.append((response.getRegister(i) & 0xFF00) >> 8) output.append(response.getRegister(i) & 0x00FF) return output
def sim_stop(): IP = '131.243.41.14' PORT = 503 id = 2 client = ModbusClient(IP, port=PORT) try: client.write_registers(int(1), int(0), unit=id) print('simulation stop time:',client.read_input_registers(1, count=1, unit=id).registers[0]) print('epoch:',time.time()) print(dt.datetime.fromtimestamp(time.time())) print('All Done.',client.read_input_registers(1, count=1, unit=id).registers[0]) except Exception as e: print(e) finally: client.close() print('client closed [stop]') return
def read_device_map(slave, map_address): try: client = ModbusClient(MODBUS_TCP_IP, port=MODBUS_PORT) client.connect() gems_value = client.read_input_registers(map_address, slave, unit=UNIT) client.close() return gems_value.registers[0] except Exception as e: client.close()
class ComModbusTcp: def __init__(self): self.client = None self.lock = threading.Lock() def connectToDevice(self, address): """ Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument. """ self.client = ModbusTcpClient(address) def disconnectFromDevice(self): """Close connection""" self.client.close() def sendCommand(self, data): """ Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model """ # make sure data has an even number of elements if (len(data) % 2 == 1): data.append(0) # Initiate message as an empty list message = [] # Fill message by combining two bytes in one register for i in range(0, len(data) / 2): message.append((data[2 * i] << 8) + data[2 * i + 1]) # TODO: Implement try/except with self.lock: self.client.write_registers(0, message) def getStatus(self, numBytes): """ Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument """ numRegs = int(ceil(numBytes / 2.0)) # TODO: Implement try/except # Get status from the device with self.lock: response = self.client.read_input_registers(0, numRegs) # Instantiate output as an empty list output = [] # Fill the output with the bytes in the appropriate order for i in range(0, numRegs): output.append((response.getRegister(i) & 0xFF00) >> 8) output.append(response.getRegister(i) & 0x00FF) # Output the result return output
def update(ipaddress: str): client = ModbusTcpClient(ipaddress, port=502) with client: # print "SoC batt" resp = client.read_input_registers(1056, 2, unit=25) value1 = resp.registers[0] value2 = resp.registers[1] all = format(value1, '04x') + format(value2, '04x') final = int(struct.unpack('>i', all.decode('hex'))[0]) / 10 f = open('/var/www/html/openWB/ramdisk/speichersoc', 'w') f.write(str(final)) f.close() # print "be-entladen watt" resp = client.read_input_registers(1012, 2, unit=25) value1 = resp.registers[0] value2 = resp.registers[1] all = format(value1, '04x') + format(value2, '04x') ladung = int(struct.unpack('>i', all.decode('hex'))[0]) * -1 f = open('/var/www/html/openWB/ramdisk/speicherleistung', 'w') f.write(str(ladung)) f.close()
class communication: def __init__(self): self.client = None self.lock = threading.Lock() def connectToDevice(self, address): """Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument.""" self.client = ModbusTcpClient(address) def disconnectFromDevice(self): """Close connection""" self.client.close() def sendCommand(self, data): """Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)""" # make sure data has an even number of elements if len(data) % 2 == 1: data.append(0) # Initiate message as an empty list message = [] # Fill message by combining two bytes in one register for i in range(0, len(data) / 2): message.append((data[2 * i] << 8) + data[2 * i + 1]) # To do!: Implement try/except with self.lock: self.client.write_registers(0, message) def getStatus(self, numBytes): """Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument""" numRegs = int(ceil(numBytes / 2.0)) # To do!: Implement try/except # Get status from the device with self.lock: response = self.client.read_input_registers(0, numRegs) # Instantiate output as an empty list output = [] # Fill the output with the bytes in the appropriate order for i in range(0, numRegs): output.append((response.getRegister(i) & 0xFF00) >> 8) output.append(response.getRegister(i) & 0x00FF) # Output the result return output
class AnalogChattySensor(): def __init__(self, BIT_NUMBER=0, THRESHOLD=100, RESOLUTION=3): self.BIT_NUMBER = BIT_NUMBER self.THRESHOLD = THRESHOLD self.client = ModbusTcpClient('127.0.0.1') self.encoded_message = [] self.last_value = '' self.delayed_time = 0 self.data = '' self.index = 0 self.RESOLUTION = RESOLUTION def get_data(self): return self.data def next_bit(self): self.index = self.index + 1 self.index = self.index % len(COVERT_MESSAGE) def get_measure(self): result = self.client.read_input_registers(self.BIT_NUMBER, 1) current_value = result.registers[0] < self.THRESHOLD if self.last_value != '' and self.last_value == True and current_value == False: current_time = int( str(time.time()).split('.')[1][:self.RESOLUTION]) if int(COVERT_MESSAGE[self.index]) == current_time % 2: delta_time = int(str( time.time()).split('.')[1][:3]) - self.delayed_time self.data = "\t".join([ "Chatty Sensor:", str(time.time()).split('.')[1][:self.RESOLUTION], COVERT_MESSAGE[self.index], str(delta_time) ]) self.encoded_message.append( str(time.time()).split('.')[1][:self.RESOLUTION]) self.last_value = current_value else: current_value = self.last_value self.delayed_time = int(str(time.time()).split('.')[1][:3]) else: self.delayed_time = int(str(time.time()).split('.')[1][:3]) self.last_value = current_value return current_value def __del__(self): self.client.close()
def modbus_poller(id, stop_event, config): log = logging.getLogger("worker-" + str(id)) log.setLevel(logging.DEBUG) client = ModbusClient(host=config["address"], port=config["port"]) client.connect() log.info("Worker started") t_max = -1 while not stop_event.is_set(): log.info("Poller turn") t0 = time() address = 0 for i in poll_range(config["num_controls"], config["chunk_size"]): result = client.read_input_registers(address=address, count=i, unit=1) address += i if result is not None: if result.function_code >= 0x80 and result.function_code != 132: log.warn("Server returned error!") print result stop_event.set() break elif result.function_code == 132: print "Server fault: " + str(result) sleep(1) break t = time() - t0 log.info("Request took " + str(t) + " s") if t > t_max: t_max = t sleep(config["thread"]["interval"]) log.info("Worker shutting down") log.info("Max worker process time: " + str(t_max)) client.close()
def readMBinputregisters(clientIP, register, number=1): from pymodbus.client.sync import ModbusTcpClient, ConnectionException values = [] client = ModbusTcpClient(clientIP) try: rawresult = client.read_input_registers(register, number) except ConnectionException: # print('we were unable to connect to the host') statuscode = 7 else: # print(rawresult) try: resultregisters = rawresult.registers except AttributeError: statuscode = rawresult.exception_code else: statuscode = 0 values = resultregisters client.close() result = {'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values':values} return result
def get_pv_data(config): host = config.get('inv_host') port = config.get('inv_port', 502) modbusid = config.get('inv_modbus', 3) manufacturer = config.get('inv_modbus', 'Default') registers = eval(config.get('registers')) client = ModbusClient(host=host, port=port) try: client.connect() except: print('Modbus Connection Error', 'could not connect to target. Check your settings, please.') return None data = {} ## empty data store for current values for myreg in registers: ## if the connection is somehow not possible (e.g. target not responding) # show a error message instead of excepting and stopping try: received = client.read_input_registers(address=int(myreg[0]), count=modbusdatatype[myreg[1]], unit=modbusid) except: thisdate = str(datetime.datetime.now()).partition('.')[0] thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.' print(thiserrormessage) return None ## prevent further execution of this function name = myreg[3] message = BinaryPayloadDecoder.fromRegisters(received.registers, byteorder=Endian.Big, wordorder=Endian.Big) ## provide the correct result depending on the defined datatype if myreg[1] == 'S32': interpreted = message.decode_32bit_int() elif myreg[1] == 'U32': interpreted = message.decode_32bit_uint() elif myreg[1] == 'U64': interpreted = message.decode_64bit_uint() elif myreg[1] == 'STR32': interpreted = message.decode_string(32) elif myreg[1] == 'S16': interpreted = message.decode_16bit_int() elif myreg[1] == 'U16': interpreted = message.decode_16bit_uint() else: ## if no data type is defined do raw interpretation of the delivered data interpreted = message.decode_16bit_uint() ## check for "None" data before doing anything else if ((interpreted == MIN_SIGNED) or (interpreted == MAX_UNSIGNED)): value = None else: ## put the data with correct formatting into the data table if myreg[2] == 'FIX3': value = float(interpreted) / 1000 elif myreg[2] == 'FIX2': value = float(interpreted) / 100 elif myreg[2] == 'FIX1': value = float(interpreted) / 10 elif myreg[2] == 'UTF8': value = str(interpreted,'UTF-8').rstrip("\x00") elif myreg[2] == 'ENUM': e=pvenums.get(name,{}) value = e.get(interpreted,str(interpreted)) else: value = interpreted data[name] = value client.close() return data
def discover(type): responses=list() result = [] valid_iphead = False try: infile = None # infile = open(os.path.expanduser("~")+"/workspace/bemoss_os/machine_ip.txt","r") #### infile = open("machine_ip.txt", "r") #### for line in infile: # line= "192.168.1.2" #### own_ip = line.rstrip() own_ip_parts = own_ip.split('.') if len(own_ip_parts) == 4: print( "Found own IP: "+own_ip) iphead = own_ip_parts[0]+'.'+own_ip_parts[1]+'.'+own_ip_parts[2]+'.' valid_iphead = True break infile.close() except: if infile is not None: infile.close() valid_iphead = False # print("reached half way ") if valid_iphead: # print("inside ip head") start_ip=2 end_ip=254 print ("Looking for Modbus Devices in the IP range: "+iphead+str(start_ip)+" to "+iphead+str(end_ip)) _Timeout=0.2 ip_index=start_ip iprange=list() # print("start ip index") while ip_index<=end_ip: iprange.append(iphead+str(ip_index)) # print("ipindex: ",ip_index) ip_index=ip_index+1 print("********************") #print iprange counter = 1 #### for ip in iprange: counter += 1 #### if (counter != 99): #### continue #### print("checking in the ip range: ",ip) try: #print ip _socket = None #### # _socket = socket.socket() try: _socket = socket.create_connection((ip, 502), _Timeout) print("Connection successful: ",ip, "socket: ",_socket) except socket.error: if _socket: #### _socket.close() #### print("socket error") #### _socket = None if _socket is not None: _socket.close() #### Defaults.Timeout = 10 #### client = ModbusTcpClient(ip) print("ModbusTcpClient: ", client) # client.bind(("192.168.1.2",0)) print(client.connect()) if type == 'Prolon_VAV': possible_slave_ids = [1, 2, 7, 16] elif type == 'Prolon_RTU': possible_slave_ids = [15, 20] else: possible_slave_ids = [] print("possible slave ids: ",possible_slave_ids) for slave_id in possible_slave_ids: print("slave: ",slave_id) print("result b4: ",result) result = client.read_input_registers(0,unit=slave_id) print("slave_id: ",slave_id," result: ",result) if result is not None: responses.append(ip+':'+str(slave_id)) print("end of loop ",slave_id) client.close() print("client closed") break #### except Exception as e: print("error: ",e) pass if (ip == 99): break print("End of outer for loop.") else: print ("Modbus discovery failed: Couldn't find IP subnet of network!") print("responses: ",responses) return responses
class clientthreads(threading.Thread): def __init__(self, vnic, ipaddr, port): threading.Thread.__init__(self) self.ipaddr = ipaddr # ip address self.port = port # port address self.vnic = vnic # virtual nic self.mode = "" # server or client self.state = "" # up or down self.dest = "" # destination address for client self.clientstop = threading.Event() self.server = "" self.client = "" self.framer = "" self.vnicm = "" self.runtime= 0 self.delayr = random.uniform(0,5) self.delayw = random.uniform(0,60) self.firstdelay = 0 self.pstart= "" def run(self): self.client = ModbusTcpClient(self.dest, self.port, source_address=(self.ipaddr, 0), retries=1, retry_on_empty=True) if(self.mode=="read"): self.clientintr() elif(self.mode=="write"): self.clientintw() else: print "wrong mode specified" def clientintr(self): # instantiate server stuff while(not self.clientstop.is_set()): if(time.time() - self.pstart > self.runtime): print "stopping" break if(self.firstdelay < 1): print "Start RDelay is: " + str(self.delayr) time.sleep(self.delayr) self.firstdelay = 1 print "Starting Reads" self.clientreads() print "\n\r-----read-----\n\r" print self.dest print time.time() - self.pstart print "------------------\n\r" def clientintw(self): # instantiate server stuff while(not self.clientstop.is_set()): if(time.time() - self.pstart > self.runtime): print "stopping" break if(self.firstdelay < 1): print "Start WDelay is: " + str(self.delayw) time.sleep(self.delayw) self.firstdelay = 1 print "Starting Writes" self.clientwrites() print "\n\r-----write----\n\r" print self.dest print time.time() - self.pstart print "------------------\n\r" def clientreads(self): self.client.read_coils(1, 10) self.client.read_discrete_inputs(1, 10) self.client.read_holding_registers(1, 10) self.client.read_input_registers(1, 10) time.sleep(5) def clientwrites(self): self.client.write_coil(1, True) self.client.write_register(1, 3) self.client.write_coils(1, [True]*10) self.client.write_registers(1, [3]*10) time.sleep(60) def alloc(self): # Allocate ip address if (validateIP(self.ipaddr, self.vnicm)): cmdargs = [self.vnic, self.ipaddr] subprocess.call(["ifconfig"] + cmdargs) else: return 0 def dealloc(self): # De-allocate ip address cmdargs = [self.vnic] subprocess.call(["ifconfig"] + cmdargs + ["down"]) def stop(self): self.clientstop.set() return
"Thermal/AmbientTemp", "Thermal/AmbientTemp/1hAvg", "Thermal/AmbientHumidity", "Thermal/AmbientHumidity/1hAvg", "Thermal/TopOilTemp", "Thermal/TopOilTemp/1hAvg", "Thermal/BottomOilTemp", "Thermal/BottomOilTemp/1hAvg", "Thermal/TapChangerTemp", "Thermal/TapChangerTemp/1hAvg" ] numInputs = 10 startAddress = 1000 slaveID = 1 result = client.read_input_registers(startAddress, numInputs, slaveID) for i in range(0, len(totusTemps)): print totusTemps[i] + " = " + str(result.getRegister(i)/10.0) + "\xb0C"# scaling is 10 # read alarms totusAlarms = [ "ALARM/System/HL/State", "ALARM/System/HHLL/State" ] numInputs = 2 startAddress = 100 slaveID = 1
from pymodbus.constants import Endian from pymodbus.payload import BinaryPayloadDecoder from pymodbus.client.sync import ModbusTcpClient as ModbusClient import logging logging.basicConfig() log = logging.getLogger() log.setLevel(logging.DEBUG) client = ModbusClient(host='193.196.78.187', port=501) print client.connect() result = client.read_input_registers(address=16, count=2, unit=65) print result.registers decoder = BinaryPayloadDecoder.fromRegisters(result.registers, endian=Endian.Little) decoded = decoder.decode_32bit_float() print decoded client.close() #time.sleep(0.5) # print('result',str(result.registers))
class Connection(): def __init__(self, indicator_list, coil_on_list, coil_off_list, command_list, coil_list, port, method="rtu", timeout=0.1, unit=0x01): self.unit = unit self.indicator_list = indicator_list self.coil_on_list = coil_on_list self.coil_off_list = coil_off_list self.coil_list = coil_list self.command_list = command_list self.lock = threading.Lock() if method == "rtu": self.client = ModbusSerialClient(method=method, port=port, baudrate=19200, stopbits=1, bytesize=8, timeout=timeout) elif method == "tcp": self.client = ModbusTcpClient(host=port) def translate(self, command): self.lock.acquire() self.client.connect() print self.client.connect() # input registers if command.split("_")[0] == "IReg": rr = self.client.read_input_registers(self.indicator_list[command.split()[0]], 1, unit=self.unit) self.client.close() self.lock.release() return rr.getRegister(0) # coils elif command.split("_")[0] == "Coil": if command.split()[0] in self.coil_on_list: wr = self.client.write_coil(self.coil_on_list[command.split()[0]], 1, unit=self.unit) rr = self.client.read_coils(self.coil_on_list[command.split()[0]], 1, unit=self.unit) elif command.split()[0] in self.coil_off_list: wr = self.client.write_coil(self.coil_off_list[command.split()[0]], 0, unit=self.unit) rr = self.client.read_coils(self.coil_off_list[command.split()[0]], 1, unit=self.unit) elif command.split()[0] in self.coil_list and len(command.split()) > 1 and \ command.split()[1].isdigit(): wr = self.client.write_coil(self.coil_list[command.split()[0]], int(command.split()[1]), unit=self.unit) rr = self.client.read_coils(self.coil_list[command.split()[0]], 1, unit=self.unit) self.client.close() self.lock.release() return rr.getBit(0) # holding registers elif command.split("_")[0] == "HReg": if len(command.split()) > 1 and command.split()[1].isdigit(): wr = self.client.write_registers(self.command_list[command.split()[0]], [int(command.split()[1])], unit=self.unit) rr = self.client.read_holding_registers(self.command_list[command.split()[0]], 1, unit=self.unit) self.client.close() self.lock.release() return rr.getRegister(0) else: print "Not correct command" self.lock.release() return "Not correct command"
assert(rq.function_code < 0x80) # test that we are not an error log.debug("Write to a holding register and read back") rq = client.write_register(1, 10, unit=1) rr = client.read_holding_registers(1, 1, unit=1) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers[0] == 10) # test the expected value log.debug("Write to multiple holding registers and read back") rq = client.write_registers(1, [10]*8, unit=1) rr = client.read_holding_registers(1, 8, unit=1) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers == [10]*8) # test the expected value log.debug("Read input registers") rr = client.read_input_registers(1, 8, unit=1) assert(rq.function_code < 0x80) # test that we are not an error arguments = { 'read_address': 1, 'read_count': 8, 'write_address': 1, 'write_registers': [20]*8, } log.debug("Read write registeres simulataneously") rq = client.readwrite_registers(unit=1, **arguments) rr = client.read_holding_registers(1, 8, unit=1) assert(rq.function_code < 0x80) # test that we are not an error assert(rq.registers == [20]*8) # test the expected value assert(rr.registers == [20]*8) # test the expected value
except: print("Error creating the data file!") # Write the column names df.write("sn,sta1_delay,sta2_delay,sta3_delay,sta4_delay,sta6_delay,sta1_to_sta2_delay,sta2_to_sta3_delay,sta3_to_sta4_delay,sta6_to_sta1_delay,inspection_result\n") print("[DONE]") print("Exporting data..."), # Maximum parts the PLC can track is currently 512; iterate through all for part in range(1,512): # Inform the PLC task which index we want to read request = client.write_register(0x800B, part) # PLC needs time to update before we read the data time.sleep(0.02) # Read the data rd = client.read_input_registers(0x800A, 11) # Part SN's (the first element) are updated as parts are presented # to Station 6, and are sequential. So, if the first element value # does not match the expected one, there is no more data to be exported. if rd.registers[0] != part: break else: #print (rd.registers) sdata = "" # Iterate through each element and add it to the CSV string for word in rd.registers: if sdata != "": sdata = sdata + "," sdata = sdata + str(word) # Write the data to the file, and add a new line df.write(sdata + "\n")
rr = client.read_input_registers(8009,1) print rr ''' ''' rr = client.read_input_registers(8000,1) print rr.registers rr = client.read_input_registers(8001,1) print rr.registers rr = client.read_holding_registers(8001, 1) print rr.registers ''' i=1 uptime = time.time() while True: rq = client.write_registers(8001, [i]*1) print i rr = client.read_input_registers(8000, 1) print rr.registers if i < 7: i = i * 2 print time.time() - uptime else: i=1 os.system("cls") time.sleep(1) #---------------------------------------------------------------------------# # close the client #---------------------------------------------------------------------------# client.close()
def discover(type): responses=list() valid_iphead = False try: infile = None infile = open(os.path.expanduser("~")+"/workspace/bemoss_os/machine_ip.txt","r") for line in infile: own_ip = line.rstrip() own_ip_parts = own_ip.split('.') if len(own_ip_parts) == 4: print "Found own IP: "+own_ip iphead = own_ip_parts[0]+'.'+own_ip_parts[1]+'.'+own_ip_parts[2]+'.' valid_iphead = True break infile.close() except: if infile is not None: infile.close() valid_iphead = False if valid_iphead: start_ip=2 end_ip=254 print "Looking for Modbus Devices in the IP range: "+iphead+str(start_ip)+" to "+iphead+str(end_ip) _Timeout=0.2 ip_index=start_ip iprange=list() while ip_index<=end_ip: iprange.append(iphead+str(ip_index)) ip_index=ip_index+1 #print iprange for ip in iprange: try: #print ip _socket = None try: _socket = socket.create_connection((ip, 502), _Timeout) except socket.error: if _socket: _socket.close() _socket = None if _socket is not None: _socket.close() client = ModbusTcpClient(ip,port=502) client.connect() if type == 'Prolon_VAV': possible_slave_ids = [1,2,7] elif type == 'Prolon_RTU': possible_slave_ids = [15,20] else: possible_slave_ids = [] for slave_id in possible_slave_ids: result = client.read_input_registers(0,unit=slave_id) if result is not None: responses.append(ip+':'+str(slave_id)) client.close() except: pass else: print "Modbus discovery failed: Couldn't find IP subnet of network!" return responses
def getDeviceStatus(self): getDeviceStatusResult = True try: client = ModbusTcpClient(self.get_variable('address'),port=502) client.connect() if (self.get_variable('model')=='VC1000'): result = client.read_input_registers(0,8,unit=self.get_variable('slave_id')) if int(result.registers[0])==32767: self.set_variable('temperature',None) else: self.set_variable('temperature',float('%.1f' % self.cel2far(float(int(result.registers[0]))/100.0))) self.set_variable('heat_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[1]))/100.0))) self.set_variable('cool_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[2]))/100.0))) if int(result.registers[7])==32767: self.set_variable('supply_temperature',None) else: self.set_variable('supply_temperature',float('%.1f' % self.cel2far(float(int(result.registers[7]))/100.0))) result = client.read_holding_registers(159,2,unit=self.get_variable('slave_id')) if (int(result.registers[0])==1): self.set_variable('flap_override','ON') else: self.set_variable('flap_override','OFF') self.set_variable('flap_position',int(result.registers[1])) elif (self.get_variable('model')=='M1000'): result = client.read_input_registers(0,26,unit=self.get_variable('slave_id')) if int(result.registers[18])==32767: self.set_variable('temperature',None) else: self.set_variable('temperature',float('%.1f' % self.cel2far(float(int(result.registers[18]))/100.0))) self.set_variable('heat_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[19]))/100.0))) self.set_variable('cool_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[20]))/100.0))) if int(result.registers[0])==32767: self.set_variable('supply_temperature',None) else: self.set_variable('supply_temperature',float('%.1f' % self.cel2far(float(int(result.registers[0]))/100.0))) if int(result.registers[1])==32767: self.set_variable('return_temperature',None) else: self.set_variable('return_temperature',float('%.1f' % self.cel2far(float(int(result.registers[1]))/100.0))) if int(result.registers[2])==32767: self.set_variable('outside_temperature',None) else: self.set_variable('outside_temperature',float('%.1f' % self.cel2far(float(int(result.registers[2]))/100.0))) self.set_variable('pressure',float(int(result.registers[22]))/100.0) self.set_variable('outside_damper_position',int(result.registers[17])) self.set_variable('bypass_damper_position',int(result.registers[25])) cool1=int(result.registers[4]) cool2=int(result.registers[12]) cool3=int(result.registers[13]) cool4=int(result.registers[14]) if (int(result.registers[15])==1): self.set_variable('fan_status','ON') else: self.set_variable('fan_status','OFF') result = client.read_holding_registers(129,1,unit=self.get_variable('slave_id')) if int(result.registers[0]) > 100: self.set_variable('heating',0) else: self.set_variable('heating',int(result.registers[0])) result = client.read_holding_registers(10,1,unit=self.get_variable('slave_id')) if int(result.registers[0]) == 0: self.set_variable('cooling_mode','None') self.set_variable('cooling_status','OFF') elif int(result.registers[0]) == 1: self.set_variable('cooling_mode','STG1') if cool1 == 0: self.set_variable('cooling_status','OFF') else: self.set_variable('cooling_status','ON') elif int(result.registers[0]) == 2: self.set_variable('cooling_mode','STG2') if cool2 == 0: self.set_variable('cooling_status','OFF') else: self.set_variable('cooling_status','ON') elif int(result.registers[0]) == 3: self.set_variable('cooling_mode','STG3') if cool3 == 0: self.set_variable('cooling_status','OFF') else: self.set_variable('cooling_status','ON') elif int(result.registers[0]) == 4: self.set_variable('cooling_mode','STG4') if cool4 == 0: self.set_variable('cooling_status','OFF') else: self.set_variable('cooling_status','ON') client.close() except Exception as er: print "classAPI_vav_rtu: ERROR: Reading Modbus registers at getDeviceStatus:" print er getDeviceStatusResult = False if getDeviceStatusResult==True: self.set_variable('offline_count',0) else: self.set_variable('offline_count',self.get_variable('offline_count')+1)
rr = client.read_coils(1,8) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.bits == [True]*8) # test the expected value rq = client.write_coils(1, [False]*8) rr = client.read_discrete_inputs(1,8) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.bits == [True]*8) # test the expected value rq = client.write_register(1, 10) rr = client.read_holding_registers(1,1) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers[0] == 10) # test the expected value rq = client.write_registers(1, [10]*8) rr = client.read_input_registers(1,8) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers == [17]*8) # test the expected value arguments = { 'read_address': 1, 'read_count': 8, 'write_address': 1, 'write_registers': [20]*8, } rq = client.readwrite_registers(**arguments) rr = client.read_input_registers(1,8) assert(rq.function_code < 0x80) # test that we are not an error assert(rq.registers == [20]*8) # test the expected value assert(rr.registers == [17]*8) # test the expected value
def run_sync_client(): # ------------------------------------------------------------------------# # choose the client you want # ------------------------------------------------------------------------# # make sure to start an implementation to hit against. For this # you can use an existing device, the reference implementation in the tools # directory, or start a pymodbus server. # # If you use the UDP or TCP clients, you can override the framer being used # to use a custom implementation (say RTU over TCP). By default they use # the socket framer:: # # client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer) # # It should be noted that you can supply an ipv4 or an ipv6 host address # for both the UDP and TCP clients. # # There are also other options that can be set on the client that controls # how transactions are performed. The current ones are: # # * retries - Specify how many retries to allow per transaction (default=3) # * retry_on_empty - Is an empty response a retry (default = False) # * source_address - Specifies the TCP source address to bind to # # Here is an example of using these options:: # # client = ModbusClient('localhost', retries=3, retry_on_empty=True) # ------------------------------------------------------------------------# client = ModbusClient('localhost', port=5020) # client = ModbusClient(method='ascii', port='/dev/pts/2', timeout=1) # client = ModbusClient(method='rtu', port='/dev/ttyp0', timeout=1) client.connect() # ------------------------------------------------------------------------# # specify slave to query # ------------------------------------------------------------------------# # The slave to query is specified in an optional parameter for each # individual request. This can be done by specifying the `unit` parameter # which defaults to `0x00` # ----------------------------------------------------------------------- # log.debug("Reading Coils") rr = client.read_coils(1, 1, unit=0x01) print(rr) # ----------------------------------------------------------------------- # # example requests # ----------------------------------------------------------------------- # # simply call the methods that you would like to use. An example session # is displayed below along with some assert checks. Note that some modbus # implementations differentiate holding/input discrete/coils and as such # you will not be able to write to these, therefore the starting values # are not known to these tests. Furthermore, some use the same memory # blocks for the two sets, so a change to one is a change to the other. # Keep both of these cases in mind when testing as the following will # _only_ pass with the supplied async modbus server (script supplied). # ----------------------------------------------------------------------- # log.debug("Write to a Coil and read back") rq = client.write_coil(0, True, unit=UNIT) rr = client.read_coils(0, 1, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.bits[0] == True) # test the expected value log.debug("Write to multiple coils and read back- test 1") rq = client.write_coils(1, [True]*8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error rr = client.read_coils(1, 21, unit=UNIT) assert(rr.function_code < 0x80) # test that we are not an error resp = [True]*21 # If the returned output quantity is not a multiple of eight, # the remaining bits in the final data byte will be padded with zeros # (toward the high order end of the byte). resp.extend([False]*3) assert(rr.bits == resp) # test the expected value log.debug("Write to multiple coils and read back - test 2") rq = client.write_coils(1, [False]*8, unit=UNIT) rr = client.read_coils(1, 8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.bits == [False]*8) # test the expected value log.debug("Read discrete inputs") rr = client.read_discrete_inputs(0, 8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error log.debug("Write to a holding register and read back") rq = client.write_register(1, 10, unit=UNIT) rr = client.read_holding_registers(1, 1, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers[0] == 10) # test the expected value log.debug("Write to multiple holding registers and read back") rq = client.write_registers(1, [10]*8, unit=UNIT) rr = client.read_holding_registers(1, 8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error assert(rr.registers == [10]*8) # test the expected value log.debug("Read input registers") rr = client.read_input_registers(1, 8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error arguments = { 'read_address': 1, 'read_count': 8, 'write_address': 1, 'write_registers': [20]*8, } log.debug("Read write registeres simulataneously") rq = client.readwrite_registers(unit=UNIT, **arguments) rr = client.read_holding_registers(1, 8, unit=UNIT) assert(rq.function_code < 0x80) # test that we are not an error assert(rq.registers == [20]*8) # test the expected value assert(rr.registers == [20]*8) # test the expected value # ----------------------------------------------------------------------- # # close the client # ----------------------------------------------------------------------- # client.close()
cos_write = client.write_coils(args.offset, coils) assert(cos_write.function_code < 0x80) elif args.mode == 'r': # NOTE: read_holding_registers if args.type == 'HR': hr_read = client.read_holding_registers(args.offset, count=args.count) assert(hr_read.function_code < 0x80) print(hr_read.registers[0:args.count]) # NOTE: read_holding_registers elif args.type == 'IR': ir_read = client.read_input_registers(args.offset, count=args.count) assert(ir_read.function_code < 0x80) print(ir_read.registers[0:args.count]) # NOTE: read_discrete_inputs elif args.type == 'DI': di_read = client.read_discrete_inputs(args.offset, count=args.count) assert(di_read.function_code < 0x80) print(di_read.bits) # NOTE: read_discrete_inputs elif args.type == 'CO': co_read = client.read_coils(args.offset, count=args.count) assert(co_read.function_code < 0x80)
# ---------------------------------------------------------------------------# # If you need to decode a collection of registers in a weird layout, the # payload decoder can help you as well. # # Here we demonstrate decoding a random register layout, unpacked it looks # like the following: # # - a 8 byte string 'abcdefgh' # - a 32 bit float 22.34 # - a 16 bit unsigned int 0x1234 # - an 8 bit int 0x12 # - an 8 bit bitstring [0,1,0,1,1,0,1,0] # ---------------------------------------------------------------------------# address = 0x01 count = 8 result = client.read_input_registers(address, count) decoder = BinaryPayloadDecoder.fromRegisters(result.registers, endian=Endian.Little) decoded = { "string": decoder.decode_string(8), "float": decoder.decode_32bit_float(), "16uint": decoder.decode_16bit_uint(), "8int": decoder.decode_8bit_int(), "bits": decoder.decode_bits(), } print "-" * 60 print "Decoded Data" print "-" * 60 for name, value in decoded.iteritems(): print ("%s\t" % name), value
class ModbusTest(object): """ Modbus Test Basisklasse """ def __init__(self, host=None, slave_id=1, function_code=None, register_addr=None, data_type=None, endian='big'): self.client = None self.host = host self.slave_id = slave_id self.function_code = function_code self.register_addr = register_addr self.data_type = data_type if endian == 'big': self.endian = Endian.Big else: self.endian = Endian.Little def connect(self): _logger.debug('connect {}'.format(self.host)) self.client = ModbusClient(self.host, port=502) self.client.connect() def run(self): self.connect() try: while True: try: value = self.read() except IOError as e: print e else: self.print_value(value) time.sleep(2) except KeyboardInterrupt: self.client.close() pass def read(self): count = COUNTS.get(self.data_type) if not count: raise ValueError('Unsupported data type {}'.format(self.data_type)) _logger.debug('read register: {}, count: {}, slave: {}, function: {}'.format(self.register_addr, count, self.slave_id, self.function_code)) if self.function_code == 3: result = self.client.read_holding_registers(self.register_addr, count, unit=self.slave_id) elif self.function_code == 4: result = self.client.read_input_registers(self.register_addr, count, unit=self.slave_id) else: raise ValueError('Unsupported function code {}'.format(self.function_code)) if result is None: raise IOError('No modbus reponse') if isinstance(result, ExceptionResponse): raise IOError(str(result)) d = BinaryPayloadDecoder.fromRegisters(result.registers, endian=self.endian) if self.data_type == '16bit_int': value = d.decode_16bit_int() elif self.data_type == '16bit_uint': value = d.decode_16bit_uint() elif self.data_type == '32bit_int': value = d.decode_32bit_int() elif self.data_type == '32bit_uint': value = d.decode_32bit_uint() elif self.data_type == '32bit_float': value = d.decode_32bit_float() elif self.data_type == '64bit_float': value = d.decode_64bit_float() else: raise ValueError('Unsupported data type {}'.format(self.data_type)) return value def print_value(self, value): """ Methode zur Ausgabe des Messwertes muss von der erbenden Klasse implementiert werden. """ raise NotImplementedError