Modbus RTU master READ_HOLDING_REGISTERS processed slow

[skylin008]

Hello everyone, I had used the code [https://github.com/brainelectronics/micropython-modbus/tree/develop/umodbus] Modbus RTU READ HOLDING REGISTERS function in PYBV11 with micropython version is V1.22 . It is elapsed time about : 30~40ms, how to speed up the data process time, thanks !
Follow as the master code:

`# modbus master driver for lidar

6 pieces lidar for system, address from 1 to 6

from right to left side, count round closewize

system package

from machine import Pin
import logging
import gc
from InitConfig import config
import uasyncio as asyncio
import time

log = logging.MiniLog("RtuMaster", level = logging.DEBUG)
DEBUG = config.get('DEBUG', False)

MasterUartId = config.get("UART_LIDAR")

self defined package

from umodbus.serial import Serial

gc.collect()

version = '1.0'
author = 'skylin'

def timed_function(f, *args, **kwargs):
myname = str(f).split(' ')[1]
def new_func(*args, **kwargs):
t = time.ticks_us()
result = f(*args, **kwargs)
delta = time.ticks_diff(time.ticks_us(), t)
print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
return result
return new_func

register_definitions = {
"HREGS":{ # read hold registers
"slave_address":{
"index1": 1,
"index2": 2,
"index3": 3,
"index4": 4,
"index5": 5,
"index6": 6
},
"register_address": 0x01,
"length": 0x02,
},
}

class Frame(object):
def init(self,data = None):
""" Data struct: """
if data is None:
self.data = bytearray()
else:
self.data = bytearray(data)

def __len__(self):
    return len(self.data)

class FrameBuffer(object):
def init(self, size):
"""
A FrameBuffer is used to buffer frames received from the Network
over the active Bus.The FrameBuffer is designed as a FIFO and is
useful to overcome the limited storing capability
"""
self._size = size
self._data = [[memoryview(bytearray(4))] for _ in range(size)]
self._index_write = 0
self._index_read = 0
self._null_sink = [0, 0, 0, 0]
self._count = 0

@micropython.native
def put(self, v):
    self._data[self._index_write] = v
    self.next_index = (self._index_write + 1) % self._size
    if self.next_index != self._index_read:
        self._index_write = self.next_index
        self._count += 1
    else:
        self.clear()
        if DEBUG:
            raise Exception("frame buffer over flow")

@micropython.native
def get(self):
    if self._index_read == self._index_write:
        return None

    lin_id, _, data = self._data[self._index_read]
    self._index_read = (self._index_read +1) % self._size
    self._count -= 1
    return Frame(data)  # Omit the data length


def any(self):
    if self._index_read == self._index_write:
        return False
    return True

def clear(self):
    self._index_write = 0
    self._index_read  = 0

class Master(object):
def init(self, uart_id = MasterUartId, baudrate = 115200, ctrlpin ='485_TR1', fbSize = 128):

    self.host = Serial(uart_id = uart_id, baudrate = baudrate, data_bits = 8, stop_bits = 2, parity = None, ctrl_pin = ctrlpin)            
   
    self.framebuf = FrameBuffer(fbSize)

@micropython.native
def write(self, registerdefinitions, idx):     
    slave_addr = registerdefinitions['HREGS']['slave_address'][idx]
    register_addr = registerdefinitions['HREGS']['register_address']
    qty = registerdefinitions['HREGS']['length']
     
    register_value = self.host.read_holding_registers(
                    slave_addr = slave_addr,
                    starting_addr = register_addr,
                    register_qty = qty,
                    signed = False
)   
    return register_value


def read(self):
    if self.framebuf.any():
        return self.framebuf.get()

if name == 'main':

async def test():            
    m = Master()
    import time
    while True:
        #for idx in ['index1','index2','index3','index4','index5','index6']:
        for idx in ['index1']:
            send_start_time = time.ticks_ms()
            res = m.write(register_definitions, idx)
            send_finish_time = time.ticks_ms()               
            print(f"time elapse:{send_finish_time - send_start_time}")
            #gc.collect()
            await asyncio.sleep_ms(20)  


async def start():
    asyncio.create_task(test())
    while True:
        await asyncio.sleep_ms(1)

app = None
async def main():
    import time
    t = time.localtime()
    log.info(t)
    gc.collect()
    global app
    
    await start()

try:
    gc.collect()
    asyncio.run(main())

except KeyboardInterrupt:
    log.info('Interrupt')

finally:
    asyncio.new_event_loop()
    log.info("run again")

`

[2dof]

I haven't worked with this lib yet, but if You read holding registers always in that same manner, then no need every time (in write function ) to extract params of register definitions to local variable and then to self.host.read_holding_registers. Also if possible you can construct whole PDU frame ( see https://www.simplymodbus.ca/FC03.htm) as 'const' and directly send to slave (no need to build frame by master every time.) , but it will not speed up probably too much.
Does slave using that same lib?

Edit: check if master has some delay set waiting time between two consecutive frames ( but usually it is 3.5 signs ( usually not less than 1.5 - 2 ms), to if you can check timing of frames construct on master side, and then on slave ( slave usually have about 30-50 ms to response) so maybe your 30-40 ms is just caused by slave (as default)

[skylin008]

thanks @2dof kindly advice.I will be try directly send to slave with const.