EMOS-TestApp/TestApp/EnergyManager.cs

using MQTTnet;
using MQTTnet.Client;
using System.Collections.Immutable;

namespace TestApp
{
    internal class EnergyManager
    {
        private MqttFactory _MqttFactory;
        private IMqttClient _MqttClient;

        private ImmutableDictionary<ulong, ulong> _CurrentValues = ImmutableDictionary<ulong, ulong>.Empty;

        private EnergyManager()
        {
            _MqttFactory= new MqttFactory();
            _MqttClient = _MqttFactory.CreateMqttClient();
        }

        public static async Task<EnergyManager> Create()
        {
            var ret = new EnergyManager();
            await ret.Connect();
            return ret;
        }

        private async Task Connect() {
            var clientOptions = new MqttClientOptionsBuilder()
                .WithTcpServer("localhost")
                .Build();

            await _MqttClient.ConnectAsync(clientOptions);

            _MqttClient.ApplicationMessageReceivedAsync += Client_ApplicationMessageReceivedAsync;

            var subscribeOptions = _MqttFactory.CreateSubscribeOptionsBuilder()
                .WithTopicFilter(
                    f => {
                        f.WithTopic("gdr/local/values/smart-meter");
                    }
                )
                .Build();

            var response = await _MqttClient.SubscribeAsync(subscribeOptions);
        }

        private Task Client_ApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs arg)
        {
            switch (arg.ApplicationMessage.Topic)
            {
                case "gdr/local/values/smart-meter":
                    ParseGDRs(arg.ApplicationMessage.Payload);
                    break;
            }

            return Task.CompletedTask;
        }

        private void ParseGDRs(byte[] payload)
        {
            var gdrs = GDRs.Parser.ParseFrom(payload);

            if (!gdrs.GDRs_.TryGetValue("smart-meter", out GDR smartMeterGDR))
            {
                return;
            }

            _CurrentValues = smartMeterGDR.Values.ToImmutableDictionary();
        }

        private double GetValue(ulong obisCode, double factor)
        {
            if (!_CurrentValues.TryGetValue(obisCode, out ulong value))
            {
                return double.NaN;
            }

            return factor * value;
        }

        public (double I1, double I2, double I3) GetCurrents() {
            return (
                GetValue(EMVariable.CurrentL1),
                GetValue(EMVariable.CurrentL2),
                GetValue(EMVariable.CurrentL3)
            );
        }

        public double GetValue(EMVariable variable) {
            return variable switch {
                EMVariable.ActivePowerPositive => GetValue(1099528667391UL, 0.001),
                EMVariable.ActiveEnergyPositive => GetValue(1099528929535UL, 0.001),
                EMVariable.ActivePowerNegative => GetValue(1099545444607UL, 0.001),
                EMVariable.ActiveEnergyNegative => GetValue(1099545706751UL, 0.001),
                EMVariable.ReactivePowerPositive => GetValue(1099562221823UL, 0.001),
                EMVariable.ReactiveEnergyPositive => GetValue(1099562483967UL, 0.001),
                EMVariable.ReactivePowerNegative => GetValue(1099578999039UL, 0.001),
                EMVariable.ReactiveEnergyNegative => GetValue(1099579261183UL, 0.001),
                EMVariable.ApparentPowerPositive => GetValue(1099662885119UL, 0.001),
                EMVariable.ApparentEnergyPositive => GetValue(1099663147263UL, 0.001),
                EMVariable.ApparentPowerNegative => GetValue(1099679662335UL, 0.001),
                EMVariable.ApparentEnergyNegative => GetValue(1099679924479UL, 0.001),
                EMVariable.PowerFactor => GetValue(1099729993983UL, 0.001),
                EMVariable.SupplyFrequency => GetValue(1099746771199UL, 0.001),
                EMVariable.ActivePowerPositiveL1 => GetValue(1099864211711UL, 0.001),
                EMVariable.ActiveEnergyPositiveL1 => GetValue(1099864473855UL, 0.001),
                EMVariable.ActivePowerNegativeL1 => GetValue(1099880988927UL, 0.001),
                EMVariable.ActiveEnergyNegativeL1 => GetValue(1099881251071UL, 0.001),
                EMVariable.ReactivePowerPositiveL1 => GetValue(1099897766143UL, 0.001),
                EMVariable.ReactiveEnergyPositiveL1 => GetValue(1099898028287UL, 0.001),
                EMVariable.ReactivePowerNegativeL1 => GetValue(1099914543359UL, 0.001),
                EMVariable.ReactiveEnergyNegativeL1 => GetValue(1099914805503UL, 0.001),
                EMVariable.ApparentPowerPositiveL1 => GetValue(1099998429439UL, 0.001),
                EMVariable.ApparentEnergyPositiveL1 => GetValue(1099998691583UL, 0.001),
                EMVariable.ApparentPowerNegativeL1 => GetValue(1100015206655UL, 0.001),
                EMVariable.ApparentEnergyNegativeL1 => GetValue(1100015468799UL, 0.001),
                EMVariable.CurrentL1 => GetValue(1100031983871UL, 0.001),
                EMVariable.VoltageL1 => GetValue(1100048761087UL, 0.001),
                EMVariable.PowerFactorL1 => GetValue(1100065538303UL, 0.001),
                EMVariable.ActivePowerPositiveL2 => GetValue(1100199756031UL, 0.001),
                EMVariable.ActiveEnergyPositiveL2 => GetValue(1100200018175UL, 0.001),
                EMVariable.ActivePowerNegativeL2 => GetValue(1100216533247UL, 0.001),
                EMVariable.ActiveEnergyNegativeL2 => GetValue(1100216795391UL, 0.001),
                EMVariable.ReactivePowerPositiveL2 => GetValue(1100233310463UL, 0.001),
                EMVariable.ReactiveEnergyPositiveL2 => GetValue(1100233572607UL, 0.001),
                EMVariable.ReactivePowerNegativeL2 => GetValue(1100250087679UL, 0.001),
                EMVariable.ReactiveEnergyNegativeL2 => GetValue(1100250349823UL, 0.001),
                EMVariable.ApparentPowerPositiveL2 => GetValue(1100333973759UL, 0.001),
                EMVariable.ApparentEnergyPositiveL2 => GetValue(1100334235903UL, 0.001),
                EMVariable.ApparentPowerNegativeL2 => GetValue(1100350750975UL, 0.001),
                EMVariable.ApparentEnergyNegativeL2 => GetValue(1100351013119UL, 0.001),
                EMVariable.CurrentL2 => GetValue(1100367528191UL, 0.001),
                EMVariable.VoltageL2 => GetValue(1100384305407UL, 0.001),
                EMVariable.PowerFactorL2 => GetValue(1100401082623UL, 0.001),
                EMVariable.ActivePowerPositiveL3 => GetValue(1100535300351UL, 0.001),
                EMVariable.ActiveEnergyPositiveL3 => GetValue(1100535562495UL, 0.001),
                EMVariable.ActivePowerNegativeL3 => GetValue(1100552077567UL, 0.001),
                EMVariable.ActiveEnergyNegativeL3 => GetValue(1100552339711UL, 0.001),
                EMVariable.ReactivePowerPositiveL3 => GetValue(1100568854783UL, 0.001),
                EMVariable.ReactiveEnergyPositiveL3 => GetValue(1100569116927UL, 0.001),
                EMVariable.ReactivePowerNegativeL3 => GetValue(1100585631999UL, 0.001),
                EMVariable.ReactiveEnergyNegativeL3 => GetValue(1100585894143UL, 0.001),
                EMVariable.ApparentPowerPositiveL3 => GetValue(1100669518079UL, 0.001),
                EMVariable.ApparentEnergyPositiveL3 => GetValue(1100669780223UL, 0.001),
                EMVariable.ApparentPowerNegativeL3 => GetValue(1100686295295UL, 0.001),
                EMVariable.ApparentEnergyNegativeL3 => GetValue(1100686557439UL, 0.001),
                EMVariable.CurrentL3 => GetValue(1100703072511UL, 0.001),
                EMVariable.VoltageL3 => GetValue(1100719849727UL, 0.001),
                EMVariable.PowerFactorL3 => GetValue(1100736626943UL, 0.001),
                _ => double.NaN,
            };
        }

    }
}