I have modified PyModbus Async Asyncio Client Example and created a program (see below) to copy coils and registers from one PLC to another. There is a main thread and a thread for each node(PLC). The modified code works reasonable well. But it turned out that the code runs considerable slower if I configured two pairs of source / destination nodes instead of one pair and copying the same amount of MODBUS packets.
Copying 140 frames from N1 to N2 is way faster (using three thread: main, N1, N2) than copying 70 frames from N1 to N2 and another 70 frames from N3 to N4 (using five threads main, N1, N2, N3, N4)
I expected the configuration with two pairs running faster. What I should change or why my expectation is incorrect? Thanks!
def run_with_already_running_loop(self):
UTILS.LOGGER.info("Running Async client with asyncio loop already started")
UTILS.LOGGER.info("------------------------------------------------------")
def done(future):
UTILS.LOGGER.info("Done !!!")
def start_loop(loop):
"""
Start Loop
:param loop:
:return:
"""
asyncio.set_event_loop(loop)
loop.run_forever()
while True:
for hostdef in self.M_HostList:
if hostdef.host == None or hostdef.host.client.protocol == None:
try:
if hostdef.host == None:
host = COPYHOST()
host.loop = asyncio.new_event_loop()
host.t = Thread(target=start_loop, args=[host.loop])
host.t.daemon = True
# Start the loop
host.t.start()
assert host.loop.is_running()
asyncio.set_event_loop(host.loop)
host.loop, host.client = ModbusClient(schedulers.ASYNC_IO, host=hostdef.IP, port=hostdef.port, loop=host.loop)
hostdef.host = host
host.future = asyncio.run_coroutine_threadsafe(self.start_async_test(hostdef, hostdef.host.client.protocol, hostdef.job, hostdef.time), loop=host.loop)
host.future.add_done_callback(done)
UTILS.LOGGER.info("Made host on {}".format(hostdef.key))
except:
UTILS.LOGGER.info("Failed to make host on {}".format(hostdef.key))
pass
try:
self.manage_jobs(hostdef)
# UTILS.LOGGER.info("@@@ {}".format(hostdef.key))
except:
pass
time.sleep(0.05)
async def start_async_test(self, hostdef, client, job, job_start_time):
last_milli_time = 0
while True:
if client == None:
await asyncio.sleep(1)
continue
current_milli_time = UTILS.UTILS.time_ms()
if job == None:
if (current_milli_time-last_milli_time) > 1000:
#UTILS.LOGGER.info("!!! {}".format(hostdef.key))
last_milli_time = current_milli_time
else:
#UTILS.LOGGER.info("!!! {} {}".format(hostdef.key, job.state))
pass
if job != None and job.state == 3 and hostdef.oqueue.qsize() == 0:
assert job_start_time != 0
job.state = 4
#UTILS.LOGGER.info("FINISHING JOB: {}".format(job.SD.key))
fjob = deepcopy(job)
hostdef.oqueue.put(fjob)
job = None
job_start_time = 0
if job == None and hostdef.iqueue.qsize() != 0:
job = hostdef.iqueue.get()
job.state = 1
job_start_time = current_milli_time
#UTILS.LOGGER.info("START JOB: {}".format(job.SD.key))
if job != None and job.dir == 'D' and job.state == 1:
# in case of destination we write
job.state = 2
if job.SD.type == '%M':
rq = await client.write_coils(job.SD.start, job.buffer, unit=UNIT)
job.state = 3
if rq.function_code < 0x80:
job.Fault = False
else:
job.Fault = True
assert False
pass
elif job.SD.type == '%MW':
rq = await client.write_registers(job.SD.start, job.buffer, unit=UNIT)
job.state = 3
if rq.function_code < 0x80:
job.Fault = False
else:
job.Fault = True
assert False
pass
else:
assert False
elif job != None and job.dir == 'S' and job.state == 1:
# in case of source we read
job.state = 2
if job.SD.type == '%M':
rr = await client.read_coils(job.SD.start, job.SD.size, unit=UNIT)
job.state = 3
if rr.function_code < 0x80:
job.Fault = False
job.buffer = rr.bits
else:
job.Fault = True
job.buffer = None
assert False
pass
elif job.SD.type == '%MW':
rr = await client.read_holding_registers(job.SD.start, job.SD.size, unit=UNIT)
job.state = 3
if rr.function_code < 0x80:
job.Fault = False
job.buffer = rr.registers
else:
job.Fault = True
job.buffer = None
assert False
else:
assert False
await asyncio.sleep(0.01)
