コード例 #1
0
        private void PublishSingleValues_UpdateItem(
            AasEventMsgEnvelope ev,
            AdminShell.ReferableRootInfo ri,
            AdminShell.KeyList startPath,
            AasPayloadUpdateValueItem ui)
        {
            // trivial
            if (ev == null || ui == null || startPath == null || ui.Path == null)
            {
                return;
            }

            // value of the leaf
            var valStr = "" + ui.Value;

            // build a complete path of keys
            var path    = startPath + ui.Path;
            var pathStr = path.BuildIdShortPath();

            // publish
            if (_diaData.LogDebug)
            {
                _logger?.Info("Publish single value (update value)");
            }
            var message = new MqttApplicationMessageBuilder()
                          .WithTopic(GenerateTopic(
                                         _diaData.EventTopic, defaultIfNull: "SingleValue",
                                         aasIdShort: ri?.AAS?.idShort, aasId: ri?.AAS?.identification,
                                         smIdShort: ri?.Submodel?.idShort, smId: ri?.Submodel?.identification,
                                         path: pathStr))
                          .WithPayload(valStr)
                          .WithExactlyOnceQoS()
                          .WithRetainFlag(_diaData.MqttRetain)
                          .Build();

            // publish
            _mqttClient.PublishAsync(message).GetAwaiter().GetResult();
            LogStatus(incSingleValue: 1);
        }
コード例 #2
0
 public void PublishEvent(AasEventMsgEnvelope ev,
                          AdminShell.ReferableRootInfo ri = null)
 {
     PublishEventAsync(ev, ri);
 }
コード例 #3
0
        public void PublishEventAsync(AasEventMsgEnvelope ev,
                                      AdminShell.ReferableRootInfo ri = null)
        {
            // access
            if (ev == null || _mqttClient == null || !_mqttClient.IsConnected)
            {
                return;
            }

            // serialize the event
            var settings = AasxIntegrationBase.AasxPluginOptionSerialization.GetDefaultJsonSettings(
                new[] { typeof(AasEventMsgEnvelope) });

            settings.TypeNameHandling = TypeNameHandling.Auto;
            settings.Formatting       = Formatting.Indented;
            var json = JsonConvert.SerializeObject(ev, settings);

            // aas / sm already available in rootInfo, prepare idShortPath
            var sourcePathStr = "";
            var sourcePath    = new AdminShell.KeyList();

            if (ev.Source?.Keys != null && ri != null && ev.Source.Keys.Count > ri.NrOfRootKeys)
            {
                sourcePath    = ev.Source.Keys.SubList(ri.NrOfRootKeys);
                sourcePathStr = sourcePath.BuildIdShortPath();
            }

            var observablePath = new AdminShell.KeyList();

            if (ev.ObservableReference?.Keys != null && ri != null &&
                ev.ObservableReference.Keys.Count > ri.NrOfRootKeys)
            {
                observablePath = ev.ObservableReference.Keys.SubList(ri.NrOfRootKeys);
            }

            // publish the full event?
            if (_diaData.EnableEventPublish)
            {
                if (_diaData.LogDebug)
                {
                    _logger?.Info("Publish Event");
                }
                var message = new MqttApplicationMessageBuilder()
                              .WithTopic(GenerateTopic(
                                             _diaData.EventTopic, defaultIfNull: "Event",
                                             aasIdShort: ri?.AAS?.idShort, aasId: ri?.AAS?.identification,
                                             smIdShort: ri?.Submodel?.idShort, smId: ri?.Submodel?.identification,
                                             path: sourcePathStr))
                              .WithPayload(json)
                              .WithExactlyOnceQoS()
                              .WithRetainFlag(_diaData.MqttRetain)
                              .Build();

                // convert to synchronous behaviour
                _mqttClient.PublishAsync(message).GetAwaiter().GetResult();
                LogStatus(incEvent: 1);
            }

            // deconstruct the event into single units?
            if (_diaData.SingleValuePublish)
            {
                if (_diaData.LogDebug)
                {
                    _logger?.Info("Publish single values ..");
                }

                if (ev.Payloads != null)
                {
                    foreach (var epl in ev.Payloads)
                    {
                        if (epl is AasPayloadStructuralChange apsc && apsc.Changes != null)
                        {
                            foreach (var ci in apsc.Changes)
                            {
                                PublishSingleValues_ChangeItem(ev, ri, observablePath, ci);
                            }
                        }

                        if (epl is AasPayloadUpdateValue apuv && apuv.Values != null)
                        {
                            foreach (var ui in apuv.Values)
                            {
                                PublishSingleValues_UpdateItem(ev, ri, observablePath, ui);
                            }
                        }
                    }
                }
            }
        }
コード例 #4
0
        private void PublishSingleValues_ChangeItem(
            AasEventMsgEnvelope ev,
            AdminShell.ReferableRootInfo ri,
            AdminShell.KeyList startPath,
            AasPayloadStructuralChangeItem ci)
        {
            // trivial
            if (ev == null || ci == null || startPath == null)
            {
                return;
            }

            // only specific reasons
            if (!(ci.Reason == AasPayloadStructuralChangeItem.ChangeReason.Create ||
                  ci.Reason == AasPayloadStructuralChangeItem.ChangeReason.Modify))
            {
                return;
            }

            // need a payload
            if (ci.Path == null || ci.Data == null)
            {
                return;
            }

            var dataRef = ci.GetDataAsReferable();

            // give this to (recursive) function
            var messages = new List <MqttApplicationMessage>();

            if (dataRef is AdminShell.SubmodelElement dataSme)
            {
                var smwc = new AdminShell.SubmodelElementWrapperCollection(dataSme);
                smwc.RecurseOnSubmodelElements(null, null, (o, parents, sme) =>
                {
                    // assumption is, the sme is now "leaf" of a SME-hierarchy
                    if (sme is AdminShell.IEnumerateChildren)
                    {
                        return;
                    }

                    // value of the leaf
                    var valStr = sme.ValueAsText();

                    // build a complete path of keys
                    var path    = startPath + ci.Path + parents.ToKeyList() + sme?.ToKey();
                    var pathStr = path.BuildIdShortPath();

                    // publish
                    if (_diaData.LogDebug)
                    {
                        _logger?.Info("Publish single value (create/ update)");
                    }
                    messages.Add(
                        new MqttApplicationMessageBuilder()
                        .WithTopic(GenerateTopic(
                                       _diaData.EventTopic, defaultIfNull: "SingleValue",
                                       aasIdShort: ri?.AAS?.idShort, aasId: ri?.AAS?.identification,
                                       smIdShort: ri?.Submodel?.idShort, smId: ri?.Submodel?.identification,
                                       path: pathStr))
                        .WithPayload(valStr)
                        .WithExactlyOnceQoS()
                        .WithRetainFlag(_diaData.MqttRetain)
                        .Build());
                });
            }

            // publish these
            // convert to synchronous behaviour
            int count = 0;

            foreach (var msg in messages)
            {
                count++;
                _mqttClient.PublishAsync(msg).GetAwaiter().GetResult();
            }
            LogStatus(incSingleValue: count);
        }