Double Command - C_DC_NA_1 (T46) QU:0-1-2-3

[bambosd]

Hello and congratulations for bringing IEC 104 protocol to python community.

I'm trying to transfer a double command to a modbus TCP Server using library pymodbus.

There is a property of this command which is : no -short pulse - long pulse - persistent. 0-1-2-3

A. Is there any functionality to detect the type of qualifier for double command ?

B. if yes, how we can asynchronous execute the trigger function ?? (We need async because in case of short pulse the modbus write command will be modbus write the value (0 or 1 for on or off) and then time.sleep for 2-3 seconds and then write the value to 0 to properly simulate the pulse)
same goes for short pulse
for persistent is continuously write the same value to the target.(3)
for 0 qualifier (no) i really didn't understand protocol wise what is doing.

This time.sleep will stop all server functionality, that's why i'm asking if there is a possibility to work async.

Thanks for any comments or suggestions.

[m-unkel]

Hello bambosd, and thank you for your kind words and detailed questions!

We have recently added async examples to the repository, including access to the double command qualifier, which should help clarify the usage. To address your points:

• The point.value property is essentially a quick shortcut to point.info.value. All additional command details are accessible via point.info. Specifically, for the double command qualifier, you can access it through point.info.qualifier.

• Please refer to the documentation for c104.DoubleCmd and the following examples down below for more details on how to work with these properties.

Regarding your question about async execution:

• Is the assumption correct that your code is fully async? Our library is designed to be event-driven using callbacks, and very few calls are blocking. Heavy lifting runs in a C++ thread in the background.

• Callbacks are executed from these background threads, which is why in the examples we use run_coroutine_threadsafe to integrate async code safely.

• This design allows you to implement async trigger functions that avoid blocking the server, which fits your use case perfectly (for example, to handle short pulses without blocking the main event loop).

Examples

• Async Client Example
• Async Server Example

We hope this clarifies things! Feel free to reach out if you need more help or examples.

Best
Martin

[bambosd]

Hello Martin,

here is my structure of 104 Server, without using the block of your examples : if name == "main": .... for simplicity and testing. This is not directly related to async defs, but is related to how we trigger outputs and the code structure.

def p3_refresh(point: c104.Point) -> None:
    p3.value=1+random.random()

p3 = station.add_point(io_address=508, type=c104.Type.M_ME_NC_1 , report_ms=1000)
p3.on_before_auto_transmit(callable=p3_refresh)


def availability_read(point: c104.Point) -> None:
    availability.value=95.33
    availability.transmit(c104.Cot.SPONTANEOUS)

availability = station.add_point(io_address=505, type=c104.Type.M_ME_NC_1)
#availability.on_before_auto_transmit(callable=availability_read)


##################### start 104 Server
server.start()

while True:
    time.sleep(1)
    print('')
    print("Connections: open %s active %s" % (server.open_connection_count, server.active_connection_count))
    
    spi_101_read()
    dpi_read(dpi_100)
    voltage_read(voltage)
    availability_read(availability)

Please note that using this structure, the on_before_auto_transmit call is not working on point availability (505) because there is no report_ms. If this value is spontaneous, using on_before_auto_transmit and report_ms sending this value as periodic !
as the p3 point (508). So the only way to trigger the function as spontaneous, is call it under while True: availability_read(availability).

can i run async def functions without the asyncio.run(main) structure (as the examples) ?

back to double command example like below :

# ########################### DC IN (T46)  ##############################

dc_10 = station.add_point(io_address=10, type=c104.Type.C_DC_NA_1)

def dc_10_command(point: c104.Point, previous_info: c104.Information, message: c104.IncomingMessage) -> c104.ResponseState:
    
    print('dc command received:' , dc_10.value)
    
    #print(int(dc_10.value))
    
    if dc_10.value==c104.Double.OFF:
        print('received off')
    if dc_10.value==c104.Double.ON:
        print('received on')
    
    m.connect()                               # connect to device
    m.write_register(10, int(dc_10.value),  device_id=1)        # set information in device
    print('write command:' , dc_10.value , int(dc_10.value) )
    m.close()   
    
    return c104.ResponseState.SUCCESS

dc_10.on_receive(callable=dc_10_command)

If you see the write register modbus command is just one shot modbus write (using pymodbus).
This method is not taking into account the qualifier, and in order to not miss any command, after i see a value change on this addresses, i write again zeros to reset the state, so i'm able to see the next double commands coming. (PLC Side).

Notes on how 104 RTU's behaving for double command (T46).
If the qualifier is pulse, this means write 2 , wait for 3 seconds, and write back the previous value. (whatever it was, 0 or 1)
for example if was a persistent value on 1 (off), we should transfer 2(ON) for 3 seconds and then return to 1.
if a persistent double command arrives, this means loop write and persist on that value and write it again on every cycle.
so it gets a little complicated if you want to pass the command with qualifiers and logic :)

Can this double command executes as async def as is ? if you see problem making only the double command async, what would be the recommended structure of 104 Server, taking into consideration double commands and also outputs periodic and spontaneous ?

Thanks for any suggestions and comments !