FCC/Devices/Sensors/PressureGage_3051/SensorGroupHandler.cs

using Edge.Core.Processor;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using PressureGage_3051.MessageEntity;
using Edge.Core.Processor.Dispatcher.Attributes;
using Edge.Core.Processor.Communicator;

namespace PressureGage_3051
{
    [MetaPartsRequired(typeof(HalfDuplexActivePollingDeviceProcessor<,>))]
    [MetaPartsRequired(typeof(ComPortCommunicator<>))]
    [MetaPartsRequired(typeof(TcpClientCommunicator<>))]
    [MetaPartsDescriptor(
        "lang-zh-cn:麦克智能压力变送器lang-zh-tw:麥克智能壓力變送器lang-en-us:PressureGageGroup",
        "lang-zh-cn:用于驱动 Modbus 协议的压力变送器组lang-zh-tw:用於驅動 Modbus 協議的壓力變送器組lang-en-us:Used for driven Pressure Gage Group which use Modbus Protocol",
        new[] { "lang-zh-cn:传感器lang-zh-tw:傳感器lang-en-us:Sensor" })]
    public class SensorGroupHandler : TestableActivePollingDeviceHandler<byte[], MessageBase>
    {
        private IContext<byte[], MessageBase> context;
        private ILogger logger = null;
        private readonly List<SensorHandler> sensorHandlerList = new List<SensorHandler>();
        private int sensorHandlerIndex = 0;

        public List<SensorHandler> SensorHandlerList
        {
            get
            {
                return sensorHandlerList;
            }
        }

        public class SensorGroupConfiguration
        {
            public string DeviceAddressList { get; set; }
        }

        [ParamsJsonSchemas("PressureGageGroupParamsJsonSchemas")]
        public SensorGroupHandler(SensorGroupConfiguration config, IServiceProvider services)
        {
            if (services != null)
            {
                var loggerFactory = services.GetRequiredService<ILoggerFactory>();
                logger = loggerFactory.CreateLogger("DynamicPrivate_PressureGage");
            }

            var deviceAddressArray = config.DeviceAddressList.Split(';', StringSplitOptions.RemoveEmptyEntries);
            logger.LogInformation($"SensorGroupHandler will create {deviceAddressArray.Length} sensor handlers for pressure gage Group from local config");
            CreateSensorHandlers(deviceAddressArray);
        }

        private void CreateSensorHandlers(string[] deviceAddressArray)
        {
            foreach (string deviceAddress in deviceAddressArray)
            {
                var sensorHandler = new SensorHandler(Convert.ToByte(deviceAddress), logger);
                sensorHandlerList.Add(sensorHandler);
            }
        }

        public override void Init(IContext<byte[], MessageBase> context)
        {
            base.Init(context);
            this.context = context;

            context.Communicator.OnConnected += async (_, __) =>
            {
                logger.LogInformation($"SensorGroupHandler Connected to COM port");
                await Task.CompletedTask;
            };

            foreach (var handler in sensorHandlerList)
            {
                handler.Init(context);
            }

            var timeWindowWithActivePollingOutgoing = this.context.Outgoing as TimeWindowWithActivePollingOutgoing<byte[], MessageBase>;
            timeWindowWithActivePollingOutgoing.PollingMsgProducer = () =>
            {
                var sensorHandler = sensorHandlerList[sensorHandlerIndex++];
                sensorHandlerIndex = sensorHandlerIndex < sensorHandlerList.Count ? sensorHandlerIndex : 0;

                return sensorHandler.GetRequestMessage();
            };
        }

        public override Task Process(IContext<byte[], MessageBase> context)
        {
            this.context = context;
            var ph = this.sensorHandlerList.Find(p => (byte)(p.DeviceAddress) == context.Incoming.Message.Address);
            if (ph == null)
            {
                logger.LogError($"SensorGroupHandler does not contain sensorHandler with address: {context.Incoming.Message.Address.ToString("X2")}");
                return Task.CompletedTask;
            }

            return ph.Process(context);
        }
    }

    public enum DeviceState
    {
        /// <summary>
        /// first time eastalized the connection with FC, or disconnected from a established connection.
        /// </summary>
        Disconnected,

        Connected
    }
}