Sanya-ips/ipsmodule/adc/Ips.Adc.General.Core/AdgController.cs

using CliWrap;
using Ips.Library.Basic;
using Ips.Library.Entity;
using Ips.Library.LocLib;
using Ips.Library.Signals;

namespace Ips.AdcAlgorithm
{
    public class AdgController : IAdController
    {
        public AdgController()
        {
            _ddcOneStopTimer = new Timer(async obj => await Stop(), null, Timeout.Infinite, Timeout.Infinite);
            _getDdcSrcFileName = GetDdcSrcFileName;
            _getAdcSrcFileName = GetAdcSrcFileName;
        }

        static readonly string CliPath = Path.Combine(IpsPath.CliRootDir, "adg");
        static readonly string CliFile = Path.Combine(CliPath, "adg.exe");
        static readonly string CliAppCfg = Path.Combine(CliPath, "app.cfg");
        static readonly string QFStopExe = Path.Combine(CliPath, "stop.exe");

        Timer _ddcOneStopTimer, _ddcRestartTimer;
        Func<AdcOptions, AdcChOptions, AdcSigOptions, string> _getDdcSrcFileName;
        Func<AdcOptions, int, string> _getAdcSrcFileName;

        public AdcOptions CurrentAdcOptions { get; set; }

        /// <summary>
        /// ADC采集
        /// </summary>
        public async Task<ExeResult<AdcResult>> StartAdc(AdcOptions options, Action<string> handline = null, CancellationToken token = default)
        {
            //停止采集
            await Stop();
            //修改配置
            await SetAppCfg(options);

            if (options.StartTime < DateTime.Now.AddSeconds(AdcConst.MinWaitTime))
                options.StartTime = DateTime.Now.AddSeconds(AdcConst.MinWaitTime);

            DirectoryUtil.CreateIfNotExists(options.StorePath);

            var cmd = CliWrap.Cli.Wrap(CliFile)
                .WithWorkingDirectory(CliPath)
                .WithValidation(CommandResultValidation.None)
                .WithArguments(args =>
                {
                    args.Add(1);
                    args.Add(DateTimeUtil.To1970s(options.StartTime));
                    args.Add(options.ClockType.ToString("D"));
                    args.Add(options.TriggerMode.ToString("D"));
                    args.Add(options.DdcFreq.E6m().ToString());
                    args.Add(options.ClockFreq.E6m().ToString());
                    args.Add(options.Mutil == 1 ? 0 : options.Mutil);
                    args.Add(options.ChCount);
                    args.Add(options.StorePath, true);
                    args.Add(options.TimeLen);
                });

            if (handline != null)
            {
                cmd = cmd.WithStandardErrorPipe(PipeTarget.ToDelegate(handline))
                         .WithStandardOutputPipe(PipeTarget.ToDelegate(handline));
            }

            var result = await cmd.ExecuteAsync(token);
            var adcResult = await AdcFileUtil.BuildAdcResult(options, _getAdcSrcFileName);
            return ExeResult.Create(adcResult, cmd.Arguments, result.StartTime, result.ExitTime, result.ExitCode);
        }

        /// <summary>
        /// DDC采集
        /// </summary>
        public async Task<ExeResult<AdcResult>> StartDdcOne(AdcOptions options, Action<string> handline = null, CancellationToken token = default)
        {
            await Stop();
            await SetAppCfg(options);
            if (options.StartTime < DateTime.Now.AddSeconds(AdcConst.MinWaitTime))
                options.StartTime = DateTime.Now.AddSeconds(AdcConst.MinWaitTime);
            var cmd = BuildDdcCommand(options, handline);
            //由于DDC采集不会停止，到时间后结束进程
            var stopTimeSpan = options.StartTime.AddSeconds(options.TimeLen + AdcConst.DDCFindFileDelay) - DateTime.Now;
            _ddcOneStopTimer.Change(stopTimeSpan, Timeout.InfiniteTimeSpan);

            var cmdRes = await cmd.ExecuteAsync(token);
            var adcResult = AdcFileUtil.BuildDdcResult(options, _getDdcSrcFileName);
            return ExeResult.Create(adcResult, cmd.Arguments, cmdRes.StartTime, cmdRes.ExitTime, cmdRes.ExitCode);
        }

        /// <summary>
        /// DDC持续采集
        /// </summary>
        public async Task<ExeResult<AdcResult>> StartDdcKeep(AdcOptions options, Action<AdcResult> resultCallback, Action<string> handline = null, CancellationToken token = default)
        {
            //停止原有采集
            await Stop();
            //设置配置文件
            await SetAppCfg(options);
            if (options.StartTime < DateTime.Now.AddSeconds(AdcConst.MinWaitTime))
                options.StartTime = DateTime.Now.AddSeconds(AdcConst.MinWaitTime);
            var startTime = options.StartTime;
            options.StartTime = startTime.ClearSecond().AddSeconds(Math.Ceiling(startTime.Second * 1.0 / options.TimeLen) * options.TimeLen);
            var cmd = BuildDdcCommand(options, handline);
            var adcTsk = cmd.ExecuteAsync(token);
            var outTsk = Task.Run(() =>
            {
                while (!adcTsk.Task.IsCompleted)
                {
                    var waitTime = options.StartTime.AddSeconds(options.TimeLen + AdcConst.DDCFindFileDelay) - DateTime.Now;
                    if (waitTime.TotalMilliseconds > 0)
                        Task.Delay((int)waitTime.TotalMilliseconds, token).Wait();
                    var adcResult = AdcFileUtil.BuildDdcResult(options, _getDdcSrcFileName);
                    resultCallback?.Invoke(adcResult);
                    options.StartTime = options.StartTime.AddSeconds(options.TimeLen);
                }
            });
            StartRestartDdc(new RestartDdcOptions(options, resultCallback, handline, token));
            await Task.WhenAll(adcTsk, outTsk);
            var cmdRes = await adcTsk;
            return ExeResult.Create(new AdcResult(options.StartTime, options.StorePath), cmd.Arguments, cmdRes.StartTime, cmdRes.ExitTime, cmdRes.ExitCode);
        }

        /// <summary>
        /// 停止采集
        /// </summary>
        public async Task Stop()
        {
            _ddcOneStopTimer?.Change(Timeout.Infinite, Timeout.Infinite);
            _ddcRestartTimer?.Change(Timeout.Infinite, Timeout.Infinite);
            if (CurrentAdcOptions != null && CurrentAdcOptions.CardType == AdCardType.QFCarder)
            {
                if (File.Exists(QFStopExe))
                {
                    await Cli.Wrap(QFStopExe).ExecuteAsync();
                }
            }
            ProcessUtil.KillProcessByName(CliFile);
        }

        /// <summary>
        /// 设置采集参数
        /// </summary>
        /// <param name="options"></param>
        private async Task SetAppCfg(AdcOptions options)
        {
            string cardTypeDesc = options.CardType.ToString("g");
            string cfgContent = $"DllPath={cardTypeDesc}\r\nDllName = {cardTypeDesc}.dll\r\nFilePath = {options.StorePath}";
            await File.WriteAllTextAsync(CliAppCfg, cfgContent);
            CurrentAdcOptions = options;
        }

        private void StartRestartDdc(RestartDdcOptions restartOptions)
        {
            var now = DateTime.Now;
            var addHour = now.Minute > 30 ? 2 : 1;
            var restartTime = now.AddHours(addHour).ClearMinute().AddMinutes(1);
            var waitTimeMs = (int)(restartTime - now).TotalMilliseconds;
            if (_ddcRestartTimer == null)
            {
                _ddcRestartTimer = new Timer(async obj => await RestartDdc(obj), restartOptions, waitTimeMs, Timeout.Infinite);
            }
            else
            {
                _ddcRestartTimer.Change(waitTimeMs, Timeout.Infinite);
            }
        }

        private async Task RestartDdc(object obj)
        {
            var options = obj as RestartDdcOptions;
            if (options == null) return;
            await Stop();
            await StartDdcKeep(options.AdcOptions, options.ResultCallback, options.Handline, options.Token);
        }

        private Command BuildDdcCommand(AdcOptions options, Action<string> handline)
        {
            DirectoryUtil.CreateIfNotExists(options.StorePath);

            var cmd = CliWrap.Cli.Wrap(CliFile)
                .WithWorkingDirectory(CliPath)
                .WithValidation(CommandResultValidation.None)
                .WithArguments(args =>
                {
                    args.Add(2);
                    args.Add(DateTimeUtil.To1970s(options.StartTime));
                    args.Add(options.ClockType.ToString("D"));
                    args.Add(options.TriggerMode.ToString("D"));
                    args.Add(options.DdcFreq.E6m().ToString());
                    args.Add(options.ClockFreq.E6m().ToString());
                    args.Add(options.Mutil);
                    args.Add(options.ChCount);
                    args.Add(options.StorePath);
                    args.Add(options.TimeLen);

                    args.Add(1);
                    args.Add(options.GetCenterFreqs().Select(m => (m * 1e-6).ToString()));
                    foreach (var ch in options.Channels)
                    {
                        foreach (var sig in ch.Signals)
                        {
                            int mutil = SigCalcUtil.CalcMutil(options.ClockFreq / options.Mutil, sig.BandWidth, false);
                            args.Add(ch.ChNum);
                            args.Add(sig.FreqUp == 0 ? "0" : sig.FreqUp.E6m().ToString());
                            args.Add(sig.FreqPoint.E6m().ToString());
                            args.Add(mutil);
                            args.Add(sig.SigName);
                        }
                    }
                });
            if (handline != null)
            {
                cmd = cmd.WithStandardErrorPipe(PipeTarget.ToDelegate(handline))
                    .WithStandardOutputPipe(PipeTarget.ToDelegate(handline));
            }
            return cmd;
        }

        private string GetAdcSrcFileName(AdcOptions options, int chNum)
        {
            var sigTime = options.StartTime;
            var nameTime = sigTime.Format(SignalFile.SigTimeFileFormat);
            string fileName = $"{nameTime}_ch{chNum}{(options.Mutil == 1 ? "" : "_iq")}.dat";
            string fullName = Path.Combine(options.StorePath, fileName);
            return fullName;
        }

        private string GetDdcSrcFileName(AdcOptions options, AdcChOptions ch, AdcSigOptions sig)
        {
            int mutil = SigCalcUtil.CalcMutil(options.ClockFreq / options.Mutil, sig.BandWidth, false);
            var folderTime = options.StartTime.Format("yyyyMMdd_HH");
            var nameTime = options.StartTime.Format("yyyyMMddHHmmss");
            double downFreqMHz = sig.FreqPoint.E6m();
            var fs = options.ClockFreq / options.Mutil / mutil;
            string sourceFile = Path.Combine(options.StorePath, folderTime, $"{nameTime}_{sig.SigName}_{sig.FreqUp.E6m():F3}MHz_{downFreqMHz:F3}MHz_C{fs}_CH{ch.ChNum}.dat");
            return sourceFile;
        }
    }
}