def testUdpClientConnect(self):
''' Test the Udp client connection method'''
with patch.object(socket, 'socket') as mock_method:
mock_method.return_value = object()
client = ModbusUdpClient()
self.assertTrue(client.connect())
with patch.object(socket, 'socket') as mock_method:
mock_method.side_effect = socket.error()
client = ModbusUdpClient()
self.assertFalse(client.connect())
def testUdpClientConnect(self):
''' Test the Udp client connection method'''
with patch.object(socket, 'socket') as mock_method:
class DummySocket(object):
def settimeout(self, *a, **kwa):
pass
mock_method.return_value = DummySocket()
client = ModbusUdpClient()
self.assertTrue(client.connect())
with patch.object(socket, 'socket') as mock_method:
mock_method.side_effect = socket.error()
client = ModbusUdpClient()
self.assertFalse(client.connect())
def __configure_master(self):
host = self.__config.get("host", "localhost")
port = self.__config.get("port", 502)
baudrate = self.__config.get('baudrate', 19200)
timeout = self.__config.get("timeout", 35)
method = self.__config.get('method', 'rtu')
rtu = ModbusRtuFramer if self.__config.get(
"method") == "rtu" else ModbusSocketFramer
if self.__config.get('type') == 'tcp':
self.__master = ModbusTcpClient(host, port, rtu, timeout=timeout)
elif self.__config.get('type') == 'udp':
self.__master = ModbusUdpClient(host, port, rtu, timeout=timeout)
elif self.__config.get('type') == 'serial':
self.__master = ModbusSerialClient(method=method,
port=port,
timeout=timeout,
baudrate=baudrate)
else:
raise Exception("Invalid Modbus transport type.")
self.__available_functions = {
1: self.__master.read_coils,
2: self.__master.read_discrete_inputs,
3: self.__master.read_holding_registers,
4: self.__master.read_input_registers,
5: self.__master.write_coils,
6: self.__master.write_registers,
15: self.__master.write_coils,
16: self.__master.write_registers,
}
def setup_client(client_config):
"""Set up pymodbus client."""
client_type = client_config[CONF_TYPE]
if client_type == "serial":
return ModbusSerialClient(
method=client_config[CONF_METHOD],
port=client_config[CONF_PORT],
baudrate=client_config[CONF_BAUDRATE],
stopbits=client_config[CONF_STOPBITS],
bytesize=client_config[CONF_BYTESIZE],
parity=client_config[CONF_PARITY],
timeout=client_config[CONF_TIMEOUT],
)
if client_type == "rtuovertcp":
return ModbusTcpClient(
host=client_config[CONF_HOST],
port=client_config[CONF_PORT],
framer=ModbusRtuFramer,
timeout=client_config[CONF_TIMEOUT],
)
if client_type == "tcp":
return ModbusTcpClient(
host=client_config[CONF_HOST],
port=client_config[CONF_PORT],
timeout=client_config[CONF_TIMEOUT],
)
if client_type == "udp":
return ModbusUdpClient(
host=client_config[CONF_HOST],
port=client_config[CONF_PORT],
timeout=client_config[CONF_TIMEOUT],
)
assert False
def do_connect(self, input_text, output_text, event):
"""Connect to tcp:10.10.10.1[:502] or rtu:/dev/serial or ascii:/dev/serial."""
parts = input_text.split()
if len(parts) == 1:
target = dict()
encoded_target = parts[0]
if encoded_target.count(':') > 0:
encoded_target = encoded_target.split(':')
proto = encoded_target[0].lower()
ip_dev = encoded_target[1]
#TODO verify IP or DEV file and separate variables
if len(encoded_target) == 3:
port = encoded_target[2]
else:
port = 502
if proto == 'tcp':
event.app.session = ModbusTcpClient(ip_dev, port)
elif proto == 'udp':
event.app.session = ModbusUdpClient(ip_dev, port)
elif proto == 'rtu':
event.app.session = ModbusSerialClient(method='rtu',
port=ip_dev,
timeout=1)
elif proto == 'ascii':
event.app.session = ModbusSerialClient(method='ascii',
port=ip_dev,
timeout=1)
# initiate a modbus session and return success message
output_text += 'Connect session opened with {}\n'.format(parts[0])
return output_text
# Return False to force users to fix broken target
return False
def _connect(self):
"""
connect to the modbus slave (server)
"""
framer = None
if self._framer == 0: # Socket Framer
framer = ModbusSocketFramer
elif self._framer == 1: # RTU Framer
framer = ModbusRtuFramer
elif self._framer == 2: # ASCII Framer
framer = ModbusAsciiFramer
elif self._framer == 3: # Binary Framer
framer = ModbusBinaryFramer
if self._protocol == 0: # TCP
if self._framer is None: # No Framer
self.slave = ModbusTcpClient(self._address,
int(self._port),
timeout=self._timeout)
else:
self.slave = ModbusTcpClient(self._address,
int(self._port),
timeout=self._timeout,
framer=framer)
elif self._protocol == 1: # UDP
if self._framer is None: # No Framer
self.slave = ModbusUdpClient(self._address,
int(self._port),
timeout=self._timeout)
else:
self.slave = ModbusUdpClient(self._address,
int(self._port),
timeout=self._timeout,
framer=framer)
elif self._protocol in (2, 3, 4): # serial
method_list = {2: 'ascii', 3: 'rtu', 4: 'binary'}
self.slave = ModbusSerialClient(method=method_list[self._protocol],
port=self._port,
stopbits=self._stopbits,
bytesize=self._bytesize,
parity=self._parity,
baudrate=self._baudrate,
timeout=self._timeout)
else:
raise NotImplementedError("Protocol not supported")
status = self.slave.connect()
return status
def testUdpClientSend(self):
''' Test the udp client send method'''
client = ModbusUdpClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(4, client._send('1234'))
def testUdpClientRecv(self):
''' Test the udp client receive method'''
client = ModbusUdpClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual('', client._recv(0))
self.assertEqual('\x00' * 4, client._recv(4))
def do_connect_udp(self, args, output_text):
"""Connect to a Modbus UDP device"""
assert (self.session == None), 'Session already open. Close first.' # ToDo assert session type
host, port = self.parse_ip_port(args)
self.session = ModbusUdpClient(host, port)
message_dialog(
title = 'Success',
text = 'Session opened with {}:{}'.format(host, port) )
def __configure_master(config):
current_config = config
current_config["rtu"] = FRAMER_TYPE[current_config['method']]
if current_config.get('type') == 'tcp':
master = ModbusTcpClient(
current_config["host"],
current_config["port"],
current_config["rtu"],
timeout=current_config["timeout"],
retry_on_empty=current_config["retry_on_empty"],
retry_on_invalid=current_config["retry_on_invalid"],
retries=current_config["retries"])
elif current_config.get(TYPE_PARAMETER) == 'udp':
master = ModbusUdpClient(
current_config["host"],
current_config["port"],
current_config["rtu"],
timeout=current_config["timeout"],
retry_on_empty=current_config["retry_on_empty"],
retry_on_invalid=current_config["retry_on_invalid"],
retries=current_config["retries"])
elif current_config.get(TYPE_PARAMETER) == 'serial':
master = ModbusSerialClient(
method=current_config["method"],
port=current_config["port"],
timeout=current_config["timeout"],
retry_on_empty=current_config["retry_on_empty"],
retry_on_invalid=current_config["retry_on_invalid"],
retries=current_config["retries"],
baudrate=current_config["baudrate"],
stopbits=current_config["stopbits"],
bytesize=current_config["bytesize"],
parity=current_config["parity"],
strict=current_config["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
def do_connect_udp(host_port: str):
"""
Connect to a Modbus UDP device
:PARAM: host_port: <IP/HOSTNAME>[:<PORT>]
"""
assert (
ctmodbus.session == None
), "Session already open. Close first." # ToDo assert session type
host, port = common.parse_ip_port(host_port)
s = ModbusUdpClient(host, port, timeout=3)
assert s.connect(), f"Could not connect to {host}:{port}"
ctmodbus.session = s
date, time = str(datetime.today()).split()
return (ctmodbus.output_text +
f"UDP session OPENED with {host}:{port} at {date} {time}\n")
def __init__(self, protocol, host, port, slave):
self._lock = threading.Lock()
self._slave = slave
if (protocol == "rtuovertcp"):
self._client = ModbusTcpClient(host=host,
port=port,
framer=ModbusRtuFramer,
timeout=2,
retry_on_empty=True,
retry_on_invalid=False)
elif (protocol == "rtuoverudp"):
self._client = ModbusUdpClient(host=host,
port=port,
framer=ModbusRtuFramer,
timeout=2,
retry_on_empty=False,
retry_on_invalid=False)
def setup(self):
"""Set up pymodbus client."""
if self._config_type == "serial":
from pymodbus.client.sync import ModbusSerialClient
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,
)
elif self._config_type == "rtuovertcp":
from pymodbus.client.sync import ModbusTcpClient
from pymodbus.transaction import ModbusRtuFramer
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
framer=ModbusRtuFramer,
timeout=self._config_timeout,
)
elif self._config_type == "tcp":
from pymodbus.client.sync import ModbusTcpClient
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
elif self._config_type == "udp":
from pymodbus.client.sync import ModbusUdpClient
self._client = ModbusUdpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
else:
raise ValueError(("Unsupported config_type, must be serial, " +
"tcp, udp, rtuovertcp"))
# Connect device
self.connect()
def testBasicSyncUdpClient(self):
''' Test the basic methods for the udp sync client'''
# receive/send
client = ModbusUdpClient()
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(1, client._send('\x00'))
self.assertEqual('\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual("127.0.0.1:502", str(client))
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
def _connect(self):
"""
connect to the modbus slave (server)
"""
if self._protocol == 0: # TCP
self.slave = ModbusTcpClient(self._address, int(self._port))
elif self._protocol == 1: # UDP
self.slave = ModbusUdpClient(self._address, int(self._port))
elif self._protocol in (2, 3, 4): # serial
method_list = {2: 'ascii', 3: 'rtu', 4: 'binary'}
self.slave = ModbusSerialClient(method=method_list[self._protocol],
port=self._port,
stopbits=self._stopbits,
bytesize=self._bytesize,
parity=self._parity,
baudrate=self._baudrate,
timeout=self._timeout)
else:
raise NotImplementedError("Protocol not supported")
status = self.slave.connect()
return status
def __configure_master(self):
host = self.__config.get("host", "localhost")
try:
port = self.__config.get(int("port"), 502)
except ValueError:
port = self.__config.get("port", 502)
baudrate = self.__config.get('baudrate', 19200)
timeout = self.__config.get("timeout", 35)
method = self.__config.get('method', 'rtu')
stopbits = self.__config.get('stopbits', Defaults.Stopbits)
bytesize = self.__config.get('bytesize', Defaults.Bytesize)
parity = self.__config.get('parity', Defaults.Parity)
strict = self.__config.get("strict", True)
rtu = ModbusRtuFramer if self.__config.get(
"method") == "rtu" else ModbusSocketFramer
if self.__config.get('type') == 'tcp':
self.__master = ModbusTcpClient(host, port, rtu, timeout=timeout)
elif self.__config.get('type') == 'udp':
self.__master = ModbusUdpClient(host, port, rtu, timeout=timeout)
elif self.__config.get('type') == 'serial':
self.__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.")
self.__available_functions = {
1: self.__master.read_coils,
2: self.__master.read_discrete_inputs,
3: self.__master.read_holding_registers,
4: self.__master.read_input_registers,
5: self.__master.write_coil,
6: self.__master.write_register,
15: self.__master.write_coils,
16: self.__master.write_registers,
}
def 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,
)
elif self._config_type == "rtuovertcp":
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
framer=ModbusRtuFramer,
timeout=self._config_timeout,
)
elif self._config_type == "tcp":
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
elif self._config_type == "udp":
self._client = ModbusUdpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
except ModbusException as exception_error:
self._log_error(exception_error, error_state=False)
return
# Connect device
self.connect()
def setup(self):
"""Set up pymodbus client."""
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,
)
elif self._config_type == "rtuovertcp":
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
framer=ModbusRtuFramer,
timeout=self._config_timeout,
)
elif self._config_type == "tcp":
self._client = ModbusTcpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
elif self._config_type == "udp":
self._client = ModbusUdpClient(
host=self._config_host,
port=self._config_port,
timeout=self._config_timeout,
)
else:
assert False
# Connect device
self.connect()
import paho.mqtt.client as mqtt
from functools import partial
import logging
import threading
import queue
import time
import config
import entity
logger = logging.getLogger('gateway')
logger.setLevel(logging.DEBUG)
# MODBUS
modbus_udp_client = ModbusUdpClient(config.MODBUS_SERVER_HOST, timeout=3)
modbus_tcp_client = ModbusTcpClient(config.MODBUS_SERVER_HOST)
# MQTT
mqtt_client = mqtt.Client(config.MQTT_CLIENT_NAME)
mqtt_client.username_pw_set(username=config.MQTT_USER,
password=config.MQTT_PASSWORD)
# last will
mqtt_client.will_set(config.MQTT_AVAILABILITY_TOPIC, "offline", retain=True)
# connect, loop_start will handle reconnections
mqtt_client.connect(config.MQTT_HOST)
mqtt_client.loop_start()
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.sendmessage(
QApplication.translate("Message",
"Connected via MODBUS", None))
except Exception as ex:
_, _, exc_tb = sys.exc_info()
self.adderror(
(QApplication.translate("Error Message", "Modbus Error:",
None) + " connect() {0}").format(
str(ex)), exc_tb.tb_lineno)
def mqtt_on_connect(client, userdata, flags, rc):
if rc == 0 and client.is_connected == False:
# birth message
mqtt_client.publish(MQTT_AVAILABILITY_TOPIC, "online", retain=True)
# set flag
client.is_connected = True
def mqtt_on_disconnect(client, userdata, rc):
client.is_connected = False
# initialize mqtt client
modbus_client = ModbusUdpClient(MODBUS_SERVER_HOST)
mqtt_client = mqtt.Client(MQTT_CLIENT_NAME)
mqtt_client.is_connected = False
mqtt_client.on_connect = mqtt_on_connect
mqtt_client.on_disconnect = mqtt_on_disconnect
mqtt_client.username_pw_set(username="******",
password="******")
# last will
mqtt_client.will_set(MQTT_AVAILABILITY_TOPIC, "offline", retain=True)
# connect
mqtt_client.connect(MQTT_SERVER_HOST)
mqtt_client.loop_start()
# mqtt related
def testUdpClientIsSocketOpen(self):
''' Test the udp client is_socket_open method'''
client = ModbusUdpClient()
self.assertTrue(client.is_socket_open())
def testSyncUdpClientInstantiation(self):
client = ModbusUdpClient()
self.assertNotEqual(client, None)
def __configure_master(self, config=None):
current_config = self.__config if config is None else config
host = current_config[HOST_PARAMETER] if current_config.get(
HOST_PARAMETER) is not None else self.__config.get(
HOST_PARAMETER, "localhost")
try:
port = int(current_config[PORT_PARAMETER]) if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
int(PORT_PARAMETER), 502)
except ValueError:
port = current_config[PORT_PARAMETER] if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
PORT_PARAMETER, 502)
baudrate = current_config[BAUDRATE_PARAMETER] if current_config.get(
BAUDRATE_PARAMETER) is not None else self.__config.get(
BAUDRATE_PARAMETER, 19200)
timeout = current_config[TIMEOUT_PARAMETER] if current_config.get(
TIMEOUT_PARAMETER) is not None else self.__config.get(
TIMEOUT_PARAMETER, 35)
method = current_config[METHOD_PARAMETER] if current_config.get(
METHOD_PARAMETER) is not None else self.__config.get(
METHOD_PARAMETER, "rtu")
stopbits = current_config[STOPBITS_PARAMETER] if current_config.get(
STOPBITS_PARAMETER) is not None else self.__config.get(
STOPBITS_PARAMETER, Defaults.Stopbits)
bytesize = current_config[BYTESIZE_PARAMETER] if current_config.get(
BYTESIZE_PARAMETER) is not None else self.__config.get(
BYTESIZE_PARAMETER, Defaults.Bytesize)
parity = current_config[PARITY_PARAMETER] if current_config.get(
PARITY_PARAMETER) is not None else self.__config.get(
PARITY_PARAMETER, Defaults.Parity)
strict = current_config[STRICT_PARAMETER] if current_config.get(
STRICT_PARAMETER) is not None else self.__config.get(
STRICT_PARAMETER, True)
rtu = ModbusRtuFramer if current_config.get(
METHOD_PARAMETER) == "rtu" or (
current_config.get(METHOD_PARAMETER) is None
and self.__config.get(METHOD_PARAMETER)
== "rtu") else ModbusSocketFramer
if current_config.get(TYPE_PARAMETER) == 'tcp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "tcp"):
master = ModbusTcpClient(host, port, rtu, timeout=timeout)
elif current_config.get(TYPE_PARAMETER) == 'udp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "udp"):
master = ModbusUdpClient(host, port, rtu, timeout=timeout)
elif current_config.get(TYPE_PARAMETER) == 'serial' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "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
def __configure_master(self, config=None):
current_config = self.__config if config is None else config
master_config = dict()
master_config[
"host"] = current_config[HOST_PARAMETER] if current_config.get(
HOST_PARAMETER) is not None else self.__config.get(
HOST_PARAMETER, "localhost")
try:
master_config["port"] = int(
current_config[PORT_PARAMETER]) if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
int(PORT_PARAMETER), 502)
except ValueError:
master_config[
"port"] = current_config[PORT_PARAMETER] if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
PORT_PARAMETER, 502)
master_config["baudrate"] = current_config[
BAUDRATE_PARAMETER] if current_config.get(
BAUDRATE_PARAMETER) is not None else self.__config.get(
BAUDRATE_PARAMETER, 19200)
master_config["timeout"] = current_config[
TIMEOUT_PARAMETER] if current_config.get(
TIMEOUT_PARAMETER) is not None else self.__config.get(
TIMEOUT_PARAMETER, 35)
master_config[
"method"] = current_config[METHOD_PARAMETER] if current_config.get(
METHOD_PARAMETER) is not None else self.__config.get(
METHOD_PARAMETER, "rtu")
master_config["stopbits"] = current_config[
STOPBITS_PARAMETER] if current_config.get(
STOPBITS_PARAMETER) is not None else self.__config.get(
STOPBITS_PARAMETER, Defaults.Stopbits)
master_config["bytesize"] = current_config[
BYTESIZE_PARAMETER] if current_config.get(
BYTESIZE_PARAMETER) is not None else self.__config.get(
BYTESIZE_PARAMETER, Defaults.Bytesize)
master_config[
"parity"] = current_config[PARITY_PARAMETER] if current_config.get(
PARITY_PARAMETER) is not None else self.__config.get(
PARITY_PARAMETER, Defaults.Parity)
master_config[
"strict"] = current_config[STRICT_PARAMETER] if current_config.get(
STRICT_PARAMETER) is not None else self.__config.get(
STRICT_PARAMETER, True)
master_config["rtu"] = ModbusRtuFramer if current_config.get(
METHOD_PARAMETER) == "rtu" or (
current_config.get(METHOD_PARAMETER) is None
and self.__config.get(METHOD_PARAMETER)
== "rtu") else ModbusSocketFramer
if self.__previous_master_config != master_config:
self.__previous_master_config = master_config
if current_config.get(TYPE_PARAMETER) == 'tcp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "tcp"):
master = ModbusTcpClient(master_config["host"],
master_config["port"],
master_config["rtu"],
timeout=master_config["timeout"])
elif current_config.get(TYPE_PARAMETER) == 'udp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "udp"):
master = ModbusUdpClient(master_config["host"],
master_config["port"],
master_config["rtu"],
timeout=master_config["timeout"])
elif current_config.get(TYPE_PARAMETER) == 'serial' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "serial"):
master = ModbusSerialClient(method=master_config["method"],
port=master_config["port"],
timeout=master_config["timeout"],
baudrate=master_config["baudrate"],
stopbits=master_config["stopbits"],
bytesize=master_config["bytesize"],
parity=master_config["parity"],
strict=master_config["strict"])
else:
raise Exception("Invalid Modbus transport type.")
else:
master = self.__current_master
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
def testUdpClientAddressFamily(self):
''' Test the Udp client get address family method'''
client = ModbusUdpClient()
self.assertEqual(socket.AF_INET,
client._get_address_family('127.0.0.1'))
self.assertEqual(socket.AF_INET6, client._get_address_family('::1'))
def testUdpClientRepr(self):
client = ModbusUdpClient()
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)
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)
