ModbusUnitNode.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking.Modbus;
using Waher.Networking.Modbus.Exceptions;
using Waher.Networking.XMPP.Sensor;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
using Waher.Things.Metering;
using Waher.Things.SensorData;
 
namespace Waher.Things.Modbus
{
    public enum UnitReadMode
    {
        ReadRegisters,
 
        ReadChildren
    }
 
    public class ModbusUnitNode : ProvisionedMeteringNode, ISensor
    {
        public ModbusUnitNode()
            : base()
        {
            this.MaxCoilNr = 65535;
            this.MaxDiscreteInputNr = 65535;
            this.MaxHoldingRegisterNr = 65535;
            this.MaxInputRegisterNr = 65535;
            this.ReadMode = UnitReadMode.ReadRegisters;
        }
 
        [Page(4, "Modbus", 100)]
        [Header(5, "Unit Address:")]
        [ToolTip(6, "Unit ID on the Modbus network.")]
        [Range(0, 255)]
        [Required]
        public int UnitId { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(30, "Minimum coil number:")]
        [ToolTip(31, "Smallest coil number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(0)]
        public int MinCoilNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(32, "Maximum coil number:")]
        [ToolTip(33, "Largest coil number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(65535)]
        public int MaxCoilNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(34, "Minimum discrete input number:")]
        [ToolTip(35, "Smallest discrete input number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(0)]
        public int MinDiscreteInputNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(36, "Maximum discrete input number:")]
        [ToolTip(37, "Largest discrete input number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(65535)]
        public int MaxDiscreteInputNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(38, "Minimum input register number:")]
        [ToolTip(39, "Smallest input register number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(0)]
        public int MinInputRegisterNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(40, "Maximum input register number:")]
        [ToolTip(41, "Largest input register number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(65535)]
        public int MaxInputRegisterNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(42, "Minimum holding register number:")]
        [ToolTip(43, "Smallest holding register number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(0)]
        public int MinHoldingRegisterNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(44, "Maximum holding register number:")]
        [ToolTip(45, "Largest holding register number accepted by the device.")]
        [Range(0, 65535)]
        [DefaultValue(65535)]
        public int MaxHoldingRegisterNr { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(46, "Switch byte order.")]
        [ToolTip(47, "If checked, byte order in registers will be reversed.")]
        [DefaultValue(false)]
        public bool SwitchByteOrder { get; set; }
 
        [Page(4, "Modbus", 100)]
        [Header(60, "Sensor-Data Read Mode:")]
        [ToolTip(61, "How the unit should handle sensor-data requests.")]
        [DefaultValue(UnitReadMode.ReadRegisters)]
        [Option(UnitReadMode.ReadRegisters, 62, "Read and report Modbus registers raw.")]
        [Option(UnitReadMode.ReadChildren, 63, "Read child nodes.")]
        public UnitReadMode ReadMode { get; set; }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ModbusGatewayNode), 2, "Modbus Unit");
        }
 
        public override async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList<Parameter>;
 
            Result.AddLast(new Int32Parameter("Address", await Language.GetStringAsync(typeof(ModbusGatewayNode), 7, "Address"), this.UnitId));
 
            return Result;
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is ModbusGatewayNode);
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ModbusUnitChildNode);
        }
 
        public async Task<ModbusGatewayNode> GetGateway()
        {
            if (await this.GetParent() is ModbusGatewayNode GatewayNode)
                return GatewayNode;
            else
                throw new Exception("Modbus Gateway node not found.");
        }
 
        public Task StartReadout(ISensorReadout Request)
        {
            switch (this.ReadMode)
            {
                case UnitReadMode.ReadRegisters:
                    return this.StartReadoutOfRegisters(Request);
 
                case UnitReadMode.ReadChildren:
                    return this.StartReadoutOfChildren(Request);
 
                default:
                    Request.ReportErrors(true, new ThingError(this, "Unrecognized read mode."));
                    return Task.CompletedTask;
            }
        }
 
        private async Task StartReadoutOfRegisters(ISensorReadout Request)
        {
            ModbusGatewayNode Gateway = await this.GetGateway();
            ModbusTcpClient Client = await Gateway.GetTcpIpConnection();
            await Client.Enter();
            try
            {
                LinkedList<Field> Fields = new LinkedList<Field>();
                DateTime TP = DateTime.UtcNow;
                int Offset = this.MinInputRegisterNr;
                int StepSize = 64;
                int i;
 
                while ((StepSize = Math.Min(StepSize, this.MaxInputRegisterNr - Offset + 1)) > 0 && Offset <= this.MaxInputRegisterNr)
                {
                    try
                    {
                        ushort[] Values = await Client.ReadInputRegisters((byte)this.UnitId, (ushort)Offset, (ushort)StepSize);
                        StepSize = Math.Min(StepSize, Values.Length);
 
                        for (i = 0; i < StepSize; i++)
                            Fields.AddLast(new Int32Field(this, TP, "Input Register 3" + (Offset + i).ToString("D5"),
                                ModbusUnitHoldingRegisterNode.CheckOrder(this.SwitchByteOrder, Values[i]), FieldType.Momentary, FieldQoS.AutomaticReadout));
 
                        await Request.ReportFields(false, Fields);
                        Fields.Clear();
                        Offset += StepSize;
                    }
                    catch (ModbusException)
                    {
                        StepSize >>= 1;
                    }
                }
 
                Offset = this.MinHoldingRegisterNr;
                StepSize = 64;
 
                while ((StepSize = Math.Min(StepSize, this.MaxHoldingRegisterNr - Offset + 1)) > 0 && Offset <= this.MaxHoldingRegisterNr)
                {
                    try
                    {
                        ushort[] Values = await Client.ReadMultipleRegisters((byte)this.UnitId, (ushort)Offset, (ushort)StepSize);
                        StepSize = Math.Min(StepSize, Values.Length);
 
                        for (i = 0; i < StepSize; i++)
                        {
                            Fields.AddLast(new Int32Field(this, TP, "Holding Register 4" + (Offset + i).ToString("D5"),
                                ModbusUnitHoldingRegisterNode.CheckOrder(this.SwitchByteOrder, Values[i]), FieldType.Momentary, FieldQoS.AutomaticReadout));
                        }
 
                        await Request.ReportFields(false, Fields);
                        Fields.Clear();
                        Offset += StepSize;
                    }
                    catch (ModbusException)
                    {
                        StepSize >>= 1;
                    }
                }
 
                Offset = this.MinCoilNr;
                StepSize = 256;
 
                while ((StepSize = Math.Min(StepSize, this.MaxCoilNr - Offset + 1)) > 0 && Offset <= this.MaxCoilNr)
                {
                    try
                    {
                        BitArray Bits = await Client.ReadCoils((byte)this.UnitId, (ushort)Offset, (ushort)StepSize);
                        StepSize = Math.Min(StepSize, Bits.Length);
 
                        for (i = 0; i < StepSize; i++)
                            Fields.AddLast(new BooleanField(this, TP, "Coil 0" + (Offset + i).ToString("D5"), Bits[i], FieldType.Momentary, FieldQoS.AutomaticReadout));
 
                        await Request.ReportFields(false, Fields);
                        Fields.Clear();
                        Offset += StepSize;
                    }
                    catch (ModbusException)
                    {
                        StepSize >>= 1;
                    }
                }
 
                Offset = this.MinDiscreteInputNr;
                StepSize = 256;
 
                while ((StepSize = Math.Min(StepSize, this.MaxDiscreteInputNr - Offset + 1)) > 0 && Offset <= this.MaxDiscreteInputNr)
                {
                    try
                    {
                        BitArray Bits = await Client.ReadInputDiscretes((byte)this.UnitId, (ushort)Offset, (ushort)StepSize);
                        StepSize = Math.Min(StepSize, Bits.Length);
 
                        for (i = 0; i < StepSize; i++)
                            Fields.AddLast(new BooleanField(this, TP, "Discrete Input 1" + (Offset + i).ToString("D5"), Bits[i], FieldType.Momentary, FieldQoS.AutomaticReadout));
 
                        await Request.ReportFields(false, Fields);
                        Fields.Clear();
                        Offset += StepSize;
                    }
                    catch (ModbusException)
                    {
                        StepSize >>= 1;
                    }
                }
 
                await Request.ReportFields(true);
            }
            catch (Exception ex)
            {
                await Request.ReportErrors(true, new ThingError(this, ex.Message));
            }
            finally
            {
                await Client.Leave();
            }
        }
 
        private async Task StartReadoutOfChildren(ISensorReadout Request)
        {
            foreach (INode Child in await this.ChildNodes)
            {
                if (Child is ISensor Sensor)
                {
                    TaskCompletionSource<bool> ReadoutCompleted = new TaskCompletionSource<bool>();
 
                    InternalReadoutRequest InternalReadout = new InternalReadoutRequest(this.LogId, null, Request.Types, Request.FieldNames,
                        Request.From, Request.To,
                        (Sender, e) =>
                        {
                            Request.ReportFields(false, e.Fields);
 
                            if (e.Done)
                                ReadoutCompleted.TrySetResult(true);
 
                            return Task.CompletedTask;
                        },
                        (Sender, e) =>
                        {
                            if (!(e.Errors is ThingError[] Errors))
                            {
                                List<ThingError> List = new List<ThingError>();
 
                                foreach (ThingError Error in e.Errors)
                                    List.Add(Error);
 
                                Errors = List.ToArray();
                            }
 
                            Request.ReportErrors(false, Errors);
 
                            if (e.Done)
                                ReadoutCompleted.TrySetResult(true);
 
                            return Task.CompletedTask;
                        }, null);
 
                    await Sensor.StartReadout(InternalReadout);
 
                    Task Timeout = Task.Delay(60000);
 
                    Task T = await Task.WhenAny(ReadoutCompleted.Task, Timeout);
 
                    if (ReadoutCompleted.Task.IsCompleted)
                        await Request.ReportFields(true);
                    else
                        await Request.ReportErrors(true, new ThingError(this, "Timeout."));
                }
            }
        }
 
    }
}