Handling complex types

[JaxMcCleary]

Hello lads and gents,

i am currently trying to figure out how to access variables from an S7 which are published through a opc server. The variables itself are within a root user defined structure. This user defined structure has multiple user defined structures with additional variables.
structure
I wanted to use monitoredItem and a subscription to monitor them with their node id.
The registration of the monitored items aparrently succeeds but when I change their values over another opc client (different session) the callback method (RootItemSates_Notification) won't be triggered within my client code.

        private void RegisterOpcFields()
        {
            if (IsConnected) 
            {
                try 
                {
                    var subscription = new Subscription()
                    {
                        PublishingEnabled = true,
                        PublishingInterval = 1000,
                        KeepAliveCount = 10,
                        LifetimeCount = 1000,
                        MaxNotificationsPerPublish = 1000,
                        Priority = 100,
                        TimestampsToReturn = TimestampsToReturn.Both,
                        MaxMessageCount = 10,
                        DisableMonitoredItemCache = false,
                    };
                    subscription.DisplayName = $"Subscritions";
                    CurrentSession.AddSubscription(subscription);
                    subscription.Create();
                    var lifeBitItem = new MonitoredItem();
                    MonitoredItemNotificationEventHandler lifeBitItem_Notification = new MonitoredItemNotificationEventHandler(RootItemSates_Notification);
                    lifeBitItem.StartNodeId = new NodeId($"{SPS_NAMEPSACE}.LIFE_BIT");
                    //lifeBitItem.RelativePath = $"{SPS_NAMEPSACE}.LIFE_BIT";
                    lifeBitItem.NodeClass = NodeClass.Variable;
                    //object bzw class ist 12
                    lifeBitItem.MonitoringMode = MonitoringMode.Reporting;
                    lifeBitItem.AttributeId = 13;
                    lifeBitItem.SamplingInterval = 1000;
                    lifeBitItem.Notification += lifeBitItem_Notification;


                    var labelValidationErrorItem = new MonitoredItem();
                    MonitoredItemNotificationEventHandler labelValidationErrorItem_Notification = new MonitoredItemNotificationEventHandler(RootItemSates_Notification);
                    labelValidationErrorItem.StartNodeId = new NodeId($"{SPS_NAMEPSACE}.LabelValidationError");
                    //labelValidationErrorItem.RelativePath = $"{SPS_NAMEPSACE}.LabelValidationError";
                    labelValidationErrorItem.NodeClass = NodeClass.Variable;
                    //object bzw class ist 12
                    labelValidationErrorItem.MonitoringMode = MonitoringMode.Reporting;
                    labelValidationErrorItem.AttributeId = 13;
                    labelValidationErrorItem.SamplingInterval = 1000;
                    labelValidationErrorItem.Notification += labelValidationErrorItem_Notification;


                    var printerNotInUseItem = new MonitoredItem();
                    MonitoredItemNotificationEventHandler printerNotInUseItem_Notification = new MonitoredItemNotificationEventHandler(RootItemSates_Notification);
                    printerNotInUseItem.StartNodeId = new NodeId($"{SPS_NAMEPSACE}.PRINTER_NOT_IN_USE");
                    //printerNotInUseItem.RelativePath = $"{SPS_NAMEPSACE}.PRINTER_NOT_IN_USE";
                    printerNotInUseItem.NodeClass = NodeClass.Variable;
                    //object bzw class ist 12
                    printerNotInUseItem.AttributeId = 13;
                    printerNotInUseItem.SamplingInterval = 1000;
                    printerNotInUseItem.Notification += printerNotInUseItem_Notification;


                    var mesNotInUseItem = new MonitoredItem();
                    MonitoredItemNotificationEventHandler mesNotInUseItem_Notification = new MonitoredItemNotificationEventHandler(RootItemSates_Notification);
                    mesNotInUseItem.StartNodeId = new NodeId($"{SPS_NAMEPSACE}.MES_not_in_use");
                    //mesNotInUseItem.RelativePath = $"{SPS_NAMEPSACE}.MES_not_in_use";
                    mesNotInUseItem.NodeClass = NodeClass.Variable;
                    //object bzw class ist 12
                    mesNotInUseItem.AttributeId = 13;
                    mesNotInUseItem.SamplingInterval = 1000;
                    mesNotInUseItem.Notification += mesNotInUseItem_Notification;

                    RegisterMESToSPSStructures(subscription);
                    RegisterSPSToMESStructures(subscription);


                    subscription.AddItem(lifeBitItem);
                    subscription.AddItem(labelValidationErrorItem);
                    subscription.AddItem(printerNotInUseItem);
                    subscription.AddItem(mesNotInUseItem);

                    //subscription.AddItem(monitoredItem);

                    if (ServiceResult.IsBad(lifeBitItem.Status.Error))
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Error registering monitoredItem {lifeBitItem.RelativePath}: {lifeBitItem.Status.Error.ToString()}");
                    }
                    if (ServiceResult.IsBad(labelValidationErrorItem.Status.Error))
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Error registering monitoredItem {labelValidationErrorItem.RelativePath}: {labelValidationErrorItem.Status.Error.ToString()}");
                    }
                    if (ServiceResult.IsBad(printerNotInUseItem.Status.Error))
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Error registering monitoredItem {printerNotInUseItem.RelativePath}: {printerNotInUseItem.Status.Error.ToString()}");
                    }
                    if (ServiceResult.IsBad(mesNotInUseItem.Status.Error))
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Error registering monitoredItem {mesNotInUseItem.RelativePath}: {mesNotInUseItem.Status.Error.ToString()}");
                    }
                    subscription.ApplyChanges();
                    //subscription.ResolveItemNodeIds();
                }
                catch(Exception ex) 
                {
                    _logger.Error($"{MethodInfo.GetCurrentMethod().Name}:{ex.Message}");
                    throw ex;
                }
            }
        }

The callback for the monitored items look like this.

        private void RootItemSates_Notification(Opc.Ua.Client.MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
        {
            try 
            {
                if (monitoredItem != null && monitoredItem.StartNodeId != null &&!string.IsNullOrEmpty(monitoredItem.StartNodeId.Identifier?.ToString()??null)) 
                {
                    //var dataType = OpcClientUtils.GetDataType(monitoredItem.StartNodeId, CurrentSession);
                    MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
                    _logger.Info($"{MethodInfo.GetCurrentMethod().Name}:Node: {monitoredItem.StartNodeId.Identifier} Value({notification.Value?.WrappedValue.Value ?? string.Empty})");

                    var data = notification.Value.WrappedValue.Value;

                    if (monitoredItem.StartNodeId.Identifier.ToString().ToLower().Contains(nameof(LIFE_BIT).ToLower())) 
                    {
                        if (data != null) 
                        {
                            LIFE_BIT = (bool)data;
                            _logger.Info($"{DateTime.UtcNow.ToString()} - Field {monitoredItem.StartNodeId.Identifier.ToString()} change detected: {data.ToString()}");
                        }
                        else 
                        {
                            LIFE_BIT = false;
                        }
                        if (!LIFE_BIT) 
                        {
                            if (!WriteValue($"{SPS_NAMEPSACE}.LIFE_BIT", true)) 
                            {
                                _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Unable to set the LIFE_BIT to true.");
                            }
                        }
                    }
                    else if (monitoredItem.StartNodeId.Identifier.ToString().ToLower().Contains(nameof(PRINTER_NOT_IN_USE).ToLower()))
                    {
                        if (data != null)
                        {
                            PRINTER_NOT_IN_USE = (bool)data;
                            _logger.Info($"{DateTime.UtcNow.ToString()} - Field {monitoredItem.StartNodeId.Identifier.ToString()} change detected: {data.ToString()}");
                        }
                        else
                        {
                            PRINTER_NOT_IN_USE = false;
                        }
                    }
                    else if (monitoredItem.StartNodeId.Identifier.ToString().ToLower().Contains(nameof(LabelValidationError).ToLower()))
                    {
                        if (data != null)
                        {
                            LabelValidationError = (bool)data;
                            _logger.Info($"{DateTime.UtcNow.ToString()} - Field {monitoredItem.StartNodeId.Identifier.ToString()} change detected: {data.ToString()}");
                        }
                        else
                        {
                            LabelValidationError = false;
                        }
                    }
                    else if (monitoredItem.StartNodeId.Identifier.ToString().ToLower().Contains(nameof(MES_NOT_IN_USE).ToLower()))
                    {
                        if (data != null)
                        {
                            MES_NOT_IN_USE = (bool)data;
                            _logger.Info($"{DateTime.UtcNow.ToString()} - Field {monitoredItem.StartNodeId.Identifier.ToString()} change detected: {data.ToString()}");
                        }
                        else
                        {
                            MES_NOT_IN_USE = false;
                        }
                    }
                }

                
            }
            catch(Exception ex) 
            {
                _logger.Error($"{MethodInfo.GetCurrentMethod().Name}:{ex.Message} ({monitoredItem.StartNodeId.Identifier})");
            }

        }

It works fine when I use it for variables that are not defined within user defined structures.
Do i have to define a monitored Item for the entire User Defined Structure?

I also tried to read and write variables within those user defined structures:

        public object ReadValue(string nodeId, Type expectedType)
        {
            try
            {
                Check.ArgumentNullOrEmtpy(nodeId, "The paramter can't be null in order to write values to sps.");
                if (IsConnected)
                {
                    var monitoredItem = FindItemInSubscriptionByNodeId(nodeId);
                    if (monitoredItem != null)
                    {
                        ReadValueIdCollection nodesToRead = new ReadValueIdCollection();

                        ReadValueId nodeToRead = new ReadValueId();
                        nodeToRead.NodeId = monitoredItem.StartNodeId;
                        nodeToRead.AttributeId = Attributes.Value;
                        nodesToRead.Add(nodeToRead);

                        nodeToRead = new ReadValueId();
                        nodeToRead.NodeId = monitoredItem.StartNodeId;
                        nodeToRead.AttributeId = Attributes.DataType;
                        nodesToRead.Add(nodeToRead);

                        nodeToRead = new ReadValueId();
                        nodeToRead.NodeId = monitoredItem.StartNodeId;
                        nodeToRead.AttributeId = Attributes.ValueRank;
                        nodesToRead.Add(nodeToRead);

                        // start the browse operation.
                        DataValueCollection results = null;
                        DiagnosticInfoCollection diagnosticInfos = null;

                        CurrentSession.Read(
                            null,
                            0,
                            TimestampsToReturn.Neither,
                            nodesToRead,
                            out results,
                            out diagnosticInfos);

                        ClientBase.ValidateResponse(results, nodesToRead);
                        ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);

                        foreach (var rs in results) 
                        {
                            //results[ii].GetValue(expectedType);
                            if (rs.Value != null) 
                            {
                                _logger.Info($"Code: { rs.StatusCode.Code.ToString() } Value:{ rs.Value}");
                            }
                        }
                    }
                    else
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Unable to find the matching monitored item for node id {nodeId}");
                    }
                }
                else
                {
                    _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: No active connection. Connection required to write values.");
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"{MethodInfo.GetCurrentMethod().Name}:{ex.Message}");
            }
            return null;
        }

I don't get an exception while reading but the DataValueCollection has zero entries. Which should not be the case since there are values in those variables.

        public bool WriteValue(string nodeId, object value) 
        {
            var result = false;

            try 
            {
                var builder = new StringBuilder();
                Check.ArgumentNullOrEmtpy(nodeId, "The paramter can't be null in order to write values to sps.");
                if (IsConnected) 
                {
                    var monitoredItem = FindItemInSubscriptionByNodeId(nodeId);
                    if (monitoredItem != null) 
                    {
                        WriteValue valueToWrite = new WriteValue();

                        valueToWrite.NodeId = monitoredItem.StartNodeId;
                        valueToWrite.AttributeId = monitoredItem.AttributeId;
                        valueToWrite.Value.Value = value;
                        valueToWrite.Value.StatusCode = StatusCodes.Good;
                        valueToWrite.Value.ServerTimestamp = DateTime.UtcNow;
                        valueToWrite.Value.SourceTimestamp = DateTime.UtcNow;
                        WriteValueCollection valuesToWrite = new WriteValueCollection();
                        valuesToWrite.Add(valueToWrite);

                        // write current value.
                        StatusCodeCollection results = null;
                        DiagnosticInfoCollection diagnosticInfos = null;

                        CurrentSession.Write(
                            null,
                            valuesToWrite,
                            out results,
                            out diagnosticInfos);

                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: StatusCodeCollection: { JsonConvert.SerializeObject(results) }");
                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: WriteValueCollection: {JsonConvert.SerializeObject(valuesToWrite)}");
                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: DiagnosticInfoCollection: {JsonConvert.SerializeObject(diagnosticInfos)}");


                        ClientBase.ValidateResponse(results, valuesToWrite);
                        ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);

                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: StatusCodeCollection: {JsonConvert.SerializeObject(results)}");
                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: WriteValueCollection: {JsonConvert.SerializeObject(valuesToWrite)}");
                        builder.AppendLine($"{MethodInfo.GetCurrentMethod().Name}: DiagnosticInfoCollection: {JsonConvert.SerializeObject(diagnosticInfos)}");


                        _logger.Info(builder.ToString());

                        if (StatusCode.IsBad(results[0]))
                        {
                            throw new ServiceResultException(results[0]);
                        }
                        else
                        {
                            result = true;
                        }
                    }
                    else 
                    {
                        _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: Unable to find the matching monitored item for node id { nodeId }");
                    }

                }
                else 
                {
                    _logger.Error($"{MethodInfo.GetCurrentMethod().Name}: No active connection. Connection required to write values.");
                }
            }
            catch(Exception ex) 
            {
                _logger.Error($"{MethodInfo.GetCurrentMethod().Name}:{ex.Message}");
            }
            return result;
        }

If I try to write into the variables within the structure I run into an exception:

2023-03-10 00:59:24.8397 7 ERROR - WriteValue:BadConfigurationError

I have searched for quiet some time. Sadly there are not many results for user defined structures with the OPCFoundation library. Especially if you want to monitore them.

#243

I have seen this issue. But in the sample he is reading a function and also he is not monitoring them.