ModbusCompositeChildNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking.XMPP.Sensor;
using Waher.Runtime.Language;
using Waher.Things.ControlParameters;
using Waher.Things.SensorData;
 
namespace Waher.Things.Modbus
{
    public class ModbusCompositeChildNode : ModbusUnitChildNode, ISensor, IActuator
    {
        public ModbusCompositeChildNode()
            : base()
        {
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ModbusGatewayNode), 28, "Composite Node");
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is ModbusUnitNode);
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ModbusUnitChildNode);
        }
 
        public async Task StartReadout(ISensorReadout Request)
        {
            try
            {
                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) =>
                            {
                                foreach (Field F in e.Fields)
                                    F.Thing = this;
 
                                Request.ReportFields(false, e.Fields);
 
                                if (e.Done)
                                    ReadoutCompleted.TrySetResult(true);
 
                                return Task.CompletedTask;
                            },
                            (Sender, e) =>
                            {
                                List<ThingError> Errors2 = new List<ThingError>();
 
                                foreach (ThingError Error in e.Errors)
                                    Errors2.Add(new ThingError(this, Error.ErrorMessage));
 
                                Request.ReportErrors(false, Errors2.ToArray());
 
                                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.ReportErrors(false, new ThingError(this, "Timeout."));
                    }
                }
            }
            catch (Exception ex)
            {
                await Request.ReportErrors(false, new ThingError(this, ex.Message));
            }
            finally
            {
                await Request.ReportFields(true);
            }
        }
 
        public async Task<ControlParameter[]> GetControlParameters()
        {
            List<ControlParameter> Result = new List<ControlParameter>();
 
            foreach (INode Child in await this.ChildNodes)
            {
                if (Child is IActuator Actuator)
                    Result.AddRange(await Actuator.GetControlParameters());
            }
 
            return Result.ToArray();
        }
 
    }
}