def new_modbus_reading(config): time.sleep(1) global influx_lock global RECORDS global CONNECTION_POOL modbus_ip = config.get("ip") modbus_port = config.get("port", 502) modbus_register = config.get("register") sensor_name = config.get("name", config["generated_sensor_id"]) sensor_type = config.get("sensor_type") data_type = config.get("type") sensor_unit = config.get("unit") sensor_location = config.get("location", "not specified") divide_factor = config.get("modbus_divide_by", 1) multiply_factor = config.get("modbus_multiply_by", 1) #print('%s: %s' % (sensor_name, modbus_register)) #print(f">> {sensor_name}") insertion_count = 0 # modbus_client = ModbusClient(host=modbus_ip, port=modbus_port, auto_open=True, auto_close=True) read_count_bytes = 0 if data_type == "float32": read_count_bytes = 2 elif data_type == "int32": read_count_bytes = 2 elif data_type == "uint32": read_count_bytes = 2 elif data_type == "int16": read_count_bytes = 1 elif data_type == "uint16": read_count_bytes = 1 elif data_type == "bool": read_count_bytes = 1 else: raise Exception( f"Could not understand how to parse the following data_type '{data_type}'" ) connection_key = f"{modbus_ip}_{modbus_port}" if connection_key not in CONNECTION_POOL: CONNECTION_POOL[connection_key] = ModbusTcpClient(modbus_ip, port=modbus_port) CONNECTION_POOL[connection_key].connect() client = CONNECTION_POOL[connection_key] value = client.read_holding_registers(modbus_register, read_count_bytes, unit=1) # client.close() # Default byte order default_byteorder = '<' default_wordorder = '<' byteorder = config.get("byteorder", default_byteorder) wordorder = config.get("wordorder", default_wordorder) if not hasattr(value, "registers"): LOGGER.error(f"ERROR with {sensor_name}") decoder = BinaryPayloadDecoder.fromRegisters(value.registers, byteorder=byteorder, wordorder=wordorder) decode_func = None if data_type == "float32": decode_func = decoder.decode_32bit_float() elif data_type == "int16": decode_func = decoder.decode_16bit_int() elif data_type == "uint16": decode_func = decoder.decode_16bit_uint() elif data_type == "int32": decode_func = decoder.decode_32bit_int() elif data_type == "uint32": decode_func = decoder.decode_32bit_uint() else: raise Exception( f"Could not understand how to parse the following data_type '{data_type}'" ) decoded = {f'{sensor_name}': decode_func} #print(decode_func) try: sensor_value = 1.0 * multiply_factor * decode_func / divide_factor except: LOGGER.exception( "[%s] failed to read a value from socomec (%s:%s:%s)" % (sensor_name, modbus_ip, sensor_unit, modbus_register)) return { "status": "failure", "reason": "could not read socomec (%s:%s:%s)" % (modbus_ip, sensor_unit, modbus_register) } if sensor_value is None: LOGGER.error("[%s] failed to read an accurate value (%s)" " from socomec (%s:%s)" % (sensor_name, sensor_value, modbus_ip, modbus_register)) return { "status": "failure", "reason": "failed to read an accurate (%s) value" " from socomec (%s:%s:%s)" % (sensor_name, modbus_ip, modbus_register) } data = [{ "measurement": "sensors", "fields": { "value": float(sensor_value) }, "tags": { "location": sensor_location, "sensor": sensor_name, "unit": sensor_unit, "sensor_type": sensor_type } }] # Put the modbus sensor's value in the list of values that should be inserted in DB influx_lock.acquire() RECORDS += data influx_lock.release() return False
#!/usr/bin/python import sys import os import time import getopt import socket import ConfigParser import struct import binascii verbrauchernr = str(sys.argv[1]) seradd = str(sys.argv[2]) from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient(seradd, port=8899) sdmid = int(sys.argv[3]) resp = client.read_input_registers(0x0006,2, unit=sdmid) al1 = struct.unpack('>f',struct.pack('>HH',*resp.registers)) al1 = float("%.3f" % al1[0]) al1string = "/var/www/html/openWB/ramdisk/verbraucher%s_a1" % (verbrauchernr) f = open(al1string, '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]) wattstring = "/var/www/html/openWB/ramdisk/verbraucher%s_watt" % (verbrauchernr) f = open(wattstring, 'w')
# This will try the Sungrow client otherwise will default to the standard library. client_payload = { "host": config.inverter_ip, "timeout": config.timeout, "RetryOnEmpty": True, "retries": 3, "port": config.inverter_port, } if "sungrow-" in config.model: logging.info("Creating SungrowModbusTcpClient") client = SungrowModbusTcpClient.SungrowModbusTcpClient(**client_payload) else: logging.info("Creating ModbusTcpClient") client = ModbusTcpClient(**client_payload) logging.info("Connecting") client.connect() client.close() logging.info("Connected") # Configure MQTT if hasattr(config, "mqtt_server"): mqtt_client = mqtt.Client(getattr(config, "mqtt_client_name", "pv_data")) if hasattr(config, "mqtt_username") and hasattr(config, "mqtt_password"): mqtt_client.username_pw_set(config.mqtt_username, config.mqtt_password) if config.mqtt_port == 8883: mqtt_client.tls_set()
def testSerialClientRpr(self): client = ModbusTcpClient() rep = "<{} at {} socket={}, ipaddr={}, port={}, timeout={}>".format( client.__class__.__name__, hex(id(client)), client.socket, client.host, client.port, client.timeout) self.assertEqual(repr(client), rep)
from time import sleep from pymodbus.client.sync import ModbusTcpClient inputState = [False] * 32 outputState = [False] * 32 clientDI_1 = ModbusTcpClient('192.168.82.77') clientDO_1 = ModbusTcpClient('192.168.82.76') clientDO_1.write_coils(1, inputState) while not sleep(0.05): try: result = clientDI_1.read_discrete_inputs(1, 32) activeButtonsIndexes = [i for i, x in enumerate(result.bits) if x] for index in activeButtonsIndexes: if inputState[index] != result.bits[index]: print(f"Button pressed {index}") outputState[index] = not outputState[index] inputState = result.bits clientDO_1.write_coils(1, outputState) clientDI_1.close() clientDO_1.close() except: print("error, resetting")
#!/usr/bin/python #USAGE #chmod 0755 readclassic.py #./readclassic.py 192.168.0.223 from pymodbus.client.sync import ModbusTcpClient import sys HOST= str(sys.argv[1]) client = ModbusTcpClient(HOST) def connect(): global client connected = 0 count = 0 while (not connected): resp = client.connect() if (resp == False): sys.exit(1); #time.sleep(10) else: connected = 1 count = count + 1 def close(): global client client.close()
import csv, os, datetime, sys, win32print from pymodbus.client.sync import ModbusTcpClient from pymodbus.exceptions import ModbusException client = ModbusTcpClient('192.168.1.10') # print command def printer(raw_data): default_printer = win32print.GetDefaultPrinter() h = win32print.OpenPrinter(default_printer) win32print.StartDocPrinter(h, 1, ("", "", "RAW")) win32print.WritePrinter(h, raw_data) win32print.EndDocPrinter(h) win32print.ClosePrinter(h) # 16bit word to byte conversion def word_2_2Dbyte(x): c = (x >> 8) & 0xff b = x & 0xff return c, b # byte to string conversion def word2string(v): conv = [word_2_2Dbyte(i) for i in v] b = [j for s in conv for j in s] ch = [chr(int(l)) for l in b] st = '' for k in ch:
async def async_setup(self): """Set up pymodbus client.""" try: if self._config_type == "serial": self._client = ModbusSerialClient( method=self._config_method, port=self._config_port, baudrate=self._config_baudrate, stopbits=self._config_stopbits, bytesize=self._config_bytesize, parity=self._config_parity, timeout=self._config_timeout, retry_on_empty=True, reset_socket=self._config_reset_socket, ) elif self._config_type == "rtuovertcp": self._client = ModbusTcpClient( host=self._config_host, port=self._config_port, framer=ModbusRtuFramer, timeout=self._config_timeout, reset_socket=self._config_reset_socket, ) elif self._config_type == "tcp": self._client = ModbusTcpClient( host=self._config_host, port=self._config_port, timeout=self._config_timeout, reset_socket=self._config_reset_socket, ) elif self._config_type == "udp": self._client = ModbusUdpClient( host=self._config_host, port=self._config_port, timeout=self._config_timeout, reset_socket=self._config_reset_socket, ) except ModbusException as exception_error: self._log_error(exception_error, error_state=False) return async with self._lock: await self.hass.async_add_executor_job(self._pymodbus_connect) self._call_type[CALL_TYPE_COIL][ENTRY_FUNC] = self._client.read_coils self._call_type[CALL_TYPE_DISCRETE][ ENTRY_FUNC] = self._client.read_discrete_inputs self._call_type[CALL_TYPE_REGISTER_HOLDING][ ENTRY_FUNC] = self._client.read_holding_registers self._call_type[CALL_TYPE_REGISTER_INPUT][ ENTRY_FUNC] = self._client.read_input_registers self._call_type[CALL_TYPE_WRITE_COIL][ ENTRY_FUNC] = self._client.write_coil self._call_type[CALL_TYPE_WRITE_COILS][ ENTRY_FUNC] = self._client.write_coils self._call_type[CALL_TYPE_WRITE_REGISTER][ ENTRY_FUNC] = self._client.write_register self._call_type[CALL_TYPE_WRITE_REGISTERS][ ENTRY_FUNC] = self._client.write_registers # Start counting down to allow modbus requests. if self._config_delay: self._async_cancel_listener = async_call_later( self.hass, self._config_delay, self.async_end_delay)
def __init__(self, ip): #ip should be 10.3.0.2 self.client = ModbusTcpClient(ip) self.connected = self.client.connect() self.clearFlags()
import dash from dash.dependencies import Output, Input import dash_core_components as dcc import dash_html_components as html import plotly import random import plotly.graph_objs as go from collections import deque from datetime import datetime from pymodbus.client.sync import ModbusTcpClient #CONEXION CON PLC address = 'colocar direccion IP' client = ModbusTcpClient(address) #ESTRUCTURA DE LOS EJES DEL GRAFICO #Se definen los ejes como 2 vectores de largo a definir X = deque(maxlen=20) Y = deque(maxlen=20) #Se define que en cada actualización se agregara 1 elemento a los ejes X.append(1) Y.append(1) app = dash.Dash(__name__) server = app.server #Definir layout basico app.layout = html.Div([ html.H1(children='Monitoreo de datos de PLC en tiempor real'), dcc.Graph(id='live-graph', animate=True), dcc.Interval(
def tui_main(stdscr, args): if args.host: client = ModbusTcpClient(args.host, port=args.port) else: # This prevents arduino autoreset. It does not work on the first call # because it doesn't give time to the Arduino program to # initialize. After that it is not necessary until the configuration # of the port changes again but keeping it here seems like the # cleanest and simplest solution. os.system('stty -hup -F %s' % SERIAL_PORT) client = ModbusSerialClient(method="rtu", port=SERIAL_PORT, stopbits=1, bytesize=8, parity='E', baudrate=19200, dsrdtr=False, timeout=0.01) conn = client.connect() _configure_curses(stdscr) coil_table = CoilTable() counter_table = CounterTable() analog_table = AnalogTable() ud_table = UserDataTable() tables = Circular([coil_table, analog_table, counter_table, ud_table]) _center(stdscr, tables) read_op = 0 coils = [] counters = [] analog_values = [] user_data_values = [] while True: if read_op == READ_COILS: coils = client.read_coils(0x0000, 0xd8, unit=UNIT_ID).bits elif read_op == READ_COUNTERS: counters = client.read_holding_registers(0x000a, 24, unit=UNIT_ID).registers elif read_op == READ_ANALOG: analog_values = client.read_holding_registers( 0x0000, 10, unit=UNIT_ID).registers elif read_op == READ_USER_DATA: user_data_values = client.read_holding_registers( 0x0022, 14, unit=UNIT_ID).registers read_op = (read_op + 1) % READ_OP_COUNT coil_table.set_data(coils) analog_table.set_data(analog_values) counter_table.set_data(counters) ud_table.set_data(user_data_values) stdscr.touchwin() panel.update_panels() curses.doupdate() ch = stdscr.getch() action = None if ch == -1: continue elif ch == ord('q'): return elif ch == ord('\t'): tables.current().hide_selection(True) tables.next() tables.current().hide_selection(False) elif ch == ord('h'): show_dialog(stdscr, 'Help', HELP_MSG) elif ch == curses.KEY_RESIZE: stdscr.clear() stdscr.border(0) _center(stdscr, tables) elif ch == ord('s'): action = ('write_coils', 0x0100, [1]) elif ch == ord('l'): action = ('write_coils', 0x0101, [1]) else: action = tables.current().handle_ch(ch) tl_attr = curses.A_NORMAL if action: cmd = action[0] if cmd == 'write_coils': cmd, addr, bits = action result = client.write_coils(addr, bits, unit=UNIT_ID) tl_msg = 'write_coils(0x%04x, %s, unit=0x%x) -> %s' % ( addr, bits, UNIT_ID, result) if result.function_code & 0x80: tl_attr = COLOR_WHITE_ON_RED | curses.A_BOLD read_op = READ_COILS if cmd == 'write_registers': cmd, addr, words = action result = client.write_registers(addr, words, unit=UNIT_ID) tl_msg = 'write_registers(0x%04x, %s, unit=0x%x) -> %s' % ( addr, words, UNIT_ID, result) if result.function_code & 0x80: tl_attr = COLOR_WHITE_ON_RED | curses.A_BOLD read_op = READ_COUNTERS else: tl_msg = str(action) else: tl_msg = curses.keyname(ch).decode('utf-8') stdscr.addstr(1, 1, tl_msg, tl_attr) stdscr.clrtoeol()
#!/usr/bin/env python from pymodbus.client.sync import ModbusTcpClient import struct import rospy from std_msgs.msg import String from sensor_msgs.msg import JointState from geometry_msgs.msg import Pose from ctypes import * import numpy as np # ip_address = '192.168.1.2' # port = 502 ip_address = rospy.get_param("ip_address") port = rospy.get_param("port") client = ModbusTcpClient(ip_address, port) client.connect() def euler_to_quaternion(yaw, pitch, roll): global qx, qy, qz, qw qx = np.sin(roll / 2) * np.cos(pitch / 2) * np.cos(yaw / 2) - np.cos( roll / 2) * np.sin(pitch / 2) * np.sin(yaw / 2) qy = np.cos(roll / 2) * np.sin(pitch / 2) * np.cos(yaw / 2) + np.sin( roll / 2) * np.cos(pitch / 2) * np.sin(yaw / 2) qz = np.cos(roll / 2) * np.cos(pitch / 2) * np.sin(yaw / 2) - np.sin( roll / 2) * np.sin(pitch / 2) * np.cos(yaw / 2) qw = np.cos(roll / 2) * np.cos(pitch / 2) * np.cos(yaw / 2) + np.sin( roll / 2) * np.sin(pitch / 2) * np.sin(yaw / 2) def modbus(address):
def run(self): self.client = ModbusTcpClient(self.inverter_ip, port=self.inverter_port) self.client.connect() # LONG List of reads... self.Adr0[3] = self.ReadU32(self.Adr0[0]) * 0.1 self.Adr2[3] = self.ReadU32(self.Adr2[0]) * 0.1 self.Adr4[3] = self.ReadU32(self.Adr4[0]) * 0.1 self.Adr6[3] = self.ReadU32(self.Adr6[0]) * 0.1 self.Adr16[3] = self.ReadU32(self.Adr16[0]) * 0.1 self.Adr18[3] = self.ReadU32(self.Adr18[0]) * 0.1 self.Adr24[3] = self.ReadInt32(self.Adr24[0]) * 0.001 self.Adr26[3] = self.ReadU32(self.Adr26[0]) * 0.001 self.Adr40[3] = self.ReadU32(self.Adr40[0]) * 0.1 self.Adr42[3] = self.ReadU32(self.Adr42[0]) * 0.1 self.Adr44[3] = self.ReadU32(self.Adr44[0]) * 0.1 self.Adr46[3] = self.ReadU32(self.Adr46[0]) * 0.1 self.Adr56[3] = self.ReadU32(self.Adr56[0]) * 0.1 self.Adr58[3] = self.ReadU32(self.Adr58[0]) * 0.1 self.Adr60[3] = self.ReadU32(self.Adr60[0]) * 0.001 self.Adr62[3] = self.ReadU32(self.Adr62[0]) * 0.001 self.Adr64[3] = self.ReadInt32(self.Adr64[0]) * 0.001 self.Adr80[3] = self.ReadU32(self.Adr80[0]) * 0.1 self.Adr82[3] = self.ReadU32(self.Adr82[0]) * 0.1 self.Adr84[3] = self.ReadU32(self.Adr84[0]) * 0.1 self.Adr86[3] = self.ReadU32(self.Adr86[0]) * 0.1 self.Adr96[3] = self.ReadU32(self.Adr96[0]) * 0.1 self.Adr98[3] = self.ReadU32(self.Adr98[0]) * 0.1 self.Adr100[3] = self.ReadU32(self.Adr100[0]) * 0.001 self.Adr102[3] = self.ReadU32(self.Adr102[0]) * 0.001 self.Adr104[3] = self.ReadInt32(self.Adr104[0]) * 0.001 self.Adr120[3] = self.ReadU32(self.Adr120[0]) * 0.1 self.Adr122[3] = self.ReadU32(self.Adr122[0]) * 0.1 self.Adr124[3] = self.ReadU32(self.Adr124[0]) * 0.1 self.Adr126[3] = self.ReadU32(self.Adr126[0]) * 0.1 self.Adr136[3] = self.ReadU32(self.Adr136[0]) * 0.1 self.Adr138[3] = self.ReadU32(self.Adr138[0]) * 0.1 self.Adr140[3] = self.ReadU32(self.Adr140[0]) * 0.001 self.Adr142[3] = self.ReadU32(self.Adr142[0]) * 0.001 self.Adr144[3] = self.ReadInt32(self.Adr144[0]) * 0.001 #self.Adr60[3]=self.ReadU32(self.Adr60[0])*0.001 self.Adr512[3] = self.ReadUInt64(self.Adr512[0]) * 0.1 self.Adr516[3] = self.ReadUInt64(self.Adr516[0]) * 0.1 self.Adr520[3] = self.ReadUInt64(self.Adr520[0]) * 0.1 self.Adr524[3] = self.ReadUInt64(self.Adr524[0]) * 0.1 self.Adr544[3] = self.ReadUInt64(self.Adr544[0]) * 0.1 self.Adr548[3] = self.ReadUInt64(self.Adr548[0]) * 0.1 self.Adr592[3] = self.ReadUInt64(self.Adr592[0]) * 0.1 self.Adr596[3] = self.ReadUInt64(self.Adr596[0]) * 0.1 self.Adr600[3] = self.ReadUInt64(self.Adr600[0]) * 0.1 self.Adr604[3] = self.ReadUInt64(self.Adr604[0]) * 0.1 self.Adr624[3] = self.ReadUInt64(self.Adr624[0]) * 0.1 self.Adr628[3] = self.ReadUInt64(self.Adr628[0]) * 0.1 self.Adr672[3] = self.ReadUInt64(self.Adr672[0]) * 0.1 self.Adr676[3] = self.ReadUInt64(self.Adr676[0]) * 0.1 self.Adr680[3] = self.ReadUInt64(self.Adr680[0]) * 0.1 self.Adr684[3] = self.ReadUInt64(self.Adr684[0]) * 0.1 self.Adr704[3] = self.ReadUInt64(self.Adr704[0]) * 0.1 self.Adr708[3] = self.ReadUInt64(self.Adr708[0]) * 0.1 self.Adr752[3] = self.ReadUInt64(self.Adr752[0]) * 0.1 self.Adr756[3] = self.ReadUInt64(self.Adr756[0]) * 0.1 self.Adr760[3] = self.ReadUInt64(self.Adr760[0]) * 0.1 self.Adr764[3] = self.ReadUInt64(self.Adr764[0]) * 0.1 self.Adr784[3] = self.ReadUInt64(self.Adr784[0]) * 0.1 self.Adr788[3] = self.ReadUInt64(self.Adr788[0]) * 0.1 self.Adr8192[3] = self.ReadU16_1(self.Adr8192[0]) self.KostalRegister = [] self.KostalRegister.append(self.Adr0) self.KostalRegister.append(self.Adr2) self.KostalRegister.append(self.Adr4) self.KostalRegister.append(self.Adr6) self.KostalRegister.append(self.Adr16) self.KostalRegister.append(self.Adr18) self.KostalRegister.append(self.Adr24) self.KostalRegister.append(self.Adr26) self.KostalRegister.append(self.Adr40) self.KostalRegister.append(self.Adr42) self.KostalRegister.append(self.Adr44) self.KostalRegister.append(self.Adr46) self.KostalRegister.append(self.Adr56) self.KostalRegister.append(self.Adr58) self.KostalRegister.append(self.Adr60) self.KostalRegister.append(self.Adr62) self.KostalRegister.append(self.Adr64) self.KostalRegister.append(self.Adr80) self.KostalRegister.append(self.Adr82) self.KostalRegister.append(self.Adr84) self.KostalRegister.append(self.Adr86) self.KostalRegister.append(self.Adr96) self.KostalRegister.append(self.Adr98) self.KostalRegister.append(self.Adr100) self.KostalRegister.append(self.Adr102) self.KostalRegister.append(self.Adr104) self.KostalRegister.append(self.Adr120) self.KostalRegister.append(self.Adr122) self.KostalRegister.append(self.Adr124) self.KostalRegister.append(self.Adr126) self.KostalRegister.append(self.Adr136) self.KostalRegister.append(self.Adr138) self.KostalRegister.append(self.Adr140) self.KostalRegister.append(self.Adr142) self.KostalRegister.append(self.Adr144) #self.KostalRegister.append(self.Adr60) self.KostalRegister.append(self.Adr512) self.KostalRegister.append(self.Adr516) self.KostalRegister.append(self.Adr520) self.KostalRegister.append(self.Adr524) self.KostalRegister.append(self.Adr544) self.KostalRegister.append(self.Adr548) self.KostalRegister.append(self.Adr592) self.KostalRegister.append(self.Adr596) self.KostalRegister.append(self.Adr600) self.KostalRegister.append(self.Adr604) self.KostalRegister.append(self.Adr624) self.KostalRegister.append(self.Adr628) self.KostalRegister.append(self.Adr672) self.KostalRegister.append(self.Adr676) self.KostalRegister.append(self.Adr680) self.KostalRegister.append(self.Adr684) self.KostalRegister.append(self.Adr704) self.KostalRegister.append(self.Adr708) self.KostalRegister.append(self.Adr752) self.KostalRegister.append(self.Adr756) self.KostalRegister.append(self.Adr760) self.KostalRegister.append(self.Adr764) self.KostalRegister.append(self.Adr784) self.KostalRegister.append(self.Adr788) self.KostalRegister.append(self.Adr8192) self.client.close()
def connect(self): # if self.master and not self.master.socket: # self.master = None if self.master is None: self.commError = False try: # as in the following the port is None, no port is opened on creation of the (py)serial object if self.type == 1: # Serial ASCII from pymodbus.client.sync import ModbusSerialClient self.master = ModbusSerialClient(method='ascii', port=self.comport, baudrate=self.baudrate, bytesize=self.bytesize, parity=self.parity, stopbits=self.stopbits, retry_on_empty=True, timeout=self.timeout) elif self.type == 2: # Serial Binary from pymodbus.client.sync import ModbusSerialClient # @Reimport self.master = ModbusSerialClient(method='binary', port=self.comport, baudrate=self.baudrate, bytesize=self.bytesize, parity=self.parity, stopbits=self.stopbits, retry_on_empty=True, timeout=self.timeout) elif self.type == 3: # TCP from pymodbus.client.sync import ModbusTcpClient try: self.master = ModbusTcpClient( host=self.host, port=self.port, retry_on_empty=True, retries=1, timeout=0.9, #self.timeout ) self.readRetries = 0 except: self.master = ModbusTcpClient( host=self.host, port=self.port, ) elif self.type == 4: # UDP from pymodbus.client.sync import ModbusUdpClient try: self.master = ModbusUdpClient( host=self.host, port=self.port, retry_on_empty=True, retries=3, timeout=0.7, #self.timeout ) except: # older versions of pymodbus don't support the retries, timeout nor the retry_on_empty arguments self.master = ModbusUdpClient( host=self.host, port=self.port, ) else: # Serial RTU from pymodbus.client.sync import ModbusSerialClient # @Reimport self.master = ModbusSerialClient( method='rtu', port=self.comport, baudrate=self.baudrate, bytesize=self.bytesize, parity=self.parity, stopbits=self.stopbits, retry_on_empty=False, strict= False, # settings this to False disables the inter char timeout restriction timeout=self.timeout) # self.master.inter_char_timeout = 0.05 self.readRetries = 1 self.master.connect() self.updateActiveRegisters() time.sleep(.5) # avoid possible hickups on startup if self.isConnected() != None: self.aw.sendmessage( QApplication.translate("Message", "Connected via MODBUS", None)) except Exception as ex: _, _, exc_tb = sys.exc_info() self.aw.qmc.adderror((QApplication.translate( "Error Message", "Modbus Error:", None) + " connect() {0}").format(str(ex)), exc_tb.tb_lineno)
'frec1': 100, 'frect': 100, 'pac1': 1000, 'preac1': 1000, 'pap1': 1000, 'fp1': 100, 'eac1': 100, 'ereacind1': 100, 'ereaccap1': 100 } # Consulta monitores modelo for monitor in monitores_energia: try: client = ModbusTcpClient(monitores_energia[monitor]['ip'], port=502, timeout=10) client.connect() log.debug("Reading Registers") for medida, registro in modbus_registers.items(): read = client.read_holding_registers(registro, modbus_len[medida]) if modbus_len[medida] == 2: dato = struct.pack("<H", read.registers[0]) #primer registro dato2 = struct.pack("<H", read.registers[1]) #segundo registro valor = struct.unpack( "<i", dato + dato2) #al estar en little endian van en el orden #print(valor[0]) monitores_energia[monitor][ medida] = valor[0] / modbus_multiplicador[medida] else:
def __init__(self, ip='192.168.56.1'): self.ip = ip self.client = ModbusTcpClient(self.ip, 502) self.connection = self.client.connect()
def __init__(self, host: str, port: int = 502): super().__init__() self._client = ModbusTcpClient(host, port)
def Roraima_communications(): FORMAT = ('%(asctime)-15s %(threadName)-15s ' '%(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s') logging.basicConfig(filename='Roraima_Log.txt', filemode='w',format=FORMAT) log=logging.getLogger() log.setLevel(logging.DEBUG) for p in serial.tools.list_ports.comports(): try: if 'Arduino' in p.manufacturer: arduino_ports = p.device logging.info("Puerto Serie Arduino:"+str(p.device)) break except: break time.sleep(2) logging.info("Info Puerto Serie Arduino:"+str(p.device)) while True: arduino = serial.Serial(arduino_ports,9600, timeout=5) t0=time.time() comando = datetime.now().strftime("%d%b,%H:%M:%S+") comando+='\n' error_AN=0 try: a=arduino.write(comando.encode()) lectura = arduino.readline() txt=str(lectura) txt=txt[2:-5] analogico=txt.split("|") except: logging.error("No se puede contectar a Tarjeta ARDUINO") analogico=[] analogico.append(0) analogico.append(0) analogico.append(0) analogico.append(0) analogico.append(0) analogico.append(0) error_AN=1 error_bd=0 try: connection=mysql.connector.connect (host='localhost',database='MAIN_SENSOR',user='******',password='******') cursor=connection.cursor() cursor.execute("SELECT DB_SENSOR FROM MAIN WHERE 1") LISTA_SENSORES=cursor.fetchall() except: logging.error("No se puede contectar a base de datos Main Sensor de este dispositivo") error_bd=1 i=0 if error_bd==0: for SENSOR in LISTA_SENSORES[:][0]: error_general=0 cursor.execute("SELECT * FROM "+ SENSOR +"_CONF WHERE 1") CONF = cursor.fetchall() CANT_DIR=len(CONF) TAGS=[T[1] for T in CONF] RANG_MIN=[T[4] for T in CONF] RANG_MAX=[T[5] for T in CONF] PROTOCOLO=[T[6] for T in CONF] DIRECCION=[T[7] for T in CONF] PARAM_COMM1=[T[8] for T in CONF] PARAM_COMM2=[T[9] for T in CONF] PARAM_COMM3=[T[10] for T in CONF] PARAM_COMM4=[T[11] for T in CONF] PARAM_COMM5=[T[12] for T in CONF] PARAM_COMM6=[T[13] for T in CONF] result=[]; for j in range(len(TAGS)): if PROTOCOLO[j]=="MTCP": client = ModbusTcpClient(DIRECCION[j],port=int(PARAM_COMM3[j])) cnx_modbus=client.connect() if cnx_modbus== True: X_1=int(PARAM_COMM5[j])-40001 rr=0 try: rr = client.read_holding_registers(X_1,1,unit=int(PARAM_COMM4[j])) result.append(rr.registers[0]) except: logging.exception("No se puede leer registros: " + SENSOR + ":" + TAGS[j]) error_general=1 result.append(0) else: logging.exception("No se puede conectar: " + SENSOR + ":" + TAGS[j]) error_general=1 result.append(0) if PROTOCOLO[j]=="ANA": canaltxt=DIRECCION[j] canal=int(canaltxt) try: if float(analogico[canal])>(1024/5): rANA=(float(analogico[canal])-(1024/5))/(1024-(1024/5)) rMed=rANA*(float(RANG_MAX[j])-float(RANG_MIN[j]))+float(RANG_MIN[j]) result.append(rMed) else: result.append(0) logging.error("Error en sensor Analogico : " + SENSOR +":"+TAGS[j]+":"+DIRECCION[j]) except: result.append(0) logging.error("Error en sensor Analogico : " + SENSOR +":"+TAGS[j]+":"+DIRECCION[j]) fecha=datetime.now().strftime('%Y-%m-%d %H:%M:%S') cursor.execute("SELECT COUNT(*) FROM "+ SENSOR +"_MEASURE") conteo=cursor.fetchone() LAST_ID=1 if conteo[0] !=0: cursor.execute("SELECT ID FROM "+ SENSOR +"_MEASURE ORDER BY ID DESC LIMIT 1") LID=cursor.fetchone() LAST_ID=LID[0]+1 Q1="INSERT INTO `"+ SENSOR + "_MEASURE` (`ID`, `FECHA_HORA`" Q2= ") VALUES ('"+ str(LAST_ID) + "','" + str(fecha)+"'" for j in range(len(TAGS)): Q1=Q1+ ",`" + TAGS[j]+"`" Q2=Q2+ ",'" + str(result[j])+"'" Query=Q1+Q2+")" cursor.execute(Query) connection.commit() logging.info("Se actualizo: "+ SENSOR + ","+ str(len(TAGS)) + " TAGS") connection.close() t1=time.time() while((t1-t0)<60): t1=time.time() comando = datetime.now().strftime("%d%b,%H:%M:%S+") comando+='\n' try: a=arduino.write(comando.encode()) except: logging.error("No se puede contectar a Tarjeta ARDUINO")
#!/usr/bin/env python3 from time import sleep from pymodbus.payload import BinaryPayloadDecoder from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient('127.0.0.1', port=5020) client.connect() while True: co = client.read_coils(address=0x100, count=8) hr = client.read_holding_registers(address=0x200, count=1) decoder = BinaryPayloadDecoder.fromRegisters(hr.registers) temperature = decoder.decode_8bit_int() heater = co.bits[0] cooler = co.bits[1] print("heater: {} | cooler: {} | temperature: {}".format( heater, cooler, temperature), end=' \r') if heater: temperature += 1 client.write_register(0x200, (temperature) * 256) elif cooler: temperature -= 1 client.write_register(0x200, (temperature) * 256) if temperature < 70: client.write_coil(0x100, True)
#!/usr/bin/python3 import sys from pymodbus.client.sync import ModbusTcpClient lla = int(sys.argv[1]) client = ModbusTcpClient('192.168.193.26', port=8899) rq = client.write_registers(1000, lla, unit=1)
def __configure_master(self, config=None): current_config = self.__config if config is None else config host = current_config['host'] if current_config.get( "host") is not None else self.__config.get("host", "localhost") try: port = int(current_config['port']) if current_config.get( "port") is not None else self.__config.get(int("port"), 502) except ValueError: port = current_config['port'] if current_config.get( "port") is not None else self.__config.get("port", 502) baudrate = current_config['baudrate'] if current_config.get( 'baudrate') is not None else self.__config.get('baudrate', 19200) timeout = current_config['timeout'] if current_config.get( "timeout") is not None else self.__config.get("timeout", 35) method = current_config['method'] if current_config.get( 'method') is not None else self.__config.get('method', 'rtu') stopbits = current_config['stopbits'] if current_config.get( 'stopbits') is not None else self.__config.get( 'stopbits', Defaults.Stopbits) bytesize = current_config['bytesize'] if current_config.get( 'bytesize') is not None else self.__config.get( 'bytesize', Defaults.Bytesize) parity = current_config['parity'] if current_config.get( 'parity') is not None else self.__config.get( 'parity', Defaults.Parity) strict = current_config["strict"] if current_config.get( "strict") is not None else self.__config.get("strict", True) rtu = ModbusRtuFramer if current_config.get("method") == "rtu" or ( current_config.get("method") is None and self.__config.get("method") == "rtu") else ModbusSocketFramer if current_config.get('type') == 'tcp' or ( current_config.get("type") is None and self.__config.get("type") == "tcp"): master = ModbusTcpClient(host, port, rtu, timeout=timeout) elif current_config.get('type') == 'udp' or ( current_config.get("type") is None and self.__config.get("type") == "udp"): master = ModbusUdpClient(host, port, rtu, timeout=timeout) elif current_config.get('type') == 'serial' or ( current_config.get("type") is None and self.__config.get("type") == "serial"): master = ModbusSerialClient(method=method, port=port, timeout=timeout, baudrate=baudrate, stopbits=stopbits, bytesize=bytesize, parity=parity, strict=strict) else: raise Exception("Invalid Modbus transport type.") available_functions = { 1: master.read_coils, 2: master.read_discrete_inputs, 3: master.read_holding_registers, 4: master.read_input_registers, 5: master.write_coil, 6: master.write_register, 15: master.write_coils, 16: master.write_registers, } return master, available_functions
#!/usr/bin/python import sys # import os # import time # import getopt # import socket # import ConfigParser import struct # import binascii from pymodbus.client.sync import ModbusTcpClient ipadd = str(sys.argv[1]) idadd = int(sys.argv[2]) client = ModbusTcpClient(ipadd, port=8899) if (idadd < 100): #resp = client.read_input_registers(0x0002,2, unit=idadd) #ikwh = resp.registers[1] resp = client.read_input_registers(0x0002, 4, unit=idadd) value1 = resp.registers[0] value2 = resp.registers[1] all = format(value1, '04x') + format(value2, '04x') ikwh = int(struct.unpack('>i', all.decode('hex'))[0]) ikwh = float(ikwh) / 100 f = open('/var/www/html/openWB/ramdisk/llkwhlp7', 'w') f.write(str(ikwh)) f.close() resp = client.read_input_registers(0x0E, 2, unit=idadd) lla1 = resp.registers[1]
#!/usr/bin/python #MTU Server from config import * from pymodbus.client.sync import ModbusTcpClient import time import numpy as np import logging from sklearn.decomposition import PCA import matplotlib.pyplot as plt import matplotlib.animation as anim logging.basicConfig() log = logging.getLogger() log.setLevel(logging.INFO) opc1_client = ModbusTcpClient(OPC1_IP, OPC1_PORT) opc1_client.connect() opc2_client = ModbusTcpClient(OPC2_IP, OPC2_PORT) opc2_client.connect() i = 0 fig = plt.figure() ax = fig.add_subplot(1, 1, 1) y = [] def update(i): #Read registers from the specific zone l1 = float(opc1_client.read_holding_registers(L1, 1).registers[0]) l2 = float(opc2_client.read_holding_registers(L2, 1).registers[0]) t1 = float(opc1_client.read_holding_registers(T1, 1).registers[0])
def times(): sleep(0.25) a = 1 contpacket = 0 while a: #function_code = raw_input('>') for function_code in ['01', '02', '03', '04', '05', '06', '0f', '10']: #for function_code in ['0f']: #------------------------------------------------------------------------ if function_code == '01': clientTCP = ModbusTcpClient(AddrTCP) connection = clientTCP.connect() #print(clientTCP.timeout) if connection == True: times() print( '--------------------------------------------------FC01---------------------------------------------------------- ' ) Request = clientTCP.read_coils(0x0013, 0x0025, unit=0x11) resp = reversePacket('FC01', Request) print('') print( '*********************************************************' ) print('Resultado comparado com Modbus RTU:') print(PacketCompare('FC01', sglobal, resp))
def testSyncTcpClientInstantiation(self): client = ModbusTcpClient() self.assertNotEqual(client, None)
#!/usr/bin/env python import sys import rospy import time from tm_motion.srv import * import actionlib from tm_motion.msg import ActionAction, ActionGoal from pymodbus.client.sync import ModbusTcpClient host = '192.168.1.2' port_modbus = 502 client = ModbusTcpClient(host, port_modbus) client.connect() def start_program(): print "starting program" status = client.write_coil(7104, True, unit=1) print(status) time.sleep(5) def stop_program(): print "stopping program" status = client.write_coil(7105, True, unit=1) print(status) time.sleep(2) def grip(): print "griping object" #go into gipper function
#!/usr/bin/python from pymodbus.client.sync import ModbusTcpClient import sys import os import time import argparse parser = argparse.ArgumentParser() parser.add_argument("a", "address", type=str, help="ip address") parser.add_argument("i", "id", type=int, help="modbus id") parser.add_argument("p", "phases", type=int, choices=[1, 3], help="phases to activate") parser.add_argument("-d", "--duration", type=int, default=1, help="duration in seconds, defaults to 1") parser.add_argument("-v", "--verbose", action="store_true", help="verbose debug output") args = parser.parse_args() if(args.verbose): print("Wartezeit vor und nach %dp Umschaltung %s #%d: %ds"%(args.phases, args.address, args.id, args.duration)) client = ModbusTcpClient(args.address, port=8899) if ( args.phases == 1 ): rq = client.write_register(0x0001, 256, unit=args.id) time.sleep(args.duration) rq = client.write_register(0x0001, 512, unit=args.id) elif ( args.phases == 3 ): rq = client.write_register(0x0002, 256, unit=args.id) time.sleep(args.duration) rq = client.write_register(0x0002, 512, unit=args.id)
import logging def listToString(s): str1 = '' for ele in s: str1 += chr(ele) return str1 logging.basicConfig() log = logging.getLogger() #log.setLevel(logging.DEBUG) client = ModbusTcpClient('192.168.0.200') client.connect() #result=client.read_holding_registers(1134,2,unit=1) #result=client.read_input_registers(1134,2,unit=0x01) #result=client.register_write_message.WriteSingleregisterRequest(1134,500,unit=0x01) result = client.read_holding_registers(1134, 2, unit=0x01) #result=client.read_holding_registers(1132,2,unit=0x01) #print(result.registers) #response=client.execute(result) #print(result.registers) #result=client.write_register(1132,False,unit=0x01) #result=client.read_coils(1134,2,unit=0x01) print(result.registers) #result=client.read_holding_registers(1134,2,unit=1) #print(result.registers)
#!/usr/bin/python import sys import os import time import getopt import socket import ConfigParser import struct import binascii ipaddress = str(sys.argv[1]) slave1id = int(sys.argv[2]) slave2id = int(sys.argv[3]) from pymodbus.client.sync import ModbusTcpClient client = ModbusTcpClient(ipaddress, port=502) #wr1 resp = client.read_holding_registers(40084, 2, unit=slave1id) multipli = resp.registers[0] multiplint = format(multipli, '04x') fmultiplint = int(struct.unpack('>h', multiplint.decode('hex'))[0]) respw = client.read_holding_registers(40083, 2, unit=slave1id) value1w = respw.registers[0] allw = format(value1w, '04x') rawprodw = finalw = int(struct.unpack('>h', allw.decode('hex'))[0]) * -1 if fmultiplint == 0: rawprodw = 0 if fmultiplint == -1: rawprodw = rawprodw / 10 if fmultiplint == -2: rawprodw = rawprodw / 100
def __init__(self, host: str, port: int = 502, timeout: int = 3): self.client = ModbusTcpClient(host=host, port=port, timeout=timeout)