Need help registering custom codec

[JessevGool]

I'm trying to read 2 custom data types, one of them is embedded into the other
This is the UDT_IdentificationData:

This is a UDT_SemVer:

I looked at the example code and made the following classes

package org.example;

import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import org.eclipse.milo.opcua.stack.core.UaSerializationException;
import org.eclipse.milo.opcua.stack.core.serialization.SerializationContext;
import org.eclipse.milo.opcua.stack.core.serialization.UaDecoder;
import org.eclipse.milo.opcua.stack.core.serialization.UaEncoder;
import org.eclipse.milo.opcua.stack.core.serialization.UaStructure;
import org.eclipse.milo.opcua.stack.core.serialization.codecs.GenericDataTypeCodec;
import org.eclipse.milo.opcua.stack.core.types.builtin.ExpandedNodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.UInteger;

import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;

public class UDT_IdentificationData implements UaStructure {

    public static final ExpandedNodeId TYPE_ID = ExpandedNodeId.parse(String.format(
            "nsu=%s;s=%s",
            "http://www.siemens.com/simatic-s7-opcua",
            "TE_\"UDT_IdentificationData\""
    ));

    public static final ExpandedNodeId BINARY_ENCODING_ID = ExpandedNodeId.parse(String.format(
            "nsu=%s;s=%s",
            "http://www.siemens.com/simatic-s7-opcua",
            "TE_\"UDT_IdentificationData\".BinaryEncoding"
    ));

    private final UInteger serialNumber;
    private final UInteger moduleType;
    private final UInteger vendorId;
    private final UDT_SemVer softwareVersion;
    private final UDT_SemVer electricalVersion;
    private final UDT_SemVer mechanicalVersion;

    public UDT_IdentificationData() {
        this(uint(0), uint(0), uint(0), new UDT_SemVer(), new UDT_SemVer(), new UDT_SemVer());
    }

    public UDT_IdentificationData(
            UInteger serialNumber,
            UInteger moduleType,
            UInteger vendorId,
            UDT_SemVer softwareVersion,
            UDT_SemVer electricalVersion,
            UDT_SemVer mechanicalVersion
    ) {
        this.serialNumber = serialNumber;
        this.moduleType = moduleType;
        this.vendorId = vendorId;
        this.softwareVersion = softwareVersion;
        this.electricalVersion = electricalVersion;
        this.mechanicalVersion = mechanicalVersion;
    }

    public UInteger getSerialNumber() {
        return serialNumber;
    }

    public UInteger getModuleType() {
        return moduleType;
    }

    public UInteger getVendorId() {
        return vendorId;
    }

    public UDT_SemVer getSoftwareVersion() {
        return softwareVersion;
    }

    public UDT_SemVer getElectricalVersion() {
        return electricalVersion;
    }

    public UDT_SemVer getMechanicalVersion() {
        return mechanicalVersion;
    }

    @Override
    public ExpandedNodeId getTypeId() {
        return TYPE_ID;
    }

    @Override
    public ExpandedNodeId getBinaryEncodingId() {
        return BINARY_ENCODING_ID;
    }

    @Override
    public ExpandedNodeId getXmlEncodingId() {
        // XML encoding not supported
        return ExpandedNodeId.NULL_VALUE;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UDT_IdentificationData that = (UDT_IdentificationData) o;
        return Objects.equal(serialNumber, that.serialNumber) &&
                Objects.equal(moduleType, that.moduleType) &&
                Objects.equal(vendorId, that.vendorId) &&
                Objects.equal(softwareVersion, that.softwareVersion) &&
                Objects.equal(electricalVersion, that.electricalVersion) &&
                Objects.equal(mechanicalVersion, that.mechanicalVersion);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(serialNumber, moduleType, vendorId, softwareVersion, electricalVersion, mechanicalVersion);
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("serialNumber", serialNumber)
                .add("moduleType", moduleType)
                .add("vendorId", vendorId)
                .add("softwareVersion", softwareVersion)
                .add("electricalVersion", electricalVersion)
                .add("mechanicalVersion", mechanicalVersion)
                .toString();
    }

    public static class Codec extends GenericDataTypeCodec<UDT_IdentificationData> {
        @Override
        public Class<UDT_IdentificationData> getType() {
            return UDT_IdentificationData.class;
        }

        @Override
        public UDT_IdentificationData decode(
                SerializationContext context,
                UaDecoder decoder
        ) throws UaSerializationException {

            UInteger serialNumber = decoder.readUInt32("SerialNumber");
            UInteger moduleType = decoder.readUInt32("ModuleType");
            UInteger vendorId = decoder.readUInt32("VendorId");
            UDT_SemVer softwareVersion = (UDT_SemVer) decoder.readStruct("SoftwareVersion", UDT_SemVer.TYPE_ID);
            UDT_SemVer electricalVersion = (UDT_SemVer) decoder.readStruct("ElectricalVersion", UDT_SemVer.TYPE_ID);
            UDT_SemVer mechanicalVersion = (UDT_SemVer) decoder.readStruct("MechanicalVersion", UDT_SemVer.TYPE_ID);

            return new UDT_IdentificationData(serialNumber, moduleType, vendorId, softwareVersion, electricalVersion, mechanicalVersion);
        }

        @Override
        public void encode(
                SerializationContext context,
                UaEncoder encoder, UDT_IdentificationData value
        ) throws UaSerializationException {

            encoder.writeUInt32("SerialNumber", value.serialNumber);
            encoder.writeUInt32("ModuleType", value.moduleType);
            encoder.writeUInt32("VendorId", value.vendorId);
            encoder.writeStruct("SoftwareVersion", value.softwareVersion, UDT_SemVer.TYPE_ID);
            encoder.writeStruct("ElectricalVersion", value.electricalVersion, UDT_SemVer.TYPE_ID);
            encoder.writeStruct("MechanicalVersion", value.mechanicalVersion, UDT_SemVer.TYPE_ID);
        }
    }

}

package org.example;

import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import org.eclipse.milo.opcua.stack.core.UaSerializationException;
import org.eclipse.milo.opcua.stack.core.serialization.SerializationContext;
import org.eclipse.milo.opcua.stack.core.serialization.UaDecoder;
import org.eclipse.milo.opcua.stack.core.serialization.UaEncoder;
import org.eclipse.milo.opcua.stack.core.serialization.UaStructure;
import org.eclipse.milo.opcua.stack.core.serialization.codecs.GenericDataTypeCodec;
import org.eclipse.milo.opcua.stack.core.types.builtin.ExpandedNodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.UInteger;

import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;

public class UDT_SemVer implements UaStructure {

    public static final ExpandedNodeId TYPE_ID = ExpandedNodeId.parse(String.format(
            "nsu=%s;s=%s",
            "http://www.siemens.com/simatic-s7-opcua",
            "TE_\"UDT_SemVer\""
    ));

    public static final ExpandedNodeId BINARY_ENCODING_ID = ExpandedNodeId.parse(String.format(
            "nsu=%s;s=%s",
            "http://www.siemens.com/simatic-s7-opcua",
            "TE_\"UDT_SemVer\".BinaryEncoding"
    ));

    private final UInteger major;
    private final UInteger minor;
    private final UInteger patch;

    public UDT_SemVer() {
        this(uint(0), uint(0), uint(0));
    }

    public UDT_SemVer(UInteger major, UInteger minor, UInteger patch) {
        this.major = major;
        this.minor = minor;
        this.patch = patch;
    }

    public UInteger getMajor() {
        return major;
    }

    public UInteger getMinor() {
        return minor;
    }

    public UInteger getPatch() {
        return patch;
    }

    @Override
    public ExpandedNodeId getTypeId() {
        return TYPE_ID;
    }

    @Override
    public ExpandedNodeId getBinaryEncodingId() {
        return BINARY_ENCODING_ID;
    }

    @Override
    public ExpandedNodeId getXmlEncodingId() {
        // XML encoding not supported
        return ExpandedNodeId.NULL_VALUE;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UDT_SemVer that = (UDT_SemVer) o;
        return Objects.equal(major, that.major) &&
                Objects.equal(minor, that.minor) &&
                Objects.equal(patch, that.patch);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(major, minor, patch);
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("major", major)
                .add("minor", minor)
                .add("patch", patch)
                .toString();
    }

    public static class Codec extends GenericDataTypeCodec<UDT_SemVer> {
        @Override
        public Class<UDT_SemVer> getType() {
            return UDT_SemVer.class;
        }

        @Override
        public UDT_SemVer decode(
                SerializationContext context,
                UaDecoder decoder
        ) throws UaSerializationException {

            UInteger major = decoder.readUInt32("major");
            UInteger minor = decoder.readUInt32("minor");
            UInteger patch = decoder.readUInt32("patch");

            return new UDT_SemVer(major, minor, patch);
        }

        @Override
        public void encode(
                SerializationContext context,
                UaEncoder encoder, UDT_SemVer value
        ) throws UaSerializationException {

            encoder.writeUInt32("major", value.major);
            encoder.writeUInt32("minor", value.minor);
            encoder.writeUInt32("patch", value.patch);
        }
    }

}

I'm registering them as follows:

private static void registerCustomCodec(OpcUaClient client) {
        NodeId dataTypeId_SemVer = UDT_SemVer.TYPE_ID
                .toNodeId(client.getNamespaceTable())
                .orElseThrow(() -> new IllegalStateException("namespace not found"));

        NodeId binaryEncodingId_SemVer = UDT_SemVer.BINARY_ENCODING_ID
                .toNodeId(client.getNamespaceTable())
                .orElseThrow(() -> new IllegalStateException("namespace not found"));

        // Register codec with the client's DataTypeManager instance.
        // We need to register it by both its encodingId and its dataTypeId because it may be
        // looked up by either depending on the context.

        client.getStaticDataTypeManager().registerCodec(
                binaryEncodingId_SemVer,
                new UDT_SemVer.Codec().asBinaryCodec()
        );

        client.getStaticDataTypeManager().registerCodec(
                new QualifiedName(dataTypeId_SemVer.getNamespaceIndex(), "UDT_SemVer"),
                dataTypeId_SemVer,
                new UDT_SemVer.Codec().asBinaryCodec()
        );


        // Register UDT_IdentificationData codec
        NodeId dataTypeId = UDT_IdentificationData.TYPE_ID
                .toNodeId(client.getNamespaceTable())
                .orElseThrow(() -> new IllegalStateException("namespace not found"));
        NodeId binaryEncodingId = UDT_IdentificationData.BINARY_ENCODING_ID
                .toNodeId(client.getNamespaceTable())
                .orElseThrow(() -> new IllegalStateException("namespace not found"));

        client.getStaticDataTypeManager().registerCodec(
                binaryEncodingId,
                new UDT_IdentificationData.Codec().asBinaryCodec()
        );
        client.getStaticDataTypeManager().registerCodec(
                new QualifiedName(dataTypeId.getNamespaceIndex(), "UDT_IdentificationData"),
                dataTypeId,
                new UDT_IdentificationData.Codec().asBinaryCodec()
        );
}

I'm reading them as follows:

           registerCustomCodec(client);

           UaVariableNode node = client.getAddressSpace().getVariableNode(
            NodeId.parse("ns=3;s=\"H35dispenser\".\"ID\"")
            );

            System.out.printf("DataType=%s%n", node.getDataType());

            // Read the current value
            DataValue value = node.readValue();
            System.out.printf("Value=%s%n", value);

            Variant variant = value.getValue();
            ExtensionObject xo = (ExtensionObject) variant.getValue();
            UDT_IdentificationData decoded = (UDT_IdentificationData) xo.decode(
                    client.getStaticSerializationContext()
            );
            System.out.printf("Decoded=%s%n", decoded);

Which gives me the following output

DataType=NodeId{ns=3, id=DT_"UDT_IdentificationData"}
Value=DataValue{value=Variant{value=ExtensionObject{encoded=ByteString{bytes=[-94, 15, 0, 0, 4, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]}, encodingId=NodeId{ns=3, id=TE_"UDT_IdentificationData"}}}, status=StatusCode{name=Good, value=0x00000000, quality=good}, sourceTime=DateTime{utcTime=133753651966745068, javaDate=Wed Nov 06 12:13:16 CET 2024}, serverTime=DateTime{utcTime=133753651966745068, javaDate=Wed Nov 06 12:13:16 CET 2024}}
org.eclipse.milo.opcua.stack.core.UaSerializationException: no codec registered for encodingId=NodeId{ns=3, id=TE_"UDT_IdentificationData"}

What am I doing wrong here?

[kevinherron]

public static final ExpandedNodeId TYPE_ID = ExpandedNodeId.parse(String.format(
        "nsu=%s;s=%s",
        "http://www.siemens.com/simatic-s7-opcua",
        "TE_\"UDT_IdentificationData\""
));


public static final ExpandedNodeId BINARY_ENCODING_ID = ExpandedNodeId.parse(String.format(
        "nsu=%s;s=%s",
        "http://www.siemens.com/simatic-s7-opcua",
        "TE_\"UDT_IdentificationData\".BinaryEncoding"
));

You've copied the convention used in the examples, which is fine when you are defining your own types for use in a server implementation, but in this case have to use exactly the NodeIds used by the server you are connecting to.

The error suggests the encoding id is actually ns=3, id=TE_"UDT_IdentificationData", which you seem to have used for the DataType id.

According to your screenshots the DataType id is actually something else.

Manually coding structures in your client that are dynamically defined by the server isn't really one of the intentions. You should be letting the client read the datatype dictionary or DataTypeDefinition attribute (available in dev/1.0 branch) and decoding them dynamically.

See:

• https://github.com/eclipse/milo/blob/master/milo-examples/client-examples/src/main/java/org/eclipse/milo/examples/client/UnifiedAutomationReadCustomDataTypeExample.java
• https://github.com/eclipse/milo/blob/dev/1.0/milo-examples/client-examples/src/main/java/org/eclipse/milo/examples/client/UnifiedAutomationReadCustomDataTypeExample1.java