Using the CreateInstance works if the NodeSet.xml is present. It does not create optional entries though, even when I add the NodeBuilderConfiguration as shown in the CreateAlarmNode function.

the following code:

UaServer.AddressSpace.LoadModel(‘PackMLNamespace.xml’);

PackMLNodeManager := UaServer.AddressSpace.GetNodeManager(
‘http://opcfoundation.org/UA/PackML/’)
as TUaNodeManagerUaNode;

PackMLNodeManager.NodeBuilderConfiguration :=
TUaTypeDefinitionBasedNodeBuilderConfiguration.Builder
.AddOptional(‘Parameter’)
.AddOptional(‘Product’)
.AddOptional(‘MaterialInterlocked’)
.Build;

MyStatus := PackMLNodeManager.CreateInstance(TUaNodeId.Create(PackMLNodeManager.Namespace, 4), ‘Status’);
MyObjectsFolder.AddOrganizes(MyStatus);

leads to the following object being created:
https://ibb.co/dwxK492R

It’s not adding the optional elements. Guess I misread something there?

For the dynamic type creation, just using TUaObjectType will eliminate the runtime error but it does not seem to work either. The type will not be visible in the type library of the server and creating an instance just creates an empty object.

If I do this on the other hand it does work a bit but still not completely:

MyType := MyNodeManager.GetType(Id_BaseObjectType).AddSubtype(TUaNodeId.Create(MyNodeManager.Namespace, 9999), ‘MyTestType’);

// MyType := TUaObjectType.Create(MyNodeManager);
// MyType.SuperType := MyNodeManager.GetType(id_BaseObjectType);
// MyType.NodeId := TUaNodeId.Create(MyNodeManager.Namespace, 9999);

p := TUaVariable.Create(MyNodeManager);
p.Name := ‘Test’;
p.DataTypeId := Id_Int32;
p.AddReference(Id_ModellingRule_Mandatory, Id_HasModellingRule);

MyType.AddComponent(p);
MyType.AddReference(p, Id_HasComponent);

MyType.AddProperty(‘TestProperty’);

MyObj2 := MyNodeManager.CreateInstance(MyType.NodeId, ‘MyTestObj’);
MyObjectsFolder.AddOrganizes(MyObj2);

Now the Type does show up under the type definition.
https://ibb.co/4w16DCT6

But the variable under it does not, only the property is there as you can see.

And the created instance looks like this:
https://ibb.co/4ZcFF1Rv

It is missing the property and the variable.

As loading a NodeSet.xml is basically creating types at runtime too, I figured it should be possible to simulate that without a NodeSet.xml as well.

What is already working today is to simply go with a BasicObjectType and manually add all the variables and stuff I want to build the type I need, just without a dedicated type. The problem I ran into with that is if I need an array of objects it should really be an array of a specific object type instead of an array of basic objects. Otherwise the client will have a hard time figuring out how the structure actually is supposed to be.

PS: I’m on version 7.8.0 Build 881 if that has any relevance for this topic.

Greetings
Patrick

Thanks for the help, seems like I got everything I need now and can build the actual logic for the server to support PackML and custom types.

I ran into another thing now. Is it possible to create datatypes for structures dynamically as well? The example in the server (CreateDynamicStructureValue) shows how to use a type that is defined in a nodeset.xml but again I’d like to skip the NodeSet.xml and do it manually / dynamically in code.

What I got so far is the following:

MyType2 := (MyNodeManager.GetType(Id_StructureType) as TUaDataType)
.AddSubtype(TUaNodeId.Create(MyNodeManager.Namespace, 9998), ‘MyTestStruct’) as TUaDataType;

pDef := TUaDataTypeDefinition.Create;

//define the actual datatype
//?

MyType2.DataTypeDefinition := pDef;

The problem is I don’t see a way to actually define the fields in the TypeDefinition, as it seems like it only allows to read fields, but not to actually define them. Using the Builder Interface (TUaDataTypeDefinition.Builder) doesn’t seem to help either, as that again expects a definition to create the structure…

Update:

Ok, figured out how that is supposed to work. I found the VarStructureCreate function in UAVariants.

What you do is create a normal variant array and then add the type structure with VarStructureCreate(…) to each element of that array. So something like this (this example omits a couple steps but highlights the part of how to create the array of the structure type.

var
V: Variant
myStruct: IUaDynamicStructure;
begin
MyTypeVar := MyNodeManager.CreateVar(‘test’);
MyTypeVar.DataType := MyStructType2;
MyTypeVar.DataTypeID := MyStructType2.NodeID;

MyBuilder := UAServer.TypeDictionary.CreateDynamicStructureBuilder(myStructType2.NodeId);

//fill normal elements
V := VarArrayCreate([0, 1], varVariant);
for i := 0 to 2 do
begin
myStruct := CreateStructure(..); //this creates the actual structure using the Builder Interface
V[i] := VarStructureCreate(MyStruct);
end;

MyBuilder.SetFieldValue(‘Field2’, TUaVariant.Create(V));

MyTypeVar.Value := MyBuilder.Build;
end;