FCC/Applications/VaporRecoveryOnlineWatchProject/Bogus_VaporRecoveryDataCollectorBoard/App.cs

using Edge.Core.Processor;
using Edge.Core.Processor.Dispatcher.Attributes;
using Edge.Core.UniversalApi;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Wayne_VaporRecoveryDataCollectorBoard.MessageEntity;
using Wayne_VaporRecoveryDataCollectorBoard.MessageEntity.Incoming;

namespace Bogus_VaporRecoveryDataCollectorBoard
{
    [MetaPartsDescriptor(
              "lang-zh-cn:气液比数据收集板 模拟器lang-en-us:气液比数据收集板 模拟器",
              "lang-zh-cn:模拟器,气体和液体小数点位数请设置2，用于驱动 气液比数据收集板 模拟器， 请调用API: ManualSetNextVaporAndLiquid来人工设置模拟气液比值lang-en-us:模拟器,气体和液体小数点位数请设置2，用于驱动 气液比数据收集板 模拟器,  请调用API: ManualSetNextVaporAndLiquid来人工设置模拟气液比值",
              new[] { "lang-zh-cn:在线监测lang-zh-tw:在線監測lang-en-us:OnlineWatch" })]
    public class App : Wayne_VaporRecoveryDataCollectorBoard.GroupHandler, IAppProcessor
    {
        private bool isStop = false;

        private int vaporLitre = 990; int liquidLiter = 1000;
        public App(DeviceConfigV1 deviceConfig, IServiceProvider services) : base(deviceConfig, services)
        { }

        public string MetaConfigName { get; set; }

        public void Init(IEnumerable<IProcessor> processors)
        {
        }

        public Task<bool> Start()
        {
            Task.Run(async () =>
            {
                await Task.Delay(5000);
                foreach (var b in base.Boards)
                {
                    b.State = Wayne_VaporRecoveryDataCollectorBoard.BoardStateEnum.Initializing;
                    base.FireOnBoardStateChangeEvent(b);
                }

                await Task.Delay(3000);
                foreach (var b in base.Boards)
                {
                    b.State = Wayne_VaporRecoveryDataCollectorBoard.BoardStateEnum.Initialized;
                    base.FireOnBoardStateChangeEvent(b);
                }

                foreach (var b in base.Boards)
                {
                    foreach (var n in b.Nozzles)
                    {
                        n.NozzleState = Wayne_VaporRecoveryDataCollectorBoard.MessageEntity.NozzleStateEnum.Idle;
                        base.FireOnBoardNozzleStateChangeEvent(n);
                    }
                }

                while (true)
                {
                    if (this.isStop) break;
                    await Task.Delay(3000);
                    foreach (var b in base.Boards)
                    {
                        foreach (var n in b.Nozzles)
                        {
                            n.NozzleState = Wayne_VaporRecoveryDataCollectorBoard.MessageEntity.NozzleStateEnum.Fuelling;
                            base.FireOnBoardNozzleStateChangeEvent(n);

                            #region real time data

                            for (int i = 0; i <= 7; i++)
                            {
                                var realTimeFlowData = new FakeRealTimeFlowData()
                                {
                                    Address = b.BoardPhysicalAddress,
                                    NozzleStates = new List<KeyValuePair<byte, NozzleStateEnum>>()
                                    {
                                        new KeyValuePair<byte, NozzleStateEnum>((byte)n.NozzleNumberOnBoard, NozzleStateEnum.Fuelling)
                                    },
                                    NozzleLiquidAndAirFlowData = new List<Tuple<byte, double, double>>()
                                    {
                                        new Tuple<byte, double, double>((byte)n.NozzleNumberOnBoard,this.liquidLiter*(1+(double)i/100),this.vaporLitre*(1+(double)i/100))
                                    }
                                };
                                base.FireOnDataReceivedEvent(realTimeFlowData);
                                await Task.Delay(1500);
                            }

                            #endregion

                            await Task.Delay(1000);
                            n.NozzleState = Wayne_VaporRecoveryDataCollectorBoard.MessageEntity.NozzleStateEnum.Idle;
                            base.FireOnBoardNozzleStateChangeEvent(n);
                            await Task.Delay(3000);
                            var trxFlowData = new FakeTrxFlowData()
                            {
                                Address = b.BoardPhysicalAddress,
                                NozzleNumber = (byte)n.NozzleNumberOnBoard,
                                AirVolume = this.vaporLitre * 10,// 1100,
                                LiquidVolume = this.liquidLiter * 10,//1000,
                                FuellingStartTime = DateTime.Now.Subtract(new TimeSpan(0, 5, 0)),
                                FuellingEndTime = DateTime.Now.Subtract(new TimeSpan(0, 0, 30)),
                                是否需要处理合并流量 = false,
                            };
                            base.FireOnDataReceivedEvent(trxFlowData);
                        }
                    }
                }
            });
            return Task.FromResult(true);
        }

        public Task<bool> Stop()
        {
            base.Dispose();
            this.isStop = true;
            return Task.FromResult(true);
        }

        public override async Task<READ_PARA_Response> ReadBoardNozzleInitParameters(byte boardPhysicalAddress, byte onBoardNozzleNumber)
        {
            var exists = this.boardNozzleInitParameters.FirstOrDefault(p => p.BoardPhysicalAddress == boardPhysicalAddress && p.OnBoardNozzleNumber == onBoardNozzleNumber);
            if (exists != null)
            {
                return new FakeREAD_PARA_Response()
                {
                    Address = boardPhysicalAddress,
                    NozzleNumber = onBoardNozzleNumber,
                    停止加油阀值 = exists.ParametersConfig.停止加油阀值,
                    加油脉冲当量 = exists.ParametersConfig.加油脉冲当量,
                    开始加油阀值 = exists.ParametersConfig.开始加油阀值,
                    最大未变化次数 = exists.ParametersConfig.最大未变化次数,
                    最小加油量 = exists.ParametersConfig.最小加油量,
                    Raw_气液比值 = (int)(exists.ParametersConfig.气液比值 * 1000),
                    油气脉冲当量 = exists.ParametersConfig.油气脉冲当量,
                };
            }
            else
                return new FakeREAD_PARA_Response()
                {
                    Address = boardPhysicalAddress,
                    NozzleNumber = onBoardNozzleNumber,
                    停止加油阀值 = new Random().Next(100, 200),
                    加油脉冲当量 = new Random().Next(200, 400),
                    开始加油阀值 = new Random().Next(400, 700),
                    最大未变化次数 = (byte)new Random().Next(1, 100),
                    最小加油量 = new Random().Next(10000, 100000),
                    Raw_气液比值 = 1 * 1000,
                    油气脉冲当量 = new Random().Next(400, 1500),
                };
        }

        private class BoardNozzleInitParameter
        {
            public byte BoardPhysicalAddress { get; set; }
            public byte OnBoardNozzleNumber { get; set; }
            public BoardInitParameterConfigV1 ParametersConfig { get; set; }
        }

        private List<BoardNozzleInitParameter> boardNozzleInitParameters = new List<BoardNozzleInitParameter>();

        public override async Task<bool> WriteBoardNozzleInitParameters(byte boardPhysicalAddress, byte onBoardNozzleNumber, BoardInitParameterConfigV1 parametersConfig)
        {
            var exists = this.boardNozzleInitParameters.FirstOrDefault(p => p.BoardPhysicalAddress == boardPhysicalAddress && p.OnBoardNozzleNumber == onBoardNozzleNumber);
            if (exists != null)
                this.boardNozzleInitParameters.Remove(exists);
            this.boardNozzleInitParameters.Add(new BoardNozzleInitParameter() { BoardPhysicalAddress = boardPhysicalAddress, OnBoardNozzleNumber = onBoardNozzleNumber, ParametersConfig = parametersConfig });
            return true;
        }

        [UniversalApi(Description = "人为指定接下来的模拟过程中的气体与液体的升数，数值均为不包括小数点的，即输入123，则实际代表1.23升（假设你之前的设置小数点位数是2）。" +
            "此数据将以极小的波动（为了更精确模拟实际的波动）应用于所有加油过程中的油气值，且将  输入值x10 作为加油完成后的油气值，一般的，0.83<=气液比值<=1.35为合格值，否则为不合格。")]
        public async Task<bool> ManualSetNextVaporAndLiquid(int vaporLitre, int liquidLiter)
        {
            this.vaporLitre = vaporLitre;
            this.liquidLiter = liquidLiter;
            return true;
        }
    }

    internal class FakeTrxFlowData : READ_ONE_HISTORY_DATA_Response
    {
        public override byte NozzleNumber { get; set; }
        public override int AirVolume { get; set; }
        public override int LiquidVolume { get; set; }
        public override DateTime FuellingStartTime { get; set; }
        public override DateTime FuellingEndTime { get; set; }
        public override bool 是否需要处理合并流量 { get; set; }
    }

    internal class FakeRealTimeFlowData : READ_WORKING_AND_TYPE_Response
    {
        public override IEnumerable<KeyValuePair<byte, NozzleHistoryDataStateEnum>> NozzleHistoryDataStates { get; set; }
        public override IEnumerable<Tuple<byte, double, double>> NozzleLiquidAndAirFlowData { get; set; }
        public override IEnumerable<KeyValuePair<byte, NozzleStateEnum>> NozzleStates { get; set; }
    }

    internal class FakeREAD_PARA_Response : READ_PARA_Response
    {
        public override byte NozzleNumber { get; set; }
        public override byte 最大未变化次数 { get; set; }
        public override int 开始加油阀值 { get; set; }
        public override int 停止加油阀值 { get; set; }
        public override int 最小加油量 { get; set; }

        public override int 加油脉冲当量 { get; set; }

        public override int 油气脉冲当量 { get; set; }
        public override int? Raw_气液比值 { get; set; }
    }
}