Method - no vars? (.set_modelling_rule(True)) - auto creation of nodeid's

[dannyolsen]

Hi,

can anyone explain why the variables on the one method shows and the other one not? And is it even relevant?

We need the node id to create a meaning name by itself - like "ns=2;s=mydevice.door.mymethod". My best guess is that this can be done with the ".set_modelling_rule(True)" function.

This is just a very slight modification of the server_example.py from the repo.

Any help appreciated - thanks!

I have attached the the code at the boottom of this post.

What UAexpert shows this

This shows the code that i create the two methods.

#CODE server_example.py
import asyncio
import copy
import logging
from datetime import datetime
import time
from math import sin

from asyncua import ua, uamethod, Server

class SubHandler(object):

"""
Subscription Handler. To receive events from server for a subscription
"""

def datachange_notification(self, node, val, data):
    print("Python: New data change event", node, val)

def event_notification(self, event):
    print("Python: New event", event)

method to be exposed through server

def func(parent, variant):
ret = False
if variant.Value % 2 == 0:
ret = True
return [ua.Variant(ret, ua.VariantType.Boolean)]

method to be exposed through server

uses a decorator to automatically convert to and from variants

@uamethod
def multiply(parent, x, y):
print("multiply method call with parameters: ", x, y)
return x * y

async def main():
# optional: setup logging
#logger = logging.getLogger("asyncua.address_space")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.internal_server")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.binary_server_asyncio")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.uaprocessor")
# logger.setLevel(logging.DEBUG)

# now setup our server
server = Server()
await server.init()
server.disable_clock()  #for debuging
#server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/")
server.set_endpoint("opc.tcp://0.0.0.0:4841")
server.set_server_name("FreeOpcUa Example Server")
# set all possible endpoint policies for clients to connect through
server.set_security_policy([
            ua.SecurityPolicyType.NoSecurity,
            ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
            ua.SecurityPolicyType.Basic256Sha256_Sign])

# setup our own namespace
uri = "http://examples.freeopcua.github.io"
idx = await server.register_namespace(uri)

# create a new node type we can instantiate in our address space
dev = await server.nodes.base_object_type.add_object_type(idx, "MyDevice")
await (await dev.add_variable(idx, "sensor1", 1.0)).set_modelling_rule(True)
await (await dev.add_property(idx, "device_id", "0340")).set_modelling_rule(True)
ctrl = await dev.add_object(idx, "controller")
await ctrl.set_modelling_rule(True)
await (await ctrl.add_property(idx, "state", "Idle")).set_modelling_rule(True)
await (await dev.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean])).set_modelling_rule(True)

# populating our address space

# First a folder to organise our nodes
myfolder = await server.nodes.objects.add_folder(idx, "myEmptyFolder")
# instanciate one instance of our device
mydevice = await server.nodes.objects.add_object(idx, "Device0001", dev)
mydevice_var = await mydevice.get_child([f"{idx}:controller", f"{idx}:state"])  # get proxy to our device state variable
# create directly some objects and variables
myobj = await server.nodes.objects.add_object(idx, "MyObject")
myvar = await myobj.add_variable(idx, "MyVariable", 6.7)
await myvar.set_writable()    # Set MyVariable to be writable by clients
mystringvar = await myobj.add_variable(idx, "MyStringVariable", "Really nice string")
await mystringvar.set_writable()    # Set MyVariable to be writable by clients
mydtvar = await myobj.add_variable(idx, "MyDateTimeVar", datetime.utcnow())
await mydtvar.set_writable()    # Set MyVariable to be writable by clients
myarrayvar = await myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myuintvar = await myobj.add_variable(idx, "myuintvar", ua.UInt16(4))
await myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32))
await myarrayvar.set_writable(True)
myprop = await myobj.add_property(idx, "myproperty", "I am a property")
mymethod = await myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean])
multiply_node = await myobj.add_method(idx, "multiply", multiply, [ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])

#import some nodes from xml
#await server.import_xml("custom_nodes.xml")

# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = await server.get_event_generator()
myevgen.event.Severity = 300

# starting!
async with server:
    print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
    # enable following if you want to subscribe to nodes on server side
    #handler = SubHandler()
    #sub = await server.create_subscription(500, handler)
    #handle = await sub.subscribe_data_change(myvar)
    # trigger event, all subscribed clients wil receive it
    var = await myarrayvar.read_value()  # return a ref to value in db server side! not a copy!
    var = copy.copy(var)  # WARNING: we need to copy before writting again otherwise no data change event will be generated
    var.append(9.3)
    await myarrayvar.write_value(var)
    await mydevice_var.write_value("Running")
    await myevgen.trigger(message="This is BaseEvent")
    await server.write_attribute_value(myvar.nodeid, ua.DataValue(0.9))  # Server side write method which is a bit faster than using write_value
    while True:
        await asyncio.sleep(0.1)
        await server.write_attribute_value(myvar.nodeid, ua.DataValue(sin(time.time())))

if name == "main":
logging.basicConfig(level=logging.INFO)
asyncio.run(main())

[schroeder-]

The InputArguments and OutputArguments are missing the modeling rule mandatory, so they aren't instantiated.
The InputArguments and OutputArguments are used by some clients to determine which Arguments are support, so they should be present.
This fixes your problem: #939

[schroeder-]

Worked for me this is my code used in test case:

    custom_otype = await base_otype.add_object_type(2, 'ObjectWithMethodTestArgs')

    @uamethod
    def func(_parent, value):
        return value * 2
    meth = await custom_otype.add_method(ua.NodeId('ObjectWithMethodTestArgsTest', 2), ua.QualifiedName('ObjectWithMethodTestArgsTest', 2), func, [ua.VariantType.Int64], [ua.VariantType.Int64])
    await meth.set_modelling_rule(True)
    obj = await opc.opc.nodes.objects.add_object(2, 'ObjectWithMethodsArgs', custom_otype)

[dannyolsen]

Hi Schroeder,

I end up the same place - I have tried to copy your code to the best of my ability, but still no vars are showing up in the method.

Can you please provide at complete code example I can test?

Here is my code:

import asyncio
import copy
import logging
from datetime import datetime
import time
from math import sin

from asyncua import ua, uamethod, Server

@uamethod
def func(_parent, value):
    return value * 2

async def main():

    server = Server()
    await server.init()
    server.disable_clock()  #for debuging
    server.set_endpoint("opc.tcp://0.0.0.0:4840/schroeder/")
    server.set_server_name("Schroeder Server")

    server.set_security_policy([
                ua.SecurityPolicyType.NoSecurity,
                ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
                ua.SecurityPolicyType.Basic256Sha256_Sign])

    uri = "http://examples.freeopcua.github.io"
    idx = await server.register_namespace(uri)

    dev = await server.nodes.base_object_type.add_object_type(idx, "MyDevice")

    meth = await dev.add_method(ua.NodeId('ObjectWithMethodTestArgsTest', 2), ua.QualifiedName('ObjectWithMethodTestArgsTest', 2), func, [ua.VariantType.Int64], [ua.VariantType.Int64])
    await meth.set_modelling_rule(True)
    obj = await server.nodes.objects.add_object(2, 'ObjectWithMethodsArgs', dev)
    
    myevgen = await server.get_event_generator()
    myevgen.event.Severity = 300

    # starting!
    async with server:
        print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())

        await myevgen.trigger(message="This is BaseEvent")

        while True:
            await asyncio.sleep(0.1)

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    asyncio.run(main())

I get these messages when server is starting up:

INFO:asyncua.common.manage_nodes:create_method Node(NodeId(Identifier=1, NamespaceIndex=2, NodeIdType=<NodeIdType.FourByte: 1>))
INFO:asyncua.common.instantiate_util:Instantiate: Skip node without modelling rule QualifiedName(NamespaceIndex=0, Name='InputArguments') as part of QualifiedName(NamespaceIndex=2, Name='ObjectWithMethodTestArgsTest')
INFO:asyncua.common.instantiate_util:Instantiate: Skip node without modelling rule QualifiedName(NamespaceIndex=0, Name='OutputArguments') as part of QualifiedName(NamespaceIndex=2, Name='ObjectWithMethodTestArgsTest')

UAexpert shows:

[schroeder-]

I tested your code with the current master and i works:

[dannyolsen]

Hi Schroeder - That is so weird - I can not get the In Out args to show ... How come they show when you do it? I am running python 3.10.4 through anaconda. I have done the pip install . as you told me but they are still missing...

any ideas?

regards

[dannyolsen]

Hmm... seems like i had an environment issue with microsoft code... seems to work if i lauched directly from the terminal.. i can see the args now at least - thanks for testing and letting me know that my code was good :)