Updating AsyncSerialServer while server is running with updating_task

[kepten2]

Hi all, I'm pretty new to modbus (and thus pymodbus), so forgive if these are stupid questions.

I'm trying to run a serial modbus server that get's values from an API. The goal is to update these values every day or X hours, but without restarting the modbus server.
I have the updating_server example working with values from the API or the default example values (context).
I can read these values with a client. But I can't seem to update the values after the initial update when the server starts. Is this even possible without restarting the modbus server?

Some relevant code (adjusted example code):

async def updating_task(context):
    """Run every so often and update live values of the context.

    It should be noted that there is a race condition for the update.
    """
    log.debug("updating the context")
    fc_as_hex = 3
    slave_id = SLAVE_ID
    address = 0x00
    values = context[slave_id].getValues(fc_as_hex, address, count=5)
    values = [v + 1 for v in values]  # increment by 1.
    txt = f"new values: {values!s}"
    log.debug(txt)
    context[slave_id].setValues(fc_as_hex, address, values)
    await asyncio.sleep(1)

def setup_updating_server(cmdline=None):
    """Run server setup."""
    # The datastores only respond to the addresses that are initialized
    # If you initialize a DataBlock to addresses of 0x00 to 0xFF, a request to
    # 0x100 will respond with an invalid address exception.
    # This is because many devices exhibit this kind of behavior (but not all)

    # Continuing, use a sequential block without gaps.
    #datablock = ModbusSequentialDataBlock(0x00, [5] * 100)
    #context = ModbusSlaveContext(di=datablock, co=datablock, hr=datablock, ir=datablock)
    #context = ModbusServerContext(slaves=context, single=True)
    return setup_server(
        TibberObject(), description="Run asynchronous server.", cmdline=cmdline
    )

async def run_updating_server(args):
    """Start updater task and async server."""
    asyncio.create_task(updating_task(args.context))  # noqa: RUF006
    await run_async_server(args)

async def main(cmdline=None):
    """Combine setup and run"""
    run_args = setup_updating_server(cmdline=cmdline)
    await run_updating_server(run_args)

if __name__ == "__main__":
    asyncio.run(main(), debug=True)  # pragma: no cover

and server setup code:

def setup_server(price_object, description=None, context=None, cmdline=None, SLAVE_ID=18):
    args = helper.get_commandline(server=True, description=description, cmdline=cmdline)
    if context:
        args.context = context
    if not args.context:
        builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big)
        for today_price in price_object.todays.values():
            builder.add_32bit_float(today_price)
        payload_today = builder.to_registers()
        datablock_today = ModbusSequentialDataBlock(1, payload_today)
        builder_tommorow = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big)
        for tomorrow_price in price_object.tomorrows.values():
            builder_tommorow.add_32bit_float(tomorrow_price)
        payload_tomorrow = builder_tommorow.to_registers()
        datablock_tomorrow = ModbusSequentialDataBlock(1, payload_tomorrow)
        store = {
                SLAVE_ID: ModbusSlaveContext(
                    di=datablock_today,
                    co=datablock_today,
                    hr=datablock_today,
                    ir=datablock_today,
                ),
                SLAVE_ID+1: ModbusSlaveContext(
                    di=datablock_tomorrow,
                    co=datablock_tomorrow,
                    hr=datablock_tomorrow,
                    ir=datablock_tomorrow,
                )
            }
        single = False
        args.context = ModbusServerContext(slaves=store, single=single)
    args.identity = ModbusDeviceIdentification(
        info_name= {
            "VendorName": "XX",
            "ProductCode": "XX",
            "VendorUrl": "XX",
            "ProductName": "XX",
            "ModelName": "XX",
            "MajorMinorRevision": "0.1",
        }
    )
    return args

async def run_async_server(args):
    server = await StartAsyncSerialServer(
        context=args.context, 
        identity=args.identity,
        port=args.port, 
        framer=args.framer,
        baudrate=args.baudrate, 
        parity=args.parity, 
        stopbits=1, 
        bytesize=8,
        timeout=3
    )
    return server

[janiversen]

seems the example is wrong! You cannot add a new context after the server is started, after the server is started you can update the values in context used in startserver with set_values().

[janiversen]

Sorry I was too fast, the example is correct and works, but the passing of the context could be made easier.

I think you tibberobject complicates things more, please ensure you only have one context being passed around.

[janiversen]

If you get values from somewhere that you want to into a modbus server, who then is going to read them......devices are servers so they do not read data, and clients are normally apps, but then the app could read the data directly

[kepten2]

Hi Thanks for the quick replies! Yea I know about the difference between servers and clients. I'm running the server on a Raspberry Pi and the client on my pc connected via usb. I can read the values from the server with the client, and I can see the values (first 5, as expected) are being updated by the updating_task function, some logs:
First the original values from the tibberobject (just a list with floats):

pymodbus.logging DEBUG [16003, 24851, 15995, 18979, 15994, 3985, 15992, 61237, 15994, 10695, 16000, 30199, 16017, 16672, 16019, 36595, 16020, 34813, 16017, 23383, 16014, 32086, 16005, 7864, 16003, 58406, 15999, 11849, 15987, 33240, 15981, 30514, 15988, 61656, 16003, 31562, 16011, 37434, 16020, 48234, 16028, 37329, 16030, 43830, 16024, 47815, 16018, 45089]

root DEBUG new values: [16004, 24852, 15996, 18980, 15995]

And then I can read the new values with the client:

DEBUG:pymodbus.logging:[16004, 24852, 15996, 18980, 15995]

But my question is, if I can run the updating_task function again when the server is already running. Maybe at an interval or something. Or triggered from another modbus client.

[janiversen]

Yes.

[kepten2]

Yes to run the updating_task again? How can I accomplish that? (Sorry for all the questions, I'm a little bit of noob to this subject)

[janiversen]

Your question have absolutely nothing to do with pymodbus, it is solely related to python, so please do a google search or whatever.