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)
