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)