node-opcua-address-space 2.51.0

package/test_helpers/create_minimalist_address_space_nodeset.ts

@@ -0,0 +1,208 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:no-console
+// tslint:disable:max-line-length
+
+import * as chalk from "chalk";
+import { assert } from "node-opcua-assert";
+import { DataTypeIds, ObjectIds, ObjectTypeIds, ReferenceTypeIds, VariableTypeIds } from "node-opcua-constants";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+
+import { AddReferenceOpts, AddressSpace, UAFolder, UAObject, UAReferenceType, UAVariableType, NamespacePrivate } from "..";
+
+const doDebug = false;
+
+function dumpReferencesHierarchy(_addressSpace: AddressSpace) {
+    const addressSpace = _addressSpace;
+
+    function _dump(referenceType: UAReferenceType, level: string) {
+        console.log(
+            level,
+            referenceType.browseName.toString(),
+            "(",
+            chalk.green(
+                referenceType
+                    .getAllSubtypes()
+                    .map((x: any) => x.browseName.toString())
+                    .join(" ")
+            ),
+            ")"
+        );
+
+        const subTypes = referenceType.findReferencesExAsObject("HasSubtype");
+        for (const subType of subTypes) {
+            _dump(subType as UAReferenceType, "     " + level);
+        }
+    }
+
+    const references = addressSpace.findReferenceType(ReferenceTypeIds.References)!;
+
+    _dump(references, " ");
+}
+
+export function create_minimalist_address_space_nodeset(addressSpace: AddressSpace) {
+
+    const _addressSpace = addressSpace;
+
+    const namespace0 = addressSpace.registerNamespace("http://opcfoundation.org/UA/") as unknown as  NamespacePrivate;
+
+    assert(namespace0.index === 0);
+
+    function addReferenceType(browseName_: string, isAbstract?: boolean, subtypeOf?: UAReferenceType): UAReferenceType {
+        const tmp = browseName_.split("/");
+        const inverseName = tmp[1] as string;
+        const browseName = tmp[0] as string;
+
+        const options = {
+            browseName,
+            inverseName,
+            isAbstract,
+            nodeClass: NodeClass.ReferenceType,
+            nodeId: resolveNodeId((ReferenceTypeIds as any)[browseName]),
+            references: [] as AddReferenceOpts[],
+            subtypeOf
+        };
+
+        const hasSubType = resolveNodeId("HasSubtype");
+        if (subtypeOf) {
+            options.references.push({
+                isForward: false,
+                nodeId: subtypeOf.nodeId,
+                referenceType: hasSubType
+            });
+        }
+        const node = namespace0.internalCreateNode(options);
+
+        node.propagate_back_references();
+
+        return node as UAReferenceType;
+    }
+
+    // add references
+    {
+        // before we do any thing , we need to create the HasSubtype reference
+        // which is required in the first to create the hierachy of References
+        const hasSubtype = addReferenceType("HasSubtype/HasSupertype");
+
+        const references = addReferenceType("References", true);
+        {
+            const nonHierarchicalReferences = addReferenceType("NonHierarchicalReferences", true, references);
+            {
+                const hasTypeDefinition = addReferenceType("HasTypeDefinition/TypeDefinitionOf", false, nonHierarchicalReferences);
+                const hasModellingRule = addReferenceType("HasModellingRule/ModellingRuleOf", false, nonHierarchicalReferences);
+                const hasEncoding = addReferenceType("HasEncoding/EncodingOf", false, nonHierarchicalReferences);
+            }
+        }
+        {
+            const hierarchicalReferences = addReferenceType("HierarchicalReferences", true, references);
+            {
+                const hasChild = addReferenceType("HasChild/ChildOf", true, hierarchicalReferences);
+                {
+                    const aggregates = addReferenceType("Aggregates/AggregatedBy", true, hasChild);
+                    {
+                        const hasComponent = addReferenceType("HasComponent/ComponentOf", false, aggregates);
+                        const hasProperty = addReferenceType("HasProperty/PropertyOf", false, aggregates);
+                        const hasHistoricalConfiguration = addReferenceType(
+                            "HasHistoricalConfiguration/HistoricalConfigurationOf",
+                            false,
+                            aggregates
+                        );
+                    }
+                }
+                {
+                    // add a link to hasSubType
+                    hasSubtype.addReference({
+                        isForward: false,
+                        nodeId: hasChild,
+                        referenceType: hasSubtype
+                    });
+                }
+            }
+            {
+                const organizes = addReferenceType("Organizes/OrganizedBy", false, hierarchicalReferences);
+            }
+            {
+                const hasEventSource = addReferenceType("HasEventSource/EventSourceOf", false, hierarchicalReferences);
+            }
+        }
+    }
+
+    if (doDebug) {
+        dumpReferencesHierarchy(addressSpace);
+    }
+
+    const baseObjectType = namespace0.internalCreateNode({
+        browseName: "BaseObjectType",
+        isAbstract: true,
+        nodeClass: NodeClass.ObjectType,
+        nodeId: resolveNodeId(ObjectTypeIds.BaseObjectType)
+    });
+
+    const baseVariableType = (namespace0.internalCreateNode({
+        browseName: "BaseVariableType",
+        isAbstract: true,
+        nodeClass: NodeClass.VariableType,
+        nodeId: resolveNodeId(VariableTypeIds.BaseVariableType)
+    }) as any) as UAVariableType;
+
+    const propertyType = namespace0.addVariableType({
+        browseName: "PropertyType",
+        subtypeOf: baseVariableType
+    });
+
+    const baseDataVariableType = (namespace0.internalCreateNode({
+        browseName: "BaseDataVariableType",
+        isAbstract: true,
+        nodeClass: NodeClass.VariableType,
+        nodeId: resolveNodeId(VariableTypeIds.BaseDataVariableType),
+        subtypeOf: baseVariableType.nodeId
+    }) as any) as UAVariableType;
+
+    const modellingRule_Optional = (namespace0.internalCreateNode({
+        browseName: "Optional",
+        nodeClass: NodeClass.Object,
+        nodeId: resolveNodeId(ObjectIds.ModellingRule_Optional)
+    }) as any) as UAObject;
+
+    const modellingRule_Mandatory = (namespace0.internalCreateNode({
+        browseName: "Mandatory",
+        nodeClass: NodeClass.Object,
+        nodeId: resolveNodeId(ObjectIds.ModellingRule_Mandatory)
+    }) as any) as UAObject;
+
+    // add the root folder
+    {
+        const rootFolder = (namespace0.internalCreateNode({
+            browseName: "RootFolder",
+            nodeClass: NodeClass.Object,
+            nodeId: resolveNodeId(ObjectIds.RootFolder)
+        }) as any) as UAObject;
+
+        {
+            const objectsFolder = namespace0.addObject({
+                browseName: "Objects",
+                nodeId: resolveNodeId(ObjectIds.ObjectsFolder),
+                organizedBy: rootFolder
+            });
+
+            assert(rootFolder.getFolderElementByName("Objects")!.browseName.toString() === "Objects");
+        }
+        {
+            const dataTypeFolder = namespace0.addObject({
+                browseName: "DataType",
+                nodeId: resolveNodeId(ObjectIds.DataTypesFolder),
+                organizedBy: rootFolder
+            });
+            {
+                const doubleDataType = namespace0.internalCreateNode({
+                    browseName: "Double",
+                    nodeClass: NodeClass.DataType,
+                    nodeId: resolveNodeId(DataTypeIds.Double),
+                    organizedBy: dataTypeFolder
+                });
+            }
+        }
+    }
+}

package/test_helpers/dump_statemachine.ts

@@ -0,0 +1,155 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:no-console
+/*
+ * class Node {
+ *     { browseName: "string", nodeId: NodeId}
+ * }
+ * Transition {
+ *     browseName: "String"
+ *     fromState: Node
+ *     toState: Node
+ * }
+ * class SateMachineType {
+ *    initialState: Node
+ *    states: [ Node,Node, ...]
+ *    transitions: [Transition]
+ * }
+ * @param stateMachineType
+ */
+import { BaseNode, UAState, UAStateMachineEx, UATransition, UAObject, UATransitionEx } from "..";
+
+export function dumpStateMachineToPlantUML(stateMachineType: UAStateMachineEx) {
+    function w(str: string) {
+        console.log(str);
+    }
+
+    function s(state: BaseNode) {
+        return state.nodeId.value.toString();
+    }
+
+    function n(state: BaseNode) {
+        return state.browseName.name!.toString();
+    }
+
+    w("@startuml "); // + stateMachineType.browseName.toString() + ".png");
+    // initial state if any
+
+    if (stateMachineType.initialState) {
+        w(" [*] --> " + s(stateMachineType.initialState));
+        w(" " + s(stateMachineType.initialState) + ":" + n(stateMachineType.initialState));
+    } else {
+        w("[*] --> [*]");
+    }
+
+    function t(transition: BaseNode) {
+        let name = n(transition);
+        name = name.replace(":", "");
+        name = name.replace("To", "\\nTo\\n");
+        name = name.replace("Transition", "\\nTransition");
+        return name;
+    }
+
+    stateMachineType.states.forEach((state: UAObject) => w(" " + s(state) + ": " + n(state)));
+
+    stateMachineType.transitions.forEach((transition: UATransitionEx) =>
+        w("  " + s(transition.fromStateNode!) + " --> " + s(transition.toStateNode!) + " : " + t(transition))
+    );
+
+    w("@enduml");
+}
+
+/*
+ @startuml
+
+ 2930: Unshelved
+
+ 2932: TimedShelved
+
+ 2933: OneShotShelved
+
+ 2930 --> 2932 :   "2935\nUnshelvedToTimedShelved"
+
+ 2930 --> 2933 :   "2936\nUnshelvedToOneShotShelved"
+
+ 2932 --> 2930 :   "2940\nTimedShelvedToUnshelved"
+
+ 2932 --> 2933 :   "2942\nTimedShelvedToOneShotShelved"
+
+ 2933 --> 2930 :   "2943\nOneShotShelvedToUnshelved"
+
+ 2933 --> 2932 :   "2945\nOneShotShelvedToTimedShelved"
+
+ @enduml
+
+ */
+
+/*
+ digraph finite_state_machine {
+ rankdir=LR;
+ size="8,5"
+ node [shape = doublecircle]; LR_0 LR_3 LR_4 LR_8;
+ node [shape = circle];
+ LR_0 -> LR_2 [ label = "SS(B)" ];
+ LR_0 -> LR_1 [ label = "SS(S)" ];
+ LR_1 -> LR_3 [ label = "S($end)" ];
+ LR_2 -> LR_6 [ label = "SS(b)" ];
+ LR_2 -> LR_5 [ label = "SS(a)" ];
+ LR_2 -> LR_4 [ label = "S(A)" ];
+ LR_5 -> LR_7 [ label = "S(b)" ];
+ LR_5 -> LR_5 [ label = "S(a)" ];
+ LR_6 -> LR_6 [ label = "S(b)" ];
+ LR_6 -> LR_5 [ label = "S(a)" ];
+ LR_7 -> LR_8 [ label = "S(b)" ];
+ LR_7 -> LR_5 [ label = "S(a)" ];
+ LR_8 -> LR_6 [ label = "S(b)" ];
+ LR_8 -> LR_5 [ label = "S(a)" ];
+ }
+ */
+export function dumpStateMachineToGraphViz(
+    /*StateMachineProxy*/
+    stateMachineType: UAStateMachineEx
+) {
+    function w(str: string) {
+        console.log(str);
+    }
+
+    function s(state: BaseNode) {
+        return state.nodeId.value.toString();
+    }
+
+    function n(state: BaseNode) {
+        return state.browseName.name!.toString();
+    }
+
+    function s_full(state: BaseNode) {
+        return s(state) + ' [ label = "' + n(state) + '" ]';
+    }
+
+    w("digraph finite_state_machine {");
+    // initial state if any
+
+    if (stateMachineType.initialState) {
+        w("node [ shape = doublecircle];");
+        w("  _" + s_full(stateMachineType.initialState!) + " ;");
+    }
+    w("node [ shape = circle];");
+    stateMachineType.states.forEach((state: UAState) => w("   _" + s_full(state)));
+
+    stateMachineType.transitions.forEach((transition) =>
+        w(
+            "  _" +
+                s(transition.fromStateNode!) +
+                " -> _" +
+                s(transition.toStateNode!) +
+                " [ " +
+                //   " labeltooltip = \"" + i(transition) + "\" " +
+                ', label = "' +
+                n(transition) +
+                '" ];'
+        )
+    );
+
+    w("}");
+}

package/test_helpers/get_address_space_fixture.ts

@@ -0,0 +1,30 @@
+/**
+ * @module node-opcua-address-space
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+export function getAddressSpaceFixture(pathname: string) {
+    // find test_fixtures
+
+    let folder = path.join(__dirname, "./test_fixtures");
+    if (!fs.existsSync(folder)) {
+        folder = path.join(__dirname, "../test_helpers/test_fixtures");
+        if (!fs.existsSync(folder)) {
+            folder = path.join(__dirname, "../../test_helpers/test_fixtures");
+
+            // istanbul ignore next
+            if (!fs.existsSync(folder)) {
+                // tslint:disable:no-console
+                console.log(" cannot find test_fixtures folder ");
+            }
+        }
+    }
+    const filename = path.join(folder, pathname);
+
+    // istanbul ignore next
+    if (!fs.existsSync(filename)) {
+        throw new Error(" cannot find fixture with name " + pathname);
+    }
+    return filename;
+}

package/test_helpers/get_mini_address_space.ts

@@ -0,0 +1,42 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+
+import { AddressSpace } from "..";
+import { generateAddressSpace } from "../nodeJS";
+
+import { getAddressSpaceFixture } from "./get_address_space_fixture";
+
+export const mini_nodeset = "mini.Node.Set2.xml";
+export const empty_nodeset = "fixture_empty_nodeset2.xml";
+
+export const get_mini_nodeset_filename = () => getAddressSpaceFixture(mini_nodeset);
+export const get_empty_nodeset_filename = () => getAddressSpaceFixture(empty_nodeset);
+
+// tslint:disable:no-var-requires
+// tslint:disable:max-line-length
+const thenify = require("thenify");
+
+export function getMiniAddressSpace(callback: (err: Error | null, addressSpace?: AddressSpace) => void): void;
+export function getMiniAddressSpace(): Promise<AddressSpace>;
+export function getMiniAddressSpace(...args: any[]): any {
+    const callback = args[0] as (err: Error | null, addressSpace?: AddressSpace) => void;
+
+    const addressSpace = AddressSpace.create();
+
+    // register namespace 1 (our namespace);
+    const serverNamespace = addressSpace.registerNamespace("http://MYNAMESPACE");
+    assert(serverNamespace.index === 1);
+
+    generateAddressSpace(addressSpace, get_mini_nodeset_filename(), (err?: Error) => {
+        // istanbul ignore next
+        if (err) {
+            // tslint:disable:no-console
+            console.log("err =", err);
+        }
+        callback(err || null, addressSpace);
+    });
+}
+
+(module.exports as any).getMiniAddressSpace = thenify.withCallback((module.exports as any).getMiniAddressSpace);

package/test_helpers/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @module node-opcua-address-space
+ */
+export * from "./add_event_generator_object";
+export * from "./alarms_and_conditions_demo";
+export * from "./assertHasMatchingReference";
+export * from "./create_minimalist_address_space_nodeset";
+export * from "./dump_statemachine";
+export * from "./get_address_space_fixture";
+export * from "./get_mini_address_space";
+export * from "./boiler_system";

package/test_helpers/test_fixtures/dataType_in_separateNamespace.xml

@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<UANodeSet xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" LastModified="2019-05-01T00:00:00Z" 
+    xmlns="http://opcfoundation.org/UA/2011/03/UANodeSet.xsd">
+    <NamespaceUris>
+        <Uri>http://opcfoundation.org/UA/DI/</Uri>
+    </NamespaceUris>
+    <Models>
+        <Model ModelUri="http://opcfoundation.org/UA/DI/" Version="1.02" PublicationDate="2019-05-01T00:00:00Z">
+            <RequiredModel ModelUri="http://opcfoundation.org/UA/" Version="1.04.4" PublicationDate="2020-01-08T00:00:00Z" />
+        </Model>
+    </Models>
+    <Aliases>
+        <Alias Alias="Boolean">i=1</Alias>
+        <Alias Alias="SByte">i=2</Alias>
+        <Alias Alias="Byte">i=3</Alias>
+        <Alias Alias="Int16">i=4</Alias>
+        <Alias Alias="UInt16">i=5</Alias>
+        <Alias Alias="Int32">i=6</Alias>
+        <Alias Alias="UInt32">i=7</Alias>
+        <Alias Alias="Int64">i=8</Alias>
+        <Alias Alias="UInt64">i=9</Alias>
+        <Alias Alias="Float">i=10</Alias>
+        <Alias Alias="Double">i=11</Alias>
+        <Alias Alias="DateTime">i=13</Alias>
+        <Alias Alias="String">i=12</Alias>
+        <Alias Alias="ByteString">i=15</Alias>
+        <Alias Alias="Guid">i=14</Alias>
+        <Alias Alias="XmlElement">i=16</Alias>
+        <Alias Alias="NodeId">i=17</Alias>
+        <Alias Alias="ExpandedNodeId">i=18</Alias>
+        <Alias Alias="QualifiedName">i=20</Alias>
+        <Alias Alias="LocalizedText">i=21</Alias>
+        <Alias Alias="StatusCode">i=19</Alias>
+        <Alias Alias="Structure">i=22</Alias>
+        <Alias Alias="Number">i=26</Alias>
+        <Alias Alias="Integer">i=27</Alias>
+        <Alias Alias="UInteger">i=28</Alias>
+        <Alias Alias="HasComponent">i=47</Alias>
+        <Alias Alias="HasProperty">i=46</Alias>
+        <Alias Alias="Organizes">i=35</Alias>
+        <Alias Alias="HasEventSource">i=36</Alias>
+        <Alias Alias="HasNotifier">i=48</Alias>
+        <Alias Alias="HasSubtype">i=45</Alias>
+        <Alias Alias="HasTypeDefinition">i=40</Alias>
+        <Alias Alias="HasModellingRule">i=37</Alias>
+        <Alias Alias="HasEncoding">i=38</Alias>
+        <Alias Alias="HasDescription">i=39</Alias>
+    </Aliases>
+    <UADataType NodeId="ns=1;i=6522" BrowseName="1:FetchResultDataType" IsAbstract="true">
+        <DisplayName>FetchResultDataType</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">i=22</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=6525" BrowseName="1:ParameterResultDataType">
+        <DisplayName>ParameterResultDataType</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">i=22</Reference>
+        </References>
+        <Definition Name="1:ParameterResultDataType">
+            <Field Name="NodePath" DataType="i=20" ValueRank="1" />
+            <Field Name="StatusCode" DataType="i=19" />
+            <Field Name="Diagnostics" DataType="i=25" />
+        </Definition>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=15889" BrowseName="1:TransferResultDataDataType">
+        <DisplayName>TransferResultDataDataType</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">ns=1;i=6522</Reference>
+        </References>
+        <Definition Name="1:TransferResultDataDataType">
+            <Field Name="SequenceNumber" DataType="i=6" />
+            <Field Name="EndOfResults" DataType="i=1" />
+            <Field Name="ParameterDefs" DataType="ns=1;i=6525" ValueRank="1" />
+        </Definition>
+    </UADataType>
+    <!-- A -->
+    <UAObject NodeId="ns=1;i=6554" BrowseName="Default Binary" SymbolicName="DefaultBinary">
+        <DisplayName>Default Binary</DisplayName>
+        <References>
+            <Reference ReferenceType="HasEncoding" IsForward="false">ns=1;i=6525</Reference>
+            <Reference ReferenceType="HasDescription">ns=1;i=6564</Reference>
+            <Reference ReferenceType="HasTypeDefinition">i=76</Reference>
+        </References>
+    </UAObject>
+    <UAVariable NodeId="ns=1;i=6564" BrowseName="1:ParameterResultDataType" ParentNodeId="ns=1;i=6435" DataType="String">
+        <DisplayName>ParameterResultDataType</DisplayName>
+        <References>
+            <Reference ReferenceType="HasTypeDefinition">i=69</Reference>
+            <Reference ReferenceType="HasComponent" IsForward="false">ns=1;i=6435</Reference>
+        </References>
+        <Value>
+            <String xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">ParameterResultDataType</String>
+        </Value>
+    </UAVariable>
+    <!-- B-->
+    <UAObject NodeId="ns=1;i=15892" BrowseName="Default Binary" SymbolicName="DefaultBinary">
+        <DisplayName>Default Binary</DisplayName>
+        <References>
+            <Reference ReferenceType="HasEncoding" IsForward="false">ns=1;i=15889</Reference>
+            <Reference ReferenceType="HasDescription">ns=1;i=15897</Reference>
+            <Reference ReferenceType="HasTypeDefinition">i=76</Reference>
+        </References>
+    </UAObject>
+    <UAVariable NodeId="ns=1;i=15897" BrowseName="1:TransferResultDataDataType" ParentNodeId="ns=1;i=6435" DataType="String">
+        <DisplayName>TransferResultDataDataType</DisplayName>
+        <References>
+            <Reference ReferenceType="HasTypeDefinition">i=69</Reference>
+            <Reference ReferenceType="HasComponent" IsForward="false">ns=1;i=6435</Reference>
+        </References>
+        <Value>
+            <String xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">TransferResultDataDataType</String>
+        </Value>
+    </UAVariable>
+    <!-- C -->
+    <UAVariable NodeId="ns=1;i=6435" BrowseName="1:Opc.Ua.Di" SymbolicName="OpcUaDi_BinarySchema" DataType="ByteString">
+        <DisplayName>Opc.Ua.Di</DisplayName>
+        <References>
+            <Reference ReferenceType="HasProperty">ns=1;i=6437</Reference>
+            <Reference ReferenceType="HasProperty">ns=1;i=15893</Reference>
+
+            <Reference ReferenceType="HasComponent">ns=1;i=15897</Reference>
+            <Reference ReferenceType="HasComponent">ns=1;i=6564</Reference>
+            <Reference ReferenceType="HasComponent" IsForward="false">i=93</Reference>
+            <Reference ReferenceType="HasTypeDefinition">i=72</Reference>
+        </References>
+        <Value/>
+    </UAVariable>
+    <UAVariable NodeId="ns=1;i=6437" BrowseName="NamespaceUri" ParentNodeId="ns=1;i=6435" DataType="String">
+        <DisplayName>NamespaceUri</DisplayName>
+        <References>
+            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
+            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=6435</Reference>
+        </References>
+        <Value>
+            <String xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">http://opcfoundation.org/UA/DI/</String>
+        </Value>
+    </UAVariable>
+    <UAVariable NodeId="ns=1;i=15893" BrowseName="Deprecated" ParentNodeId="ns=1;i=6435" DataType="Boolean">
+        <DisplayName>Deprecated</DisplayName>
+        <References>
+            <Reference ReferenceType="HasTypeDefinition">i=68</Reference>
+            <Reference ReferenceType="HasProperty" IsForward="false">ns=1;i=6435</Reference>
+        </References>
+        <Value>
+            <Boolean xmlns="http://opcfoundation.org/UA/2008/02/Types.xsd">true</Boolean>
+        </Value>
+    </UAVariable>
+</UANodeSet>

package/test_helpers/test_fixtures/dataType_in_separateNamespace_basic.xml

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<UANodeSet xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" LastModified="2019-05-01T00:00:00Z" 
+    xmlns="http://opcfoundation.org/UA/2011/03/UANodeSet.xsd">
+    <NamespaceUris>
+        <Uri>urn:MyNamespace/</Uri>
+    </NamespaceUris>
+    <Models>
+        <Model ModelUri="urn:MyNamespace/" Version="1.02" PublicationDate="2019-05-01T00:00:00Z">
+            <RequiredModel ModelUri="http://opcfoundation.org/UA/" Version="1.04.4" PublicationDate="2020-01-08T00:00:00Z" />
+        </Model>
+    </Models>
+    <Aliases>
+        <Alias Alias="Boolean">i=1</Alias>
+        <Alias Alias="SByte">i=2</Alias>
+        <Alias Alias="Byte">i=3</Alias>
+        <Alias Alias="UInt16">i=5</Alias>
+    </Aliases>
+    <UADataType NodeId="ns=1;i=3065" BrowseName="1:ANY">
+        <DisplayName>ANY</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">i=3</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=3066" BrowseName="1:REMOTE">
+        <DisplayName>REMOTE</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">ns=1;i=3065</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=3036" BrowseName="1:HW_SUBMODULE">
+        <DisplayName>HW_SUBMODULE</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">ns=1;i=3034</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=3058" BrowseName="1:PORT">
+        <DisplayName>PORT</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">ns=1;i=3036</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=3034" BrowseName="1:HW_IO">
+        <DisplayName>HW_IO</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">ns=1;i=3024</Reference>
+        </References>
+    </UADataType>
+    <UADataType NodeId="ns=1;i=3024" BrowseName="1:HW_ANY">
+        <DisplayName>HW_ANY</DisplayName>
+        <References>
+            <Reference ReferenceType="HasSubtype" IsForward="false">i=5</Reference>
+        </References>
+    </UADataType>
+</UANodeSet>
+
+