def run_sync_client(opt):
# ----------------------------------------------------------------------- #
# connect the client
# ----------------------------------------------------------------------- #
if 'tcp' == opt['common']['protocol']:
client = ModbusTcpClient(opt['tcp']['host'], port=opt['tcp']['port'])
elif 'ascii' == opt['common']['protocol']:
client = ModbusSerialClient(method='ascii',
port=opt['serial']['device'],
timeout=1,
baudrate=opt['serial']['baudrate'])
elif 'rtu' == opt['common']['protocol']:
client = ModbusSerialClient(method='rtu',
port=opt['serial']['device'],
timeout=1,
baudrate=opt['serial']['baudrate'])
else:
print("ERR: select protocol tcp, ascii or rtu")
return
client.connect()
# ----------------------------------------------------------------------- #
# console menu loop
# ----------------------------------------------------------------------- #
console_loop(client)
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
def testBasicSyncSerialClient(self, mock_serial):
''' Test the basic methods for the serial sync client'''
# receive/send
mock_serial.in_waiting = 0
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: b'\x00' * size
client = ModbusSerialClient()
client.socket = mock_serial
client.state = 0
self.assertEqual(0, client._send(None))
client.state = 0
self.assertEqual(1, client._send(b'\x00'))
self.assertEqual(b'\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# rtu connect/disconnect
rtu_client = ModbusSerialClient(method='rtu', strict=True)
self.assertTrue(rtu_client.connect())
self.assertEqual(rtu_client.socket.interCharTimeout,
rtu_client.inter_char_timeout)
rtu_client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual('ModbusSerialClient(ascii baud[19200])', str(client))
def testSyncSerialClientInstantiation(self):
client = ModbusSerialClient()
self.assertNotEqual(client, None)
self.assertTrue(isinstance(ModbusSerialClient(method='ascii').framer, ModbusAsciiFramer))
self.assertTrue(isinstance(ModbusSerialClient(method='rtu').framer, ModbusRtuFramer))
self.assertTrue(isinstance(ModbusSerialClient(method='binary').framer, ModbusBinaryFramer))
self.assertRaises(ParameterException, lambda: ModbusSerialClient(method='something'))
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 testSerialClientConnect(self):
''' Test the serial client connection method'''
with patch.object(serial, 'Serial') as mock_method:
mock_method.return_value = object()
client = ModbusSerialClient()
self.assertTrue(client.connect())
with patch.object(serial, 'Serial') as mock_method:
mock_method.side_effect = serial.SerialException()
client = ModbusSerialClient()
self.assertFalse(client.connect())
def MainLoop(device, node_name, timeout):
#Gripper is a C-Model with an RTU connection
gripper= robotiq_c_model_control.baseCModel.robotiqBaseCModel()
gripper.client= robotiq_modbus_rtu.comModbusRtu.communication()
#We connect to the address received as an argument
#gripper.client.connectToDevice(device)
# We do not use gripper.client.connectToDevice since we want to control timeout.
#timeout= 0.005 #0.2
gripper.client.client= ModbusSerialClient(method='rtu',port=device,stopbits=1, bytesize=8, baudrate=115200, timeout=timeout)
if not gripper.client.client.connect():
print "Unable to connect to %s" % device
rospy.init_node(node_name)
#Topic of gripper status
status_pub= rospy.Publisher('~status', robotiq_msgs.CModel_robot_input, queue_size=10)
#Topic of gripper command
#rospy.Subscriber('~command', robotiq_msgs.CModel_robot_output, gripper.refreshCommand)
rospy.Subscriber('~command', robotiq_msgs.CModel_robot_output, lambda msg,g=gripper:CmdCallback(g,msg))
while not rospy.is_shutdown():
#Get and publish the Gripper status
with locker:
status= gripper.getStatus()
status_pub.publish(status)
rospy.sleep(0.005)
def __init__(self, time_offset, resource_name):
self.time_offset = time_offset
rm = pyvisa.ResourceManager()
COM_port = rm.resource_info(resource_name).alias
try:
self.client = ModbusSerialClient(method='rtu',
port=COM_port,
stopbits=1,
bytesize=8,
parity='E',
baudrate=9600)
except:
self.verification_string = "False"
self.client = False
return
# make the verification string
if self.ReadRegisters():
self.verification_string = str(self.PanelSerialNumber()[0])
else:
self.verification_string = "False"
# HDF attributes generated when constructor is run
self.new_attributes = []
# shape and type of the array of returned data
self.dtype = 'f'
self.shape = (11, )
def initialize_modbus(self):
"""
initalize correct client according to type specified in config:
'tcp' or 'serial'
"""
if self.MODBUS_TYPE == 'serial':
self.client= ModbusSerialClient(
method = self.METHOD,
port = self.SERIAL_PORT,
stopbits = self.STOPBITS,
bytesize = self.BYTESIZE,
parity = self.PARITY,
baudrate = self.BAUDRATE
)
connection = self.client.connect()
if self.MODBUS_TYPE == 'tcp':
self.client = ModbusTcpClient(self.IP_ADDRESS,port=self.PORT)
'''
rr = self.read_register_raw(0x601,1,247)
decoder = BinaryPayloadDecoder.fromRegisters(
rr.registers,
byteorder=self.BYTE_ORDER,
wordorder=self.WORD_ORDER)
output = decoder.decode_16bit_int()
print(output)
'''
#rr = self.read_register_raw(1001,2,7)
'''decoder = BinaryPayloadDecoder.fromRegisters(
def __init__(self, **kwargs):
self.slave_id = 1
self.ip = '127.0.0.1'
self.port = kwargs.get('interface')
stopbits = int(kwargs.get('stop_bits', 1))
if kwargs.get('parity') == 'even':
parity = 'E'
elif kwargs.get('parity') == 'odd':
parity = 'O'
elif kwargs.get('parity') == 'none':
parity = 'N'
else:
parity = 'N'
self.client = ModbusSerialClient(method='rtu',
port=kwargs.get('interface'),
baudrate=kwargs.get('baud_rate'),
stopbits=stopbits,
parity=parity,
timeout=int(kwargs.get('timeout', 1)))
LOG.critical("ExositeModbusRTU: initialized: {}".format(kwargs))
LOG.critical("ExositeModbusRTU: initialized: {}".format(self))
def main():
t = 1
# Linux
#client = ModbusSerialClient("rtu", port='/dev/ttyS1', baudrate=9600, timeout=t)
# Windows
client = ModbusSerialClient("rtu", port='COM4', baudrate=9600, timeout=t)
client.connect()
start = time.time()
#data = client.read_input_registers(0x0000, count=10, unit=0x01)
data = client.read_holding_registers(0x0002, count=5, unit=0x01)
#print dir(data)
print(data.function_code)
print(data.registers)
stop = time.time()
if data:
succ = "was successful"
else:
succ = "failed"
print("timeout: %ss, read %s, time spent reading: %fs" %
(t, succ, stop - start))
def connect(_port='/dev/ttyUSB0',
_baudrate=9600,
_timeout=10,
_parity='N',
_stopbits=1,
_bytesize=8):
""" Connect to a RTU device
:param _port: Port to connect to device
:param _baudrate: Baudrate of connection
:param _timeout: Timeout of connection
:param _parity: Parity of connection
:param _stopbits: Stop bits of connection
:param _bytesize: Byte size of connection
:return: If connected return a ModBusSerialClient (Connection) Object
"""
client = ModbusSerialClient(method='rtu',
port=_port,
baudrate=_baudrate,
timeout=_timeout,
parity=_parity,
stopbits=_stopbits,
bytesize=_bytesize)
if client.connect():
print('RTU bus was connected')
return client
else:
print('Could not connect with RTU bus')
return None
def get_modbus_register_data(client, address, count, u):
# print "Reading modbus Address: %s" % address
#rq = client.read_holding_registers(1000,7,unit=1)
#connection = client.connect()
#print(connection)
tryit = True
while tryit:
#result = client.read_holding_registers(1002,1,unit=1) #(address=1000,count=1,unit=1)
try:
result = client.read_holding_registers(
address, count, unit=u) #(address=1000,count=1,unit=1)
except:
# print "Exception"
client.close()
client = ModbusSerialClient(method="rtu",
port="/dev/rfcomm1",
baudrate=9600,
stopbits=1,
bytesize=8,
timeout=1)
client.connect()
time.sleep(1)
else: #if result.isError():
try:
r = result.registers[0]
tryit = False #result.isError()
except:
tryit = True
#print(result.registers)
return r #esult.registers[0]
def single_client_test(host, cycles):
''' Performs a single threaded test of a synchronous
client against the specified host
:param host: The host to connect to
:param cycles: The number of iterations to perform
'''
logger = log_to_stderr()
logger.setLevel(logging.DEBUG)
logger.debug("starting worker: %d" % os.getpid())
try:
count = 0
# client = ModbusTcpClient(host, port=5020)
client = ModbusSerialClient(method="rtu",
port="/dev/ttyp0",
baudrate=9600)
while count < cycles:
with _thread_lock:
result = client.read_holding_registers(10, 1,
unit=1).getRegister(0)
count += 1
except:
logger.exception("failed to run test successfully")
logger.debug("finished worker: %d" % os.getpid())
def __init__(self, conf):
"""
inti modbus client
:param conf: conf of modbus
"""
self.modbus = ModbusSerialClient(conf['protocol'], port=conf['port'], baudrate=conf['baudrate'],
bytesize=conf['bytesize'], stopbits=conf['stopbits'], parity=conf['parity'])
def initialize(self):
self._operator_interface.print_to_console("Initializing Fixture\n")
self._serial_port = serial.Serial(self._station_config.FIXTURE_COMPORT,
115200,
parity='N',
stopbits=1,
timeout=1,
xonxoff=0,
rtscts=0)
if self._station_config.FIXTURE_PARTICLE_COUNTER:
parity = 'N'
Defaults.Retries = 5
Defaults.RetryOnEmpty = True
self._particle_counter_client = ModbusSerialClient(
method='rtu',
baudrate=9600,
bytesize=8,
parity=parity,
stopbits=1,
port=self._station_config.FIXTURE_PARTICLE_COMPORT,
timeout=2000)
if not self._particle_counter_client.connect():
raise pancakepixelFixtureError(
'Unable to open particle counter port: %s' %
self._station_config.FIXTURE_PARTICLE_COMPORT)
if not self._serial_port:
raise pancakepixelFixtureError(
'Unable to open fixture port: %s' %
self._station_config.FIXTURE_COMPORT)
else:
self._operator_interface.print_to_console(
"Fixture %s Initialized.\n" %
self._station_config.FIXTURE_COMPORT)
return True
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 serve(self):
while not self.stop:
if self.do(0.1, self.query_interval):
with self.lock:
logging.info("Querying Modbus-RTU device {}.".format(
self.tpid))
try:
if not os.access(self.device, os.R_OK | os.W_OK):
raise PermissionError()
with ModbusSerialClient(method="rtu",
port=self.device,
baudrate=self.baudrate,
parity=self.parity,
timeout=1) as client:
self._iterate_registers(client)
except PermissionError:
logging.warning(
"Cannot access device {}: No permissions or device doesn't exist. "
"Please check if your udev-rules are set correctly. Retrying in {}s."
.format(self.device, self.query_interval))
except ConnectionException:
logging.warning(
"Could not connect to Modbus-RTU client on {}. Retrying in {}s."
.format(self.tpid, self.query_interval))
def __init__(self, port, device):
self.device = device
self.port = port
self.baudrate = 9600
self.client = ModbusSerialClient(method='rtu', port=self.port, stopbits=1, baudrate=self.baudrate, parity='N')
connected = self.client.connect()
print("Connected: %s" % str(connected))
def __init__(self,
method='rtu',
port='/dev/ttyUSB0',
baudrate=9600,
timeout=3,
parity='E',
stopbits=1,
bytesize=8,
slaveAddress=0):
self.method = method
self.port = port
self.baudrate = baudrate
self.timeout = timeout
self.parity = parity
self.stopbits = stopbits
self.bytesize = bytesize
self.slaveAddress = slaveAddress
self.client = ModbusSerialClient(
method=self.method,
port=self.port, #'/dev/ttyUSB0'or #'COM9',
baudrate=self.baudrate,
timeout=self.timeout,
parity=self.parity,
stopbits=self.stopbits,
bytesize=self.bytesize)
def connect(self):
self.client = ModbusSerialClient('rtu',
port=self.port,
baudrate=self.baudrate,
timeout=self.timeout)
self.client.logger = self.logger
self.client.connect()
def _conn(self, rtu_port=None, tcp_ip=None, tcp_port=None):
"""
Connect to the device using either TCP or RTU. If using
TCP, use an RTU framer to emulate serial at the PLC.
"""
if rtu_port is None and (tcp_ip is None or tcp_port is None):
raise Exception('C000DRD Exception: no RTU or TCP port specified')
elif rtu_port is not None and (tcp_ip is not None
or tcp_port is not None):
raise Exception('C000DRD Exception: RTU and TCP port specified. '
'Can only have one or the other.')
elif rtu_port is not None:
self.client = ModbusSerialClient(method='rtu',
port=rtu_port,
baudrate=38400,
timeout=0.1,
parity=serial.PARITY_ODD)
self.conn = self.client.connect()
elif tcp_ip is not None and tcp_port is not None:
self.client = ModbusTcpClient(tcp_ip,
port=int(tcp_port),
baudrate=38400,
timeout=0.1,
parity=serial.PARITY_ODD,
framer=ModbusRtuFramer)
self.conn = self.client.connect()
def connectToDevice(self, device):
"""Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument."""
self.client = ModbusSerialClient(method='rtu',port=device,stopbits=1, bytesize=8, baudrate=115200, timeout=0.2)
if not self.client.connect():
print "Unable to connect to %s" % device
return False
return True
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 __init__(self, xmlFile):
"""Parses the xml file and creates the reader"""
self.xml = xmlFile
validationInt = validateXml(self.xml)
if validationInt == -1: raise Exception('XML File Error: devicData node missing')
elif validationInt == -2: raise Exception('XML File Error: modbus type not set')
elif validationInt == -3: raise Exception('XML File Error: ip address missing')
elif validationInt == -4: raise Exception('XML File Error: comm port missing')
elif validationInt == -5: raise Exception('XML File Error: baud rate missing')
elif validationInt == -10: raise Exception('XML File Error: No register mappings')
elif validationInt == -11: raise Exception('XML File Error: Duplicated Input register mapping')
elif validationInt == -12: raise Exception('XML File Error: Duplicated Discrete input mapping')
elif validationInt == -13: raise Exception('XML File Error: Duplicated Holding register mapping')
elif validationInt == -14: raise Exception('XML File Error: Duplicated Coil mapping')
self.xmlData = self._parseXml()
if self.xmlData.get('modbusType') == 'tcp/ip':
self.client = ModbusTcpClient(self.xmlData.get('ip'), self.xmlData.get('port'), timeout=1)
elif self.xmlData.get('modbusType') == 'rtu':
self.client = ModbusSerialClient(method = 'rtu',
port = self.xmlData.get('com'),
baudrate = self.xmlData.get('baud'),
bytesize = self.xmlData.get('bytesize'),
stopbits = self.xmlData.get('stopbits'),
parity = self.xmlData.get('parity'),
timeout = self.xmlData.get('timeout'),
)
def execute_corresponding_args(self):
"""
Parsing arguments and calling corresponding functions
"""
try:
if self._args.verbose:
self._logger.setLevel(logging.DEBUG)
else:
self._logger.setLevel(logging.INFO)
self._modbus_client = ModbusSerialClient(method="rtu",
port=self._serial_port,
parity='N',
timeout=3,
stopbits=1,
bytesize=8,
baudrate=self._baudrate)
self._modbus_client.connect()
if self._args.test:
self.test()
self.read_items()
if self._args.display_results:
self.display_items()
if self._args.store_csv:
self.store_to_csv()
except Exception as l_e:
self._logger.error(
'Error in execute_corresponding_args: {}'.format(l_e))
self._modbus_client.close()
raise l_e
def connect(self):
ret = False
if self._option['conn']['method'] == 'rtu':
self._conn = ModbusSerialClient(
method='rtu',
port=self._option['conn']['port'],
timeout=self._timeout,
baudrate=self._option['conn']['baudrate'])
ret = self._conn.connect()
msg = "failed to connect with rtu"
code = NotiCode.RTU_CONNECTED if ret else NotiCode.RTU_FAILED_CONNECTION
elif self._option['conn']['method'] == 'tcpc':
self._conn = ModbusTcpClient(self._option['conn']['host'],
port=self._option['conn']['port'],
timeout=self._timeout)
ret = self._conn.connect()
msg = "failed to connect with tcp"
code = NotiCode.TCP_CONNECTED if ret else NotiCode.RTU_FAILED_CONNECTION
else:
msg = "It's a wrong connection method. " + str(
self._option['conn']['method'])
if ret == False:
self._logger.warn(msg)
noti = Notice(
None, NotiCode.RTU_FAILED_CONNECTION) # detection is canceled
else:
noti = Notice(None,
NotiCode.RTU_CONNECTED) # detection is canceled
self.writecb(noti)
super(KSX3267Mate, self).connect()
return ret
def onHeartbeat(self):
Domoticz.Log("onHeartbeat called")
# Wich serial port settings to use?
if (Parameters["Mode3"] == "S1B7PN"): StopBits, ByteSize, Parity = 1, 7, "N"
if (Parameters["Mode3"] == "S1B7PE"): StopBits, ByteSize, Parity = 1, 7, "E"
if (Parameters["Mode3"] == "S1B7PO"): StopBits, ByteSize, Parity = 1, 7, "O"
if (Parameters["Mode3"] == "S1B8PN"): StopBits, ByteSize, Parity = 1, 8, "N"
if (Parameters["Mode3"] == "S1B8PE"): StopBits, ByteSize, Parity = 1, 8, "E"
if (Parameters["Mode3"] == "S1B8PO"): StopBits, ByteSize, Parity = 1, 8, "O"
if (Parameters["Mode3"] == "S2B7PN"): StopBits, ByteSize, Parity = 2, 7, "N"
if (Parameters["Mode3"] == "S2B7PE"): StopBits, ByteSize, Parity = 2, 7, "E"
if (Parameters["Mode3"] == "S2B7PO"): StopBits, ByteSize, Parity = 2, 7, "O"
if (Parameters["Mode3"] == "S2B8PN"): StopBits, ByteSize, Parity = 2, 8, "N"
if (Parameters["Mode3"] == "S2B8PE"): StopBits, ByteSize, Parity = 2, 8, "E"
if (Parameters["Mode3"] == "S2B8PO"): StopBits, ByteSize, Parity = 2, 8, "O"
###################################
# pymodbus: RTU / ASCII
###################################
if (Parameters["Mode1"] == "rtu" or Parameters["Mode1"] == "ascii"):
Domoticz.Debug("MODBUS DEBUG USB SERIAL HW - Port="+Parameters["SerialPort"]+", BaudRate="+Parameters["Mode2"]+", StopBits="+str(StopBits)+", ByteSize="+str(ByteSize)+" Parity="+Parity)
Domoticz.Debug("MODBUS DEBUG USB SERIAL CMD - Method="+Parameters["Mode1"])
try:
client = ModbusSerialClient(method=Parameters["Mode1"], port=Parameters["SerialPort"], stopbits=StopBits, bytesize=ByteSize, parity=Parity, baudrate=int(Parameters["Mode2"]), timeout=1, retries=2)
except:
Domoticz.Log("Error opening Serial interface on "+Parameters["SerialPort"])
#Devices[1].Update(0, "0") # Update device in Domoticz
###################################
# pymodbus: RTU over TCP
###################################
if (Parameters["Mode1"] == "rtutcp"):
Domoticz.Debug("MODBUS DEBUG TCP CMD - Method="+Parameters["Mode1"])
try:
client = ModbusTcpClient(host=UnitAddress, port=int(Parameters["Port"]), framer=ModbusRtuFramer, auto_open=True, auto_close=True, timeout=5)
except:
Domoticz.Log("Error opening TCP interface on address: "+UnitAddress)
#Devices[1].Update(0, "0") # Update device in Domoticz
###################################
# pymodbusTCP: TCP/IP
###################################
if (Parameters["Mode1"] == "tcpip"):
Domoticz.Debug("MODBUS DEBUG TCP CMD - Method="+Parameters["Mode1"]+", Address="+UnitAddress+", Port="+Parameters["Port"]+", Unit ID="+self.UnitIdForIp+", Register="+Parameters["Password"]+", Data type="+Parameters["Mode6"])
try:
client = ModbusClient(host=UnitAddress, port=int(Parameters["Port"]), unit_id=self.UnitIdForIp, auto_open=True, auto_close=True, timeout=5)
except:
Domoticz.Log("Error opening TCP/IP interface on address: "+UnitAddress)
#Devices[1].Update(0, "0") # Update device in Domoticz
try:
#Domoticz.Log("Before update. Number of devices:"+str(len(Devices)))
for i in reg:
i.update(client,Domoticz)
#Domoticz.Log("After update")
except Exception as e:
Domoticz.Log("Error calling update "+repr(e))
client.close()
def __init__(
self, host=False, port=False,
device=False, stopbits=False, parity=False, baud=False,
timeout=TIMEOUT, retries=RETRIES, unit=UNIT,
parent=False
):
if parent:
self.client = parent.client
self.mode = parent.mode
self.client = parent.client
self.timeout = parent.timeout
self.retries = parent.retries
self.unit = parent.unit
if self.mode is connectionType.RTU:
self.device = parent.device
self.stopbits = parent.stopbits
self.parity = parent.parity
self.baud = parent.baud
elif self.mode is connectionType.TCP:
self.host = parent.host
self.port = parent.port
else:
raise NotImplementedError(self.mode)
else:
self.host = host
self.port = port
self.device = device
if stopbits:
self.stopbits = stopbits
if parity:
self.parity = parity
if baud:
self.baud = baud
self.timeout = timeout
self.retries = retries
self.unit = unit
if device:
self.mode = connectionType.RTU
self.client = ModbusSerialClient(
method="rtu",
port=self.device,
stopbits=self.stopbits,
parity=self.parity,
baudrate=self.baud,
timeout=self.timeout)
else:
self.mode = connectionType.TCP
self.client = ModbusTcpClient(
host=self.host,
port=self.port,
timeout=self.timeout
)
def testSerialClientRecv(self):
''' Test the serial client receive method'''
client = ModbusSerialClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual('', client._recv(0))
self.assertEqual('\x00' * 4, client._recv(4))
def testSerialClientSend(self):
''' Test the serial client send method'''
client = ModbusSerialClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(4, client._send('1234'))
