Display_D_HP/TeamAAS-VM/Core/Management.cs

using Cognex.VisionPro;
using CSScripting;
using NPOI.SS.Formula.Eval;
using NPOI.Util;

//using ICSharpCode.SharpZipLib.Zip;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using SqlSugar;
using SqlSugar.SplitTableExtensions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Media;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Core.PLCs;
using TeamAAS_VP.Core.ScrewDriver;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.ViewModels;
using TeamAAS_VP.ViewModels.Home;
using TouchSocket.Core;
using TouchSocket.SerialPorts;
using TouchSocket.Sockets;

namespace TeamAAS_VP.Core
{
    public class Management : BindableBase
    {
        #region 字段
        IRegionManager _regionManager;
        IEventAggregator _eventAggregator;
        IContainerProvider _container;
        IConfigService _configService;
        IRobotService _robotService;
        IScannerService _scannerService;
        ICameraService _cameraService;
        IFeederService _feederService;
        IPlcService _plcService;
        ILightManagerService _lightManagerService;
        IProductService _productService;
        ICalibrationService _calibrationService;
        IRemoteCommandService _remoteCommandService;
        ISystemDatabaseService _systemDatabaseService;
        IMesService _mesService;

        Timer yieldtimer;
        private DateTime StartTime = DateTime.Now;
        /// <summary>
        /// 产品主sn
        /// </summary>
        string ProductMainSN = "";
        /// <summary>
        /// 工单信息
        /// </summary>
        string wo = "";
        string model_num = "";//产品model_num
        string color = "";//产品color
        string ppid = "";//产品ppid
        string revision = "";//产品revision
        string stage = "";//产品revision

        /// <summary>
        /// 上次执行上传csv的日期
        /// </summary>
        private DateTime _lastCompressDate = DateTime.MinValue;
        /// <summary>
        /// 当天是否上传过csv
        /// </summary>
        private bool _hasCompressedToday = false;


        #endregion

        #region 属性
        private Guid _defaultScannerId = Guid.Empty;
        private volatile TaskCompletionSource<string> _scanTcs; // 最简单：只支持单通道“当前一次扫
        public string[] CsvData = new string[50];
        public int[] ResultData = new int[200];
        public string code = "";
        List<LockResult> lockResultsAll = new List<LockResult>();//一个产品的总结果
        private ObservableCollection<ShowRender> _Renders;
        private double _CTtime;
        public int ResultDataCount;
        public string PhotoPath = "";
        // 扫码结果
        private string ScanValue = "";
        // 扫码完成事件
        private readonly ManualResetEventSlim _scanDoneEvent = new ManualResetEventSlim(false);
        //键盘数据
        public Dictionary<string, double> keyData = new Dictionary<string, double>{};
        //键盘单独数据
        public Dictionary<string, double> keyData1 = new Dictionary<string, double> { };
        //键盘差值
        public bool isValueOk;

        private System.Windows.Media.Brush _StatusBackground;

        public System.Windows.Media.Brush StatusBackground
        {
            get { return _StatusBackground; }
            set { SetProperty(ref _StatusBackground, value); }
        }

        private System.Windows.Media.Brush _RunModelBackground;

        public System.Windows.Media.Brush RunModelBackground
        {
            get { return _RunModelBackground; }
            set { SetProperty(ref _RunModelBackground, value); }
        }

        private System.Windows.Media.Brush _ManualModeBackground;

        public System.Windows.Media.Brush ManualModeBackground
        {
            get { return _ManualModeBackground; }
            set { SetProperty(ref _ManualModeBackground, value); }
        }

        private System.Windows.Media.Brush _ClearModeBackground;

        public System.Windows.Media.Brush ClearModeBackground
        {
            get { return _ClearModeBackground; }
            set { SetProperty(ref _ClearModeBackground, value); }
        }

        private SerialPortClient _Scan_Client;

        public SerialPortClient Scan_Client
        {
            get { return _Scan_Client; }
            set { _Scan_Client = value; }
        }

        private bool _ShowMes_Query;
        /// <summary>
        /// 显示查询结果
        /// </summary>
        public bool ShowMes_Query
        {
            get { return _ShowMes_Query; }
            set { SetProperty(ref _ShowMes_Query, value); }
        }

        private bool _ShowMes_Result = false;
        /// <summary>
        /// 显示上传结果
        /// </summary>
        public bool ShowMes_Result
        {
            get { return _ShowMes_Result; }
            set { SetProperty(ref _ShowMes_Result, value); }

        }

        /// <summary>
        /// ct
        /// </summary>
        public double CTtime
        {
            get { return _CTtime; }
            set { SetProperty(ref _CTtime, value); }
        }
        /// <summary>
        /// 显示界面
        /// </summary>
        public ObservableCollection<ShowRender> Renders
        {
            get { return _Renders; }
            set { SetProperty(ref _Renders, value); }
        }

        private ProductModel _CurrentProduct;

        /// <summary>
        /// 当前产品
        /// </summary>
        public ProductModel CurrentProduct
        {
            get { return _CurrentProduct; }
            set { SetProperty(ref _CurrentProduct, value); }
        }

        public BgCommunicate BgCommunicate { get; private set; }

        public BgModbusTcpCommunicate BgModbusTcpCommunicate { get; private set; }

        private ObservableCollection<StatusInfo> _Status = new ObservableCollection<StatusInfo>();

        /// <summary>
        /// 状态栏集合
        /// </summary>
        public ObservableCollection<StatusInfo> Status
        {
            get { return _Status; }
            set { SetProperty(ref _Status, value); }
        }

        private Int64 _TotalQuantity;
        /// <summary>
        /// 总产量
        /// </summary>
        public Int64 TotalQuantity
        {
            get { return _TotalQuantity; }
            set { SetProperty(ref _TotalQuantity, value); }
        }

        private Int64 _TotalQuantityToday;
        /// <summary>
        /// 当天的总产量
        /// </summary>
        public Int64 TotalQuantityToday
        {
            get { return _TotalQuantityToday; }
            set { SetProperty(ref _TotalQuantityToday, value); }
        }

        private Int64 _CurrentUPH;
        /// <summary>
        /// 当前的UPH
        /// </summary>
        public Int64 CurrentUPH
        {
            get { return _CurrentUPH; }
            set { SetProperty(ref _CurrentUPH, value); }
        }

        private Int64 _NgNumber;
        /// <summary>
        /// 当前的NG数量
        /// </summary>
        public Int64 NgNumber
        {
            get { return _NgNumber; }
            set { SetProperty(ref _NgNumber, value); }
        }
        private double _Yield;
        /// <summary>
        /// 当前的NG数量
        /// </summary>
        public double Yield
        {
            get { return _Yield; }
            set { SetProperty(ref _Yield, value); }
        }
        private XYD_ScrewDriver _ScrewDriver;
        public XYD_ScrewDriver ScrewDriver
        {
            get { return _ScrewDriver; }
            set { SetProperty(ref _ScrewDriver, value); }
        }

        public Dictionary<string, object> BackupObject { get; set; } = new Dictionary<string, object>();


        private ObservableCollection<ProductModel> _ProductList;
        public ObservableCollection<ProductModel> ProductList
        {
            get { return _ProductList; }
            set { SetProperty(ref _ProductList, value); }
        }

  
        #endregion

        #region 命令

        #endregion

        #region 事件

        #endregion

        public Management(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, IConfigService configService,
            IRobotService robotService, ICameraService cameraService, IFeederService feederService, IPlcService plcService, IProductService productService,
            ICalibrationService calibrationService, IRemoteCommandService remoteCommandService, ISystemDatabaseService systemDatabaseService, ILightManagerService lightManagerService, IMesService mesService, IScannerService scannerService)
        {

            _regionManager = regionManager;
            _eventAggregator = ea;
            _container = container;
            _configService = configService;
            _robotService = robotService;
            _scannerService = scannerService;
            _cameraService = cameraService;
            _feederService = feederService;
            _plcService = plcService;
            _calibrationService = calibrationService;
            yieldtimer = new Timer(DoYieldTime, null, 10000, 1000);
            Renders = new ObservableCollection<ShowRender>();
            _configService = configService;
            _productService = productService;
            _remoteCommandService = remoteCommandService;
            _systemDatabaseService = systemDatabaseService;
            _lightManagerService = lightManagerService;
            _mesService = mesService;
            _eventAggregator.GetEvent<CurrentStatusNotification>().Subscribe(CurrentRunStatus);
        }

        #region 初始化硬件模块

        /// <summary>
        /// 初始化Feeder
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitFeeders()
        {
            var feeders = _configService.GetAllFeeders();
            StringBuilder sb = new StringBuilder();
            foreach (var item in feeders)
            {
                _feederService.CreateFeeder(item.Id, item.FeederNo, item.FeederName, item.IP, item.Port, item.FeederBrand);
                var feeder = _feederService.GetFeeder(item.Id);
                Status.Add(new StatusInfo(item.Id, item.FeederName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
                try
                {
                    feeder.FeederConnectionStatusChanged += Management_FeederConnectionStatusChanged;
                    await feeder.ConnectAsync();     //连接Feeder
                    //SendTaskMessage($"{item.FeederName}已连接!", MessageLevel.Debug);
                }
                catch (Exception ex)
                {
                    sb.AppendLine($"{item.FeederName}:{Lang.断开连接}![{ex.Message}]");
                    SendTaskMessage($"{item.FeederName}{Lang.断开连接}!", MessageLevel.Alarm);
                }
            }
            if (sb.Length == 0)
            {
                return (true, "");
            }
            else
            {
                return (false, sb.ToString());
            }
        }

        /// <summary>
        /// 初始化机器人
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitRobots()
        {
            var robots = _configService.GetAllRobots();
            StringBuilder sb = new StringBuilder();
            foreach (var item in robots)
            {
                _robotService.CreateRobot(item.Id, item);

                try
                {
                    Status.Add(new StatusInfo(item.Id, item.RobotName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
                    var robot = _robotService.GetRobot(item.Id);
                    robot.ReceivedEvent += Management_ReceivedEvent;
                    robot.SendEvent += Management_SendEvent;
                    robot.ConnectedEvent += Management_ConnectedEvent;
                    robot.DisconnectedEvent += Management_DisconnectedEvent;
                    await robot.ConnectAsync();     //连接Robot
                    SendTaskMessage($"{item.RobotName}{Lang.已连接}!", MessageLevel.Debug);
                }
                catch (Exception ex)
                {
                    sb.AppendLine($"{item.RobotName}:{Lang.断开连接}![{ex.Message}]");
                    SendTaskMessage($"{item.RobotName}{Lang.断开连接}!", MessageLevel.Alarm);
                }
            }
            if (sb.Length == 0)
            {
                return (true, "");
            }
            else
            {
                return (false, sb.ToString());
            }
        }

        /// <summary>
        /// 初始化扫码枪
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitScanners()
        {
            var scanners = _configService.GetAllScanners();
            StringBuilder sb = new StringBuilder();
            foreach (var item in scanners)
            {
                _scannerService.CreateScanner(item.Id, item);
                try
                {
                    Status.Add(new StatusInfo(item.Id, item.ScannerName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
                    var scanner = _scannerService.GetScanner(item.Id);
                    scanner.ReceivedEvent += Management_ScannerReceivedEvent;
                    scanner.SendEvent += Management_ScannerSendEvent;
                    scanner.ConnectedEvent += Management_ScannerConnectedEvent;
                    scanner.DisconnectedEvent += Management_ScannerDisconnectedEvent;
                    await scanner.ConnectAsync();     //连接Scanner
                    SendTaskMessage($"{item.ScannerName}{Lang.已连接}!", MessageLevel.Debug);
                }
                catch (Exception ex)
                {
                    sb.AppendLine($"{item.ScannerName}:{Lang.断开连接}![{ex.Message}]");
                    SendTaskMessage($"{item.ScannerName}{Lang.断开连接}!", MessageLevel.Alarm);
                }
            }
            if (sb.Length == 0)
            {
                return (true, "");
            }
            else
            {
                return (false, sb.ToString());
            }
        }

        /// <summary>
        /// 初始化PLC
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitPlc()
        {
            var plcs = _configService.GetAllPlcs();
            StringBuilder sb = new StringBuilder();
            foreach (var item in plcs)
            {
                try
                {
                    _plcService.CreatePlc(item.Id, item);
                    var plc = _plcService.GetPlc(item.Id);
                    Status.Add(new StatusInfo(item.Id, item.Name + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
                    plc.ConnectChangedEvent += Management_PlcConnectChangedEvent;
                    await plc.ConnectAsync();     //连接PLC
                    //SendTaskMessage($"{item.Name}{Lang.已连接}!", MessageLevel.Debug);
                }
                catch (Exception ex)
                {
                    sb.AppendLine($"{item.Name}:{Lang.断开连接}![{ex.Message}]");
                    SendTaskMessage($"{item.Name}{Lang.断开连接}!", MessageLevel.Alarm);
                }
            }
            try
            {
                await WriteSystemParameterToPlcAsync(_configService.GetSystemConfiguration());
                RegisterPlcMonitorAddress();
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("为PLC写入系统参数和订阅变量时出错", ex);
            }
            if (sb.Length == 0)
            {
                return (true, "");
            }
            else
            {
                return (false, sb.ToString());
            }
        }

        /// <summary>
        /// 初始化相机
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitCameras()
        {
            var cameras = _configService.GetAllCameras();
            StringBuilder sb = new StringBuilder();
            foreach (var item in cameras)
            {
                if (item.DisplatConfigs != null)
                {
                    foreach (var item1 in item.DisplatConfigs)
                    {
                        Renders.Add(new ShowRender() { Id = item1.Id, DisplayName = item1.DisplayName });
                    }
                }
                _cameraService.CreateCamera(item.Id, item);
                try
                {
                    var camera = _cameraService.GetCamera(item.Id);
                    Status.Add(new StatusInfo(item.Id, item.CameraName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
                    camera.CameraConnectChangedEvent += Management_CameraConnectChangedEvent;
                    camera.ImageCallbackEvent += Camera_ImageCallbackEvent;
                    try
                    {
                        if (await camera.OpenDeviceAsync())
                        {
                            SendTaskMessage($"{item.CameraName}{Lang.已连接}!", MessageLevel.Debug);
                        }
                        else
                        {
                            SendTaskMessage($"{item.CameraName}{Lang.连接失败}!", MessageLevel.Alarm);
                            sb.AppendLine($"{item.CameraName}:{Lang.连接失败}!");
                        }
                    }
                    catch (Exception ex)
                    {
                        SendTaskMessage($"{item.CameraName}{ex.Message}!", MessageLevel.Alarm);
                        sb.AppendLine($"{item.CameraName}:{ex.Message}!");
                    }

                }
                catch (Exception ex)
                {
                    SendTaskMessage($"{item.CameraName}{Lang.连接失败}!", MessageLevel.Alarm);
                    sb.AppendLine($"{item.CameraName}:{Lang.连接失败}!:{ex.Message}");
                }
            }
            _container.Resolve<ShowVisionRenderViewModel>().Renders = Renders;

            if (sb.Length == 0)
            {
                return (true, "");
            }
            else
            {
                return (false, sb.ToString());
            }
        }

        private void Camera_ImageCallbackEvent(ICogImage arg1, TimeSpan arg2, string arg3, Guid cameraId)
        {

            var camera = _configService.GetCamera(cameraId);
            SendTaskMessage($"相机[{camera.CameraName}]图像接收完成！", MessageLevel.Info);

            //if (camera.CameraNo == 1)
            //{
            //    ImageData[1] = 1;
            //}
            //else if (camera.CameraNo == 2)
            //{
            //    ImageData[2] = 1;
            //}
            //else if (camera.CameraNo == 3)
            //{
            //    ImageData[3] = 1;
            //    ImageData[4] = 1;
            //}

            //_eventAggregator.GetEvent<RenderUpdateNotification>().Publish(new ShowRender()
            //{
            //    CameraName = camera.CameraName,
            //    Id = cameraId,
            //    Image = arg1,
            //    Graphic = null,
            //    Record = null,
            //    Result = false,
            //    IsShow = true,
            //});

            // 通知等待方：该相机新图到达
            //SignalImageArrived(cameraId, arg1);
        }

        /// <summary>
        /// 初始化光源控制器
        /// </summary>
        /// <returns></returns>
        public async Task<(bool IsSucceed, string Msg)> InitLightControllers()
        {
            var lightcontrollers = _configService.GetAllLightControllers();
            StringBuilder sb = new StringBuilder();
            foreach (var item in lightcontrollers)
            {
                try
                {
                    var lishtCtr = await _lightManagerService.RegisterControllerAsync(item.Id, item);
                    //var lightcontroller = _cameraService.GetLightController(item.Id);
                    //await lightcontroller.ConnectAsync();     //连接光源控制器
                    //SendTaskMessage($"{item.LightControllerName}{Lang.已连接}!", MessageLevel.Debug);
                }
                catch (Exception ex)
                {
                    //sb.AppendLine($"{item.LightControllerName}:{Lang.断开连接}![{ex.Message}]");
                    //SendTaskMessage($"{item.LightControllerName}{Lang.断开连接}!", MessageLevel.Alarm);
                }
            }
            if (lightcontrollers.Count > 0)
            {
                var result = await _lightManagerService.ConnectAllAsync();
                if (result)
                {
                    return (true, "");
                }
                else
                {
                    return (false, "Light Controller Connect Failed!");
                }
            }
            return (true, "");
            //if (sb.Length == 0)
            //{
            //    return (true, "");
            //}
            //else
            //{
            //    return (false, sb.ToString());
            //}
        }

        /// <summary>
        /// 初始化后台TCP服务器通讯
        /// </summary>
        public void InitBgTcp()
        {
            var config = _configService.GetBgTcp();
            try
            {
                BgCommunicate = new BgCommunicate(config);
                BgCommunicate.ConnectedEvent += BgCommunicate_ConnectedEvent;
                BgCommunicate.DisconnectedEvent += BgCommunicate_DisconnectedEvent;
                BgCommunicate.ReceivedEvent += BgCommunicate_ReceivedEvent;
                BgCommunicate.SendEvent += BgCommunicate_SendEvent;
                BgCommunicate.StartListening();
                SendTaskMessage($"{Lang.已开启监听端口}：{config.Port}", MessageLevel.Debug);
            }
            catch (Exception ex)
            {
                SendTaskMessage($"{Lang.未开启监听端口}：{config.Port}", MessageLevel.Error);
                LogHelper.WriteLogError("开启后台服务器通讯时出错!", ex);
            }
        }

        /// <summary>
        /// 初始化后台ModbusTCP从站
        /// </summary>
        public void InitModbusTcp()
        {
            try
            {
                var config = _configService.GetBgModbusTcp();
                BgModbusTcpCommunicate = new BgModbusTcpCommunicate(config);
                if (config.IsEnabled)
                {
                    BgModbusTcpCommunicate.Listen();
                    SendTaskMessage($"Start Modbus Tcp Slave：{BgModbusTcpCommunicate.IP}:{BgModbusTcpCommunicate.Port}:{BgModbusTcpCommunicate.SlaveID}", MessageLevel.Debug);
                }
            }
            catch (Exception ex)
            {
                SendTaskMessage($"No Start Modbus Tcp Slave：{ex.Message}", MessageLevel.Alarm);
                LogHelper.WriteLogError("开启后台Modbus TCP通讯时出错!", ex);
            }
        }

        /// <summary>
        /// 初始化后台脚本
        /// </summary>
        public void InitBackgroundcript()
        {
            try
            {
                if (!Directory.Exists(FilePath.BackgroundScriptPath))
                {
                    Directory.CreateDirectory(FilePath.BackgroundScriptPath);
                }

                try
                {
                    string[] files = Directory.GetFiles(FilePath.BackgroundScriptPath);
                    List<string> ScriptFilesCollection = new List<string>();
                    foreach (string file in files)
                    {
                        string fileName = Path.GetFileName(file);
                        string fileExtension = Path.GetExtension(file);
                        if (fileExtension == ".cs")
                        {
                            ScriptFilesCollection.Add(file);
                        }
                    }
                    foreach (var item in ScriptFilesCollection)
                    {
                        try
                        {
                            string script = FileHelper.ReadFile(item);
                            SendTaskMessage($"{Lang.执行脚本}:{item}", MessageLevel.Info);
                            Task.Factory.StartNew(() =>
                            {
                                ScriptHelper.ExecuteScriptingAsync(script, _regionManager, _eventAggregator, _container, rst =>
                            {
                                if (!rst.Item1)
                                {
                                    foreach (var err in rst.Item2)
                                    {
                                        SendTaskMessage($"{Lang.后台脚本出错}:{err}", MessageLevel.Error);
                                    }
                                }
                            });
                            });
                        }
                        catch (Exception ex)
                        {
                            LogHelper.WriteLogError($"开启脚本时出错：{item}", ex);
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("读取本地脚本文件列表时出错", ex);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("开启后台脚本时出错!", ex);
            }
        }

        /// <summary>
        /// 初始化电批
        /// </summary>
        /// <returns></returns>
        public async Task InitScrewDriver()
        {
            try
            {

                var screwDriverConfig = _configService.GetScrewDriverConfig();
                ScrewDriver = new XYD_ScrewDriver(screwDriverConfig.IPAdress, screwDriverConfig.Port);
                Status.Add(new StatusInfo(ScrewDriver.Id, "电批未连接", new SolidColorBrush(Colors.Red)));
                ScrewDriver.ConnectStateChangedEvent += ScrewDriver_ConnectStateChangedEvent;
                ScrewDriver.SendTimeout = screwDriverConfig.SendTimeout;
                screwDriverConfig.ReceiveTimeout = screwDriverConfig.ReceiveTimeout;
                var isConnected = await ScrewDriver.ConnectAsync();
                if (isConnected)
                {
                    SendTaskMessage($"电批已连接", MessageLevel.Debug);
                }
                else
                {
                    SendTaskMessage($"电批连接失败", MessageLevel.Error);
                }
            }
            catch (Exception ex)
            {
                SendTaskMessage($"电批连接失败:{ex.Message}", MessageLevel.Alarm);
                LogHelper.WriteLogError("连接电批时出错!", ex);
            }
        }

        public async Task InitScan()
        {
            if (!File.Exists(FilePath.ScanRS232ConfigPath))
            {
                var scan = new ScanRs232ConfigModel();
                FileHelper.WriteJsonFile(scan, FilePath.ScanRS232ConfigPath);
            }

            try
            {
                var res = FileHelper.ReadJsonFile<ScanRs232ConfigModel>(FilePath.ScanRS232ConfigPath);
                if (res != null)
                {
                    Scan_Client = new SerialPortClient();
                    Scan_Client.Connecting = (client1, e) => { return EasyTask.CompletedTask; };//即将连接到端口
                    Scan_Client.Connected = (client1, e) => { return EasyTask.CompletedTask; };//成功连接到端口
                    Scan_Client.Closing = (client1, e) => { return EasyTask.CompletedTask; };//即将从端口断开连接。此处仅主动断开才有效。
                    Scan_Client.Closed = (client1, e) => { return EasyTask.CompletedTask; };//从端口断开连接，当连接不成功时不会触发。
                    Scan_Client.Received = async (c, e) =>
                    {
                        //await Console.Out.WriteLineAsync(Encoding.UTF8.GetString(e.ByteBlock.Buffer));
                        await Console.Out.WriteLineAsync(e.ByteBlock.Span.ToString(Encoding.ASCII));
                    };
                    Scan_Client.Received = Scan_DataReceived;

                    await Scan_Client.SetupAsync(new TouchSocketConfig()
                         .SetSerialPortOption(new SerialPortOption()
                         {
                             BaudRate = res.BaudRate,//波特率
                             DataBits = res.DataBits,//数据位
                             Parity = res.Parity,//校验位
                             PortName = res.PortName,//COM
                             StopBits = res.StopBits//停止位
                         })
                         .SetSerialDataHandlingAdapter(() => new PeriodPackageAdapter() { CacheTimeout = TimeSpan.FromMilliseconds(100) })
                         );

                    await Scan_Client.ConnectAsync();

                    if (Scan_Client.Online)
                    {
                        SendTaskMessage(Lang.扫码机已连接, MessageLevel.Debug);
                    }
                    else
                    {
                        SendTaskMessage(Lang.扫码机未连接, MessageLevel.Debug);
                    }
                }
                else
                {
                    SendTaskMessage(Lang.请设置扫码机串口, MessageLevel.Error);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("初始化扫码枪时出错！", ex);
                SendTaskMessage(Lang.初始化扫码枪时出错 + ex.Message, MessageLevel.Error);
            }

        }
        #endregion

        #region 机器人指令执行

        public Dictionary<Guid, CancellationTokenSource> RobotTCPCollection = new Dictionary<Guid, CancellationTokenSource>();
        public Dictionary<Guid, CancellationTokenSource> ScannerTCPCollection = new Dictionary<Guid, CancellationTokenSource>();
        /// <summary>
        /// 机器人TCP接收
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        private async void Management_ReceivedEvent(Guid robotid, object arg2, TouchSocket.Sockets.ReceivedDataEventArgs e)
        {
            try
            {
                if (!RobotTCPCollection.ContainsKey(robotid))
                    RobotTCPCollection.Add(robotid, new CancellationTokenSource());
                else
                {
                    if (RobotTCPCollection[robotid].IsCancellationRequested)
                    {
                        RobotTCPCollection[robotid] = new CancellationTokenSource();
                    }
                }
                var robot = await _robotService.GetRobotAsync(robotid);
                //从服务器收到信息。但是一般byteBlock和requestInfo会根据适配器呈现不同的值。
                var buffer = e.ByteBlock.Span.ToString(robot.GetEncoding());
                SendTaskMessage($"{robot.Name}Received:{buffer}", MessageLevel.Info);

                var _ = _remoteCommandService.ExecuteAsync(buffer, RobotTCPCollection[robotid].Token, async msg =>
                {
                    try
                    {
                        if (robot.ConnectType == TCPConnectType.Client)
                        {
                            if (robot.IsConnected)
                            {
                                await robot.SendAsync($"{msg}");
                            }
                        }
                        else
                        {
                            var cient = (ITcpSessionClient)arg2;
                            if (cient.Online)
                            {
                                await robot.SendAsync(cient, $"{msg}");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("TCP发送数据时出错！", ex);
                        SendTaskMessage(ex.Message, MessageLevel.Alarm);
                    }
                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("处理机器人接收的命令时出错！", ex);
                SendTaskMessage(ex.Message, MessageLevel.Alarm);
            }
        }

        /// <summary>
        /// 扫码枪TCP接收
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        private async void Management_ScannerReceivedEvent(Guid scannerid, object arg2, TouchSocket.Sockets.ReceivedDataEventArgs e)
        {
            try
            {
                if (!ScannerTCPCollection.ContainsKey(scannerid))
                    ScannerTCPCollection.Add(scannerid, new CancellationTokenSource());
                else
                {
                    if (ScannerTCPCollection[scannerid].IsCancellationRequested)
                    {
                        ScannerTCPCollection[scannerid] = new CancellationTokenSource();
                    }
                }
                var scanner = await _scannerService.GetScannerAsync(scannerid);
                //从服务器收到信息。但是一般byteBlock和requestInfo会根据适配器呈现不同的值。
                var buffer = e.ByteBlock.Span.ToString(scanner.GetEncoding());
                var reply = (buffer ?? string.Empty).Trim();
                SendTaskMessage($"{scanner.Name}Received:{reply}", MessageLevel.Info);
                // 只要有人在等扫码结果，就先完成等待（避免被下面 ExecuteAsync 干扰）
                var tcs = _scanTcs;
                if (tcs != null && !string.IsNullOrWhiteSpace(reply))
                {
                    // 只完成一次
                    tcs.TrySetResult(reply);
                }
                var _ = _remoteCommandService.ExecuteAsync(buffer, ScannerTCPCollection[scannerid].Token, async msg =>
                {
                    try
                    {
                        if (scanner.ConnectType == TCPConnectType.Client)
                        {
                            if (scanner.IsConnected)
                            {
                                await scanner.SendAsync($"{msg}");
                            }
                        }
                        else
                        {
                            var cient = (ITcpSessionClient)arg2;
                            if (cient.Online)
                            {
                                await scanner.SendAsync(cient, $"{msg}");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("TCP发送数据时出错！", ex);
                        SendTaskMessage(ex.Message, MessageLevel.Alarm);
                    }
                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("处理扫码枪接收的命令时出错！", ex);
                SendTaskMessage(ex.Message, MessageLevel.Alarm);
            }
        }
        #endregion

        #region 机器人&Feeder&相机连接状态事件
        /// <summary>
        /// 机器人发送事件
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_SendEvent(Guid robotid, object arg2, string arg3)
        {
            var r = _robotService.GetRobot(robotid);
            SendTaskMessage($"{r.Name}Send:{arg3}", MessageLevel.Info);
        }

        /// <summary>
        /// 扫码枪发送事件
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_ScannerSendEvent(Guid scannerid, object arg2, string arg3)
        {
            var r = _scannerService.GetScanner(scannerid);
            SendTaskMessage($"{r.Name}Send:{arg3}", MessageLevel.Info);
        }

        /// <summary>
        /// 机器人断开连接时
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_DisconnectedEvent(Guid robotid, object arg2, ClosedEventArgs arg3)
        {
            if (RobotTCPCollection.ContainsKey(robotid))
            {
                RobotTCPCollection[robotid].Cancel();
            }
            var r = _configService.GetRobot(robotid);
            if (r.ConnectType == TCPConnectType.Server)
            {
                ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
                SendTaskMessage($"{r.RobotName}[{socketClient.Id}:{socketClient.IP}]{Lang.断开连接}！", MessageLevel.Error);

                var robot = _robotService.GetRobot(robotid);
                if (robot.TcpService.Count < 1)
                {
                    var sta = Status.FirstOrDefault(s => s.ID == robotid);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.RobotName}{Lang.未连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));

                }
            }
            else
            {
                SendTaskMessage($"{r.RobotName}{Lang.断开连接}！", MessageLevel.Error);
                var sta = Status.FirstOrDefault(s => s.ID == robotid);
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.RobotName}{Lang.断开连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));

            }
        }

        /// <summary>
        /// 扫码枪断开连接时
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_ScannerDisconnectedEvent(Guid scannerid, object arg2, ClosedEventArgs arg3)
        {
            if (ScannerTCPCollection.ContainsKey(scannerid))
            {
                ScannerTCPCollection[scannerid].Cancel();
            }
            var r = _configService.GetScanner(scannerid);
            if (r.ConnectType == TCPConnectType.Server)
            {
                ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
                SendTaskMessage($"{r.ScannerName}[{socketClient.Id}:{socketClient.IP}]{Lang.断开连接}！", MessageLevel.Error);
                var scanner = _scannerService.GetScanner(scannerid);
                if (scanner.TcpService.Count < 1)
                {
                    var sta = Status.FirstOrDefault(s => s.ID == scannerid);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.ScannerName}{Lang.未连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));

                }
            }
            else
            {
                SendTaskMessage($"{r.ScannerName}{Lang.断开连接}！", MessageLevel.Error);
                var sta = Status.FirstOrDefault(s => s.ID == scannerid);
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.ScannerName}{Lang.断开连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));

            }
        }

        /// <summary>
        /// 机器人连接成功时
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_ConnectedEvent(Guid robotid, object arg2, ConnectedEventArgs arg3)
        {
            var r = _configService.GetRobot(robotid);
            if (r.ConnectType == TCPConnectType.Server)
            {
                ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
                SendTaskMessage($"{r.RobotName}[{socketClient.Id}:{socketClient.IP}]{Lang.已连接}！", MessageLevel.Debug);

                var robot = _robotService.GetRobot(robotid);
                if (robot.TcpService.Count > 0)
                {
                    var sta = Status.FirstOrDefault(s => s.ID == robotid);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.RobotName}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));

                }
            }
            else
            {
                SendTaskMessage($"{r.RobotName}{Lang.已连接}！", MessageLevel.Debug);
                var sta = Status.FirstOrDefault(s => s.ID == robotid);
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.RobotName}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));

            }
        }

        /// <summary>
        /// 扫码枪连接成功时
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <param name="arg3"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Management_ScannerConnectedEvent(Guid scannerid, object arg2, ConnectedEventArgs arg3)
        {
            var r = _configService.GetScanner(scannerid);
            if (r.ConnectType == TCPConnectType.Server)
            {
                ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
                SendTaskMessage($"{r.ScannerName}[{socketClient.Id}:{socketClient.IP}]{Lang.已连接}！", MessageLevel.Debug);
                var scanner = _scannerService.GetScanner(scannerid);
                if (scanner.TcpService.Count > 0)
                {
                    var sta = Status.FirstOrDefault(s => s.ID == scannerid);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.ScannerName}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));

                }
            }
            else
            {
                SendTaskMessage($"{r.ScannerName}{Lang.已连接}！", MessageLevel.Debug);
                var sta = Status.FirstOrDefault(s => s.ID == scannerid);
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{r.ScannerName}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));

            }
        }

        /// <summary>
        /// Feeder连接状态改变时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="state"></param>
        private void Management_FeederConnectionStatusChanged(object sender, bool state)
        {
            IFeeder feeder = sender as IFeeder;
            var sta = Status.FirstOrDefault(s => s.ID == feeder.Id);
            if (state)
            {
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{feeder.Name}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));

                SendTaskMessage($"{feeder.Name}{Lang.已连接}！", MessageLevel.Debug);
            }
            else
            {
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{feeder.Name}{Lang.未连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));

                SendTaskMessage($"{feeder.Name}{Lang.断开连接}！", MessageLevel.Error);
            }
        }

        /// <summary>
        /// 相机连接或者断开时
        /// </summary>
        /// <param name="id"></param>
        /// <param name="state"></param>
        private void Management_CameraConnectChangedEvent(Guid id, bool state)
        {
            var sta = Status.FirstOrDefault(s => s.ID == id);
            var camera = _configService.GetCamera(id);
            if (sta != null && camera != null)
            {
                if (state)
                {
                    App.Current.Dispatcher.Invoke(new Action(() =>
                    {
                        sta.Message = $"{camera.CameraName}{Lang.已连接}";
                        sta.Background = new SolidColorBrush(Colors.Green);
                    }));

                }
                else
                {
                    App.Current.Dispatcher.Invoke(new Action(() =>
                    {
                        sta.Message = $"{camera.CameraName}{Lang.断开连接}";
                        sta.Background = new SolidColorBrush(Colors.Red);
                    }));
                }
            }
        }

        /// <summary>
        /// PLC连接状态改变事件
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="isconnected"></param>
        private void Management_PlcConnectChangedEvent(object sender, bool isconnected)
        {
            IPlc plc = sender as IPlc;
            var sta = Status.FirstOrDefault(s => s.ID == plc.Id);
            if (plc.IsConnected)
            {
                SendTaskMessage($"{plc.Name}{Lang.已连接}！", MessageLevel.Debug);
                if (sta == null) return;
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{plc.Name}{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));
            }
            else
            {
                SendTaskMessage($"{plc.Name}{Lang.断开连接}！", MessageLevel.Error);
                if (sta == null) return;
                App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"{plc.Name}{Lang.未连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));
            }
        }

        /// <summary>
        /// 电批连接状态改变时
        /// </summary>
        /// <param name="screwDevice"></param>
        /// <param name="state"></param>
        private void ScrewDriver_ConnectStateChangedEvent(object screwDevice, bool state)
        {
            try
            {
                XYD_ScrewDriver screwDriver = screwDevice as XYD_ScrewDriver;
                if (state)
                {
                    SendTaskMessage($"电批{Lang.已连接}！", MessageLevel.Debug);
                    var sta = Status.FirstOrDefault(s => s.ID == screwDriver.Id);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"电批{Lang.已连接}";
                             sta.Background = new SolidColorBrush(Colors.Green);
                         }));
                }
                else
                {
                    SendTaskMessage($"电批{Lang.未连接}！", MessageLevel.Error);
                    var sta = Status.FirstOrDefault(s => s.ID == screwDriver.Id);
                    App.Current.Dispatcher.Invoke(new
                         Action(() =>
                         {
                             sta.Message = $"电批{Lang.未连接}";
                             sta.Background = new SolidColorBrush(Colors.Red);
                         }));
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("电批连接状态改变时出错了", ex);
            }
        }
        #endregion

        #region 后台服务器通讯事件
        private void BgCommunicate_SendEvent(ITcpSessionClient client, string msg)
        {
            SendTaskMessage($"{Lang.服务器}[{client.ServicePort}] Send To {Lang.客户端}[{client.Id}:{client.IP}]:{msg}", MessageLevel.Info);
        }

        public Dictionary<string, CancellationTokenSource> BgCommunicateollection = new Dictionary<string, CancellationTokenSource>();
        private async void BgCommunicate_ReceivedEvent(ITcpSessionClient client, string msg)
        {

            try
            {
                if (!BgCommunicateollection.ContainsKey(client.Id))
                {
                    BgCommunicateollection.Add(client.Id, new CancellationTokenSource());
                }

                SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]ReceiveFor{Lang.客户端}[{client.Id}:{client.IP}]:{msg}", MessageLevel.Info);
                var _ = _remoteCommandService.ExecuteAsync(msg, BgCommunicateollection[client.Id].Token, async response =>
                {
                    try
                    {
                        if (!client.Online)
                        {
                            return;
                        }
                        await BgCommunicate.SendAsync(client, $"{response}");
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("后台TCP发送数据时出错！", ex);
                        SendTaskMessage(ex.Message, MessageLevel.Alarm);
                    }
                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("处理后台服务器接收的命令时出错！", ex);
                SendTaskMessage(ex.Message, MessageLevel.Alarm);
            }
        }

        private void BgCommunicate_DisconnectedEvent(ITcpSessionClient client, ClosedEventArgs e)
        {
            SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]{Lang.客户端}[{client.Id}:{client.IP}]{Lang.断开连接}!", MessageLevel.Alarm);
            if (BgCommunicateollection.ContainsKey(client.Id))
            {
                BgCommunicateollection[client.Id].Cancel();
            }
        }

        private void BgCommunicate_ConnectedEvent(ITcpSessionClient client, ConnectedEventArgs e)
        {
            SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]{Lang.客户端}[{client.Id}:{client.IP}]{Lang.连接成功}!", MessageLevel.Debug);
        }
        #endregion

        #region PLC
        /// <summary>
        /// 将系统参数写入PLC
        /// </summary>
        /// <param name="systemConfiguration"></param>
        /// <returns></returns>
        public async Task WriteSystemParameterToPlcAsync(SystemConfiguration systemConfiguration)
        {
            var addressConfig = _configService.GetPlcAddresses();
            var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
            if (plc == null || !plc.IsConnected) return;
            Dictionary<string, object> nodeValues = new Dictionary<string, object>();
            nodeValues.Add(addressConfig.Out_WorkMode.Address, (Int16)systemConfiguration.WorkMode);
            nodeValues.Add(addressConfig.Out_PickPointNum.Address, (Int16)systemConfiguration.PickPointNum);
            nodeValues.Add(addressConfig.Out_DowmCameraNum.Address, (Int16)systemConfiguration.DowmCameraNum);
            nodeValues.Add(addressConfig.Out_UpCameraPickNum.Address, (Int16)systemConfiguration.UpCameraPickNum);
            nodeValues.Add(addressConfig.Out_UpCameraPutNum.Address, (Int16)systemConfiguration.UpCameraPutNum);
            nodeValues.Add(addressConfig.Out_UPCameracheckNum.Address, (Int16)systemConfiguration.UPCameracheckNum);
            nodeValues.Add(addressConfig.Out_FixedCameraPickNum.Address, (Int16)systemConfiguration.FixedCameraPickNum);
            nodeValues.Add(addressConfig.Out_FixedCameraPutNum.Address, (Int16)systemConfiguration.FixedCameraPutNum);
            nodeValues.Add(addressConfig.Out_FixedCameracheckNum.Address, (Int16)systemConfiguration.FixedCameracheckNum);

            var res = await plc.WriteNodesAsync(nodeValues);
        }

        /// <summary>
        /// 注册需要监控的PLC地址
        /// </summary>
        public void RegisterPlcMonitorAddress()
        {
            var addressConfig = _configService.GetPlcAddresses();
            var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
            if (plc == null || !plc.IsConnected) return;

            //PLC地址数组
            List<string> monitorNodeIds = new List<string>()
            {
                addressConfig.In_DowmCameraExe.Address,
                addressConfig.In_UpCameraPickExe.Address,
                addressConfig.In_UpCameraPutExe.Address,
                addressConfig.In_UPCameracheckExe.Address,
                addressConfig.In_FixedCameraPickExe.Address,
                addressConfig.In_FixedCameraPutExe.Address,
                addressConfig.In_FixedCameracheckExe.Address,
                addressConfig.In_WorkStart.Address,
                addressConfig.In_WorkDone.Address,
                addressConfig.In_MesCheck.Address,
                addressConfig.In_RequestPosition.Address,
                addressConfig.AutoRunning.Address,
                addressConfig.ManualMode.Address,
                addressConfig.ClearMode.Address,
            };
            for (int i = 0; i < 10; i++)
            {
                monitorNodeIds.Add(string.Format(addressConfig.In_MesCheck.Address, i));
            }
            //订阅PLC地址变化
            plc.SubscribeNodes("AutoSensor", monitorNodeIds, PlcCommandTrigger,OpcUaSubscriptionMode.CustomPolling);
        }

        /// <summary>
        /// 写入点位信息给PLC
        /// </summary>
        /// <returns></returns>
        public async Task WritePositionToPlcAsync()
        {
            var addressConfig = _configService.GetPlcAddresses();
            var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
            if (plc == null || !plc.IsConnected) return;
            var current = _productService.GetCurrentProduct();
            if (current == null) return;
            if (current.PickCameraPoints != null && current.PickCameraPoints.Count > 0)
            {
                foreach (var item in current.PickCameraPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_PickCamera, plc);
                }
            }

            if (current.PickPoints != null && current.PickPoints.Count > 0)
            {
                foreach (var item in current.PickPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_Pick, plc);
                }
            }
            if (current.SecPosCameraPoints != null && current.SecPosCameraPoints.Count > 0)
            {
                foreach (var item in current.SecPosCameraPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_SecPosCamera, plc);
                }
            }
            if (current.ScrewCameraPoints != null && current.ScrewCameraPoints.Count > 0)
            {
                foreach (var item in current.ScrewCameraPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_ScrewCamera, plc);
                }
            }
            //if (current.ScrewPoints != null && current.ScrewPoints.Count > 0)
            //{
            //    foreach (var item in current.ScrewPoints)
            //    {
            //        await item.WriteToPlcAddress(addressConfig.Out_Screw, plc);
            //    }
            //    await plc.WriteNodeAsync(addressConfig.Out_WorkNum.Address, (Int16)current.ScrewPoints.Count);
            //}
            if (current.CheckCameraPoints != null && current.CheckCameraPoints.Count > 0)
            {
                foreach (var item in current.CheckCameraPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_CheckCamera, plc);
                }
            }

            if (current.AoiPoints != null && current.AoiPoints.Count > 0)
            {
                await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickNum.Address, (Int16)current.AoiPoints.Count);
                foreach (var item in current.AoiPoints)
                {
                    await item.WriteToPlcAddress(addressConfig.Out_AoiCamera, plc);
                }
            }
            else
            {
                await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickNum.Address, 0);
            }

        }

        PointF[] DowmCameraResults = new PointF[10];
        PointF[] UpCameraPutResults = new PointF[10];

        bool _LastDowmCameraExe = false;
        bool _LastScrewTeachExe = false;
        bool _LastUpCameraPickExe = false;
        bool _LastUpCameraPutExe = false;
        bool _LastUPCameracheckExe = false;
        bool _LastFixedCameraPickExe = false;
        bool _LastFixedCameraPutExe = false;
        bool _LastFixedCameracheckExe = false;
        public bool _LastAutoRunning = false;
        public bool _LastManualMode = false;
        bool _LastClearMode = false;
        Int16 _LastWorkStart = 0;
        Int16 _LastWorkDone = 0;
        Int16 _LastRequestPosition = 0;
        Int16[] _LastMesCheck = new Int16[10];
        Int16 _LastPickINC = 0;
        DateTime[] _LastMesCheckTime = new DateTime[10];
        List<Task<(bool IsSucceed, bool[] Result, string Message)>> _PrcTaskList = new List<Task<(bool IsSucceed, bool[] Result, string Message)>>();
        List<Task<(bool IsSucceed, ICogImage[] Images, string Message, int cameraIndex, Guid procedureId)>> _ImageTaskList = new List<Task<(bool IsSucceed, ICogImage[] Images, string Message, int cameraIndex, Guid procedureId)>>();

        private readonly object _stateLock = new object();

        /// <summary>
        /// PLC命令触发时
        /// </summary>
        /// <param name="tuple"></param>
        private async void PlcCommandTrigger((string key, string nodeId, object value) tuple)
        {
            try
            {
                if (tuple.key != "AutoSensor")
                {
                    return;
                }

                var addressConfig = _configService.GetPlcAddresses();
                var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
                if (plc == null || !plc.IsConnected) return;
                // 获取当前产品
                var currentProduct = _productService.GetCurrentProduct();
                if (currentProduct == null)
                {
                    return;
                }

                ////获取产品编码
                //_productService.CurrentProductCode = currentProduct.Name;
                //string productCode = plc.ReadNode<string>(addressConfig.In_Code.Address);
                ////如果产品编码为空，则以当前的时间戳作为编码
                //if (string.IsNullOrEmpty(productCode))
                //{
                //    productCode = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                //}

                // 写入3D相机长度
                if (addressConfig.In_UPCameracheckExe.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is bool state)
                    {
                        if (_LastUPCameracheckExe != state)
                        {
                            _LastUPCameracheckExe = state;
                        }
                        else
                        {
                            return;
                        }

                        if (state)
                        {
                            SendTaskMessage($"写入3D相机长度...", MessageLevel.Debug);
                            //相机的编号
                            //Int16 cameraIndex = plc.ReadNode<Int16>(addressConfig.In_FixedCameracheckNum.Address);
                            // 读取相机编号

                            Int16 cameraIndex = plc.ReadNode<Int16>(addressConfig.In_FixedCameracheckNum.Address);
                            SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);

                            // 找到对应编号的 PlcPoint
                            var targetPoint = currentProduct.AoiPoints?.FirstOrDefault(p => p.Number == cameraIndex);
                            if (targetPoint == null)
                            {
                                SendTaskMessage($"未找到 AOI 点位，编号：{cameraIndex}", MessageLevel.Alarm);
                                await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)2);
                                return;
                            }
                           

                            SetProducts(new int[] { targetPoint.Camera_Product1, targetPoint.Camera_Product2, targetPoint.Camera_Product3, targetPoint.Camera_Product4 });

                            SetBatchPoints(new int[] { targetPoint.Camera_Data1, targetPoint.Camera_Data2, targetPoint.Camera_Data3, targetPoint.Camera_Data4 });

                            await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)1);
                        }
                        else
                        {
                            SendTaskMessage($"写入3D相机长度信号已关闭", MessageLevel.Alarm);
                            await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)0);
                        }
                    }
                }
                // 发送点位个数
                else if (addressConfig.In_RequestPosition.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is Int16 state)
                    {
                        if (_LastRequestPosition != state)
                        {
                            _LastRequestPosition = state;
                        }
                        else
                        {
                            return;
                        }
                        if (state == 1)
                        {
                            var current = _productService.GetCurrentProduct();
                            if (current == null) return;
                            await plc.WriteNodeAsync(addressConfig.Out_CameraDone.Address, (Int16)1);
                            await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickNum.Address, (Int16)current.AoiPoints.Count);
                        }
                        else
                        {
                            SendTaskMessage($"多相机坐标合并请求已结束或被取消，state={state}", MessageLevel.Alarm);
                            await plc.WriteNodeAsync(addressConfig.Out_CameraDone.Address, (Int16)0);
                        }
                    }
                }

                // 固定相机检测拍照
                else if (addressConfig.In_FixedCameracheckExe.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is bool state)
                    {
                        if (_LastFixedCameracheckExe != state)
                        {
                            _LastFixedCameracheckExe = state;
                        }
                        else
                        {
                            return;
                        }
                        if (state)
                        {
                            LockResult lockResult = new LockResult();
                            lockResult.TimeStart = DateTime.Now;
                            SendTaskMessage($"触发固定相机检测拍照...", MessageLevel.Debug);
                            // 读取相机编号
                            Int16 cameraIndex = plc.ReadNode<Int16>(addressConfig.In_FixedCameracheckNum.Address);
                            SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);

                            // 找到对应编号的 PlcPoint
                            var targetPoint = currentProduct.AoiPoints?.FirstOrDefault(p => p.Number == cameraIndex);
                            if (targetPoint == null)
                            {
                                SendTaskMessage($"未找到 AOI 点位，编号：{cameraIndex}", MessageLevel.Alarm);
                                await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)2);
                                return;
                            }

                            // 收集要执行的流程 id（仅添加大于0的）
                            var procIds = new List<Guid>();
                            try
                            {
                                if (targetPoint.CameraProcedureId1 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId1)) procIds.Add(targetPoint.CameraProcedureId1);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId2 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId2)) procIds.Add(targetPoint.CameraProcedureId2);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId3 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId3)) procIds.Add(targetPoint.CameraProcedureId3);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId4 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId4)) procIds.Add(targetPoint.CameraProcedureId4);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId5 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId5)) procIds.Add(targetPoint.CameraProcedureId5);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId6 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId6)) procIds.Add(targetPoint.CameraProcedureId6);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId7 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId7)) procIds.Add(targetPoint.CameraProcedureId7);
                            }
                            catch { }
                            try
                            {
                                if (targetPoint.CameraProcedureId8 != Guid.Empty && !procIds.Contains(targetPoint.CameraProcedureId8)) procIds.Add(targetPoint.CameraProcedureId8);
                            }
                            catch { }
                            var sysConfig = _configService.GetSystemConfiguration();
                            if (sysConfig.ScannerUse == true && cameraIndex == 1 && sysConfig.CodeUse2 == true)
                            {
                                ScanValue = "";
                                _scanDoneEvent.Reset(); // 重要：先关门

                                await Scan_Client.SendAsync("T\r\n");

                                // 等待扫码结果，最多 3 秒
                                bool scanOk = await Task.Run(() => _scanDoneEvent.Wait(3000));

                                if (!scanOk || ScanValue.IsNullOrWhiteSpace())
                                {
                                    SendTaskMessage("二维码拍照失败或超时", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (short)3);
                                    return;
                                }

                                code = ScanValue;
                                SendTaskMessage($"扫码成功，SN:{code}", MessageLevel.Info);
                                //这里缺少从MES获取产品配方的内容，需要补充
                                _LastMesCheckTime[0] = (await _mesService.GetServerTimeAsync(code, 2)).Now;
                                //_LastMesCheckTime[1] = DateTime.Now;
                                LogHelper.WriteLogMes($"【mes开始QUERY】");
                                SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
                                (bool isSuccess, string response) = await _mesService.StationGetAsync(code, "", 2);//询问mes

                                if (isSuccess)
                                {
                                    //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                    LogHelper.WriteLogMes($"询问mes成功");
                                    SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);
                                    if (response != "MES功能未启用!")
                                    {
                                        string[] items = response.Split('\n');
                                        string snItem = items.FirstOrDefault(f => f.Contains("sn="));
                                        if (snItem != null)
                                        {
                                            ProductMainSN = snItem.Replace("sn=", "").Trim();
                                            _productService.CurrentProductCode = ProductMainSN;
                                            SendTaskMessage($"产品主sn:{ProductMainSN}", MessageLevel.Info);
                                        }
                                        string woItem = items.FirstOrDefault(f => f.Contains("wo="));
                                        if (woItem != null)
                                        {
                                            wo = woItem.Replace("wo=", "").Trim();
                                            SendTaskMessage($"产品wo:{wo}", MessageLevel.Info);
                                        }
                                        string modelItem = items.FirstOrDefault(f => f.Contains("model_num="));
                                        if (modelItem != null)
                                        {
                                            model_num = modelItem.Replace("model_num=", "").Trim();
                                            SendTaskMessage($"model_num：{model_num}", MessageLevel.Info);
                                        }
                                        string colorItem = items.FirstOrDefault(f => f.Contains("color="));
                                        if (colorItem != null)
                                        {
                                            color = colorItem.Replace("color=", "").Trim();
                                            SendTaskMessage($"color：{color}", MessageLevel.Info);
                                        }
                                        string ppidItem = items.FirstOrDefault(f => f.Contains("ppid="));
                                        if (ppidItem != null)
                                        {
                                            ppid = ppidItem.Replace("ppid=", "").Trim();
                                            SendTaskMessage($"ppid：{ppid}", MessageLevel.Info);
                                        }
                                        string stageItem = items.FirstOrDefault(f => f.Contains("stage="));
                                        if (stageItem != null)
                                        {
                                            stage = stageItem.Replace("stage=", "").Trim();
                                            SendTaskMessage($"stage：{revision}", MessageLevel.Info);
                                        }

                                    }
                                    LogHelper.WriteLogMes($"【mes结束QUERY】");
                                    SendTaskMessage($"mes结束QUERY", MessageLevel.Info);
                                    var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num, color);
                                    if (!string.IsNullOrEmpty(q))
                                    {
                                        ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                                        Guid productId = Guid.Empty;
                                        foreach (var itt in ProductList)
                                        {
                                            if (itt.Name == q)
                                            {
                                                productId = itt.ID;
                                                break;
                                            }
                                        }
                                        if (currentProduct.ID != productId)
                                        {
                                            //切换产品
                                            _productService.LoadProduct(productId);
                                            _productService.SetCurrentProduct(productId);
                                            await WritePositionToPlcAsync();
                                            SendTaskMessage($"切换产品成功", MessageLevel.Debug);
                                        }
                                    }


                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                                    return;
                                }
                                else
                                {
                                    //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);

                                    LogHelper.WriteLogMes($"询问mes失败");
                                    SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
                                    return;
                                }
                            }

                            if (sysConfig.ScannerUse == true && cameraIndex == 1 && sysConfig.CodeUse == true)
                            {
                                ScanValue = "";
                                _scanDoneEvent.Reset(); // 重要：先关门

                                await Scan_Client.SendAsync("T\r\n");

                                // 等待扫码结果，最多 3 秒
                                bool scanOk = await Task.Run(() => _scanDoneEvent.Wait(3000));

                                if (!scanOk || ScanValue.IsNullOrWhiteSpace())
                                {
                                    SendTaskMessage("二维码拍照失败或超时", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (short)3);
                                    return;
                                }

                                code = ScanValue;
                                SendTaskMessage($"扫码成功，SN:{code}", MessageLevel.Info);
                                //这里缺少从MES获取产品配方的内容，需要补充
                                _LastMesCheckTime[0] = (await _mesService.GetServerTimeAsync(code, 2)).Now;
                                LogHelper.WriteLogMes($"【mes开始QUERY】");
                                SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
                                //(bool isSuccess, string response) = await _mesService.StationGetAsync(code, "", 2);//询问mes
                                (bool isSuccess, string response) = await _mesService.StationGetExAsync(code, "", 2);//基于电池的SN获取产品SN，询问mes
                                if (isSuccess)
                                {
                                    //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改


                                    string ProductMainSN_Temp = "";
                                    LogHelper.WriteLogMes($"询问mes成功");
                                    SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);

                                    if (response != "MES功能未启用!")
                                    {
                                        string[] item = response.Split('\n');
                                        string snItem = item.FirstOrDefault(f => f.Contains("sn="));
                                        if (snItem != null)
                                        {
                                            ProductMainSN_Temp = snItem.Replace("sn=", "").Trim();
                                            SendTaskMessage($"sn：{ProductMainSN_Temp}", MessageLevel.Info);
                                        }
                                    }
                                    LogHelper.WriteLogMes($"询问mes成功");
                                    SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);

                                    //20260214,特别版（电池组装）
                                    (bool isSuccess2, string response2) = await _mesService.StationGetAsync(ProductMainSN_Temp, "", 2);//询问mes
                                    if (isSuccess2)
                                    {
                                        LogHelper.WriteLogMes($"询问mes成功");
                                        SendTaskMessage($"询问mes成功:{response2}", MessageLevel.Debug);

                                        if (response2 != "MES功能未启用!")
                                        {
                                            string[] item = response2.Split('\n');

                                            string snItem = item.FirstOrDefault(f => f.Contains("sn="));
                                            if (snItem != null)
                                            {
                                                ProductMainSN = snItem.Replace("sn=", "").Trim();
                                                _productService.CurrentProductCode = ProductMainSN;
                                                SendTaskMessage($"产品主sn:{ProductMainSN}", MessageLevel.Info);
                                            }
                                            string woItem = item.FirstOrDefault(f => f.Contains("wo="));
                                            if (woItem != null)
                                            {
                                                wo = woItem.Replace("wo=", "").Trim();
                                                SendTaskMessage($"产品wo:{wo}", MessageLevel.Info);
                                            }
                                            string modelItem = item.FirstOrDefault(f => f.Contains("model_num="));
                                            if (modelItem != null)
                                            {
                                                model_num = modelItem.Replace("model_num=", "").Trim();
                                                SendTaskMessage($"model_num：{model_num}", MessageLevel.Info);
                                            }
                                            string colorItem = item.FirstOrDefault(f => f.Contains("color="));
                                            if (colorItem != null)
                                            {
                                                color = colorItem.Replace("color=", "").Trim();
                                                SendTaskMessage($"color：{color}", MessageLevel.Info);
                                            }
                                            string ppidItem = item.FirstOrDefault(f => f.Contains("ppid="));
                                            if (ppidItem != null)
                                            {
                                                ppid = ppidItem.Replace("ppid=", "").Trim();
                                                SendTaskMessage($"ppid：{ppid}", MessageLevel.Info);
                                            }
                                            string stageItem = item.FirstOrDefault(f => f.Contains("stage="));
                                            if (stageItem != null)
                                            {
                                                stage = stageItem.Replace("stage=", "").Trim();
                                                SendTaskMessage($"stage：{revision}", MessageLevel.Info);
                                            }
                                        }
                                        LogHelper.WriteLogMes($"第二次询问mes成功");
                                        SendTaskMessage($"第二次询问mes成功:{response2}", MessageLevel.Debug);

                                        var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num, color);
                                        if (!string.IsNullOrEmpty(q))
                                        {
                                            ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                                            Guid productId = Guid.Empty;
                                            foreach (var itt in ProductList)
                                            {
                                                if (itt.Name == q)
                                                {
                                                    productId = itt.ID;
                                                    break;
                                                }
                                            }
                                            if (currentProduct.ID != productId)
                                            {
                                                //切换产品
                                                _productService.LoadProduct(productId);
                                                _productService.SetCurrentProduct(productId);
                                                await WritePositionToPlcAsync();
                                                SendTaskMessage($"切换产品成功", MessageLevel.Debug);
                                            }
                                        }


                                        await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                                    }
                                    else
                                    {
                                        LogHelper.WriteLogMes($"第二次询问mes失败");
                                        SendTaskMessage($"第二次询问mes失败:{response2}", MessageLevel.Error);

                                        await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);
                                    }
                                }
                                else
                                {
                                    //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);

                                    LogHelper.WriteLogMes($"询问mes失败");
                                    SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
                                }
                                return;
                            }


                            if (procIds.Count == 0 && cameraIndex != currentProduct.PhotoCountStop)
                            {
                                SendTaskMessage($"Point#{cameraIndex} 未配置任何视觉流程 (CameraProcedureId1/2/3)", MessageLevel.Alarm);
                                await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)2);
                                return;
                            }

                            var cameraProcedures = currentProduct.CameraProcedures;
                            if (cameraProcedures == null || cameraProcedures.Count == 0)
                            {
                                if(cameraIndex != currentProduct.PhotoCountStop)
                                {
                                    SendTaskMessage($"当前产品未配置 CameraProcedures，无法执行视觉流程", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)2);
                                    return;
                                }
                                
                            }

                            if (cameraIndex == currentProduct.PhotoCount)
                            {
                                _PrcTaskList.Clear();

                                lock (_stateLock)
                                {
                                    lockResultsAll.Clear();
                                }
                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    _eventAggregator.GetEvent<LockResetNotification>().Publish();
                                });
                            }


                            if (sysConfig.CodeUse == true && cameraIndex == 1)
                            {
                                var cts = new CancellationTokenSource();
                                // CameraProcedureId 存储的是具体的视觉流程 Id（ProcedureModel.Id），
                                // 需要在所有 CameraProcedures 的 ProcedureModels 中查找匹配的流程。
                                ProcedureModel selectedProcedure = null;
                                try
                                {
                                    cameraProcedures = currentProduct.CameraProcedures;

                                    if (cameraProcedures != null)
                                    {
                                        foreach (var cp in cameraProcedures)
                                        {
                                            if (cp?.ProcedureModels == null) continue;
                                            selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == targetPoint.CameraProcedureId1);
                                            if (selectedProcedure != null) break;
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                                }

                                if (selectedProcedure == null)
                                {
                                    SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{cameraIndex} ProcedureId={targetPoint.CameraProcedureId1}", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)2);
                                    return;
                                }

                                if (selectedProcedure.Id == currentProduct.FixedDownCameraProcedureId && sysConfig.TurnOnAllLightUse == true)
                                {
                                    await _remoteCommandService.SetLightBeforePhoto(selectedProcedure);
                                }
                                var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint2(selectedProcedure, null, null, cts.Token);

                                if (visionResult.IsSucceed)
                                {
                                    code = visionResult.X.ToUpper();

                                    SendTaskMessage($"扫码成功，SN:{code}", MessageLevel.Info);
                                    //这里缺少从MES获取产品配方的内容，需要补充
                                    _LastMesCheckTime[0] = (await _mesService.GetServerTimeAsync(code, 2)).Now;
                                    LogHelper.WriteLogMes($"【mes开始QUERY】");
                                    SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
                                    //(bool isSuccess, string response) = await _mesService.StationGetAsync(code, "", 2);//询问mes
                                    (bool isSuccess, string response) = await _mesService.StationGetExAsync(code, "", 2);//基于电池的SN获取产品SN，询问mes
                                    if (isSuccess)
                                    {
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改


                                        string ProductMainSN_Temp = "";
                                        LogHelper.WriteLogMes($"询问mes成功");
                                        SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);

                                        if (response != "MES功能未启用!")
                                        {
                                            string[] item = response.Split('\n');

                                            string snItem = item.FirstOrDefault(f => f.Contains("sn="));
                                            if (snItem != null)
                                            {
                                                ProductMainSN_Temp = snItem.Replace("sn=", "").Trim();
                                                SendTaskMessage($"sn：{ProductMainSN_Temp}", MessageLevel.Info);
                                            }
                                        }
                                        LogHelper.WriteLogMes($"询问mes成功");
                                        SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);

                                        //20260214,特别版（电池组装）
                                        (bool isSuccess2, string response2) = await _mesService.StationGetAsync(ProductMainSN_Temp, "", 2);//询问mes
                                        if (isSuccess2)
                                        {
                                            LogHelper.WriteLogMes($"询问mes成功");
                                            SendTaskMessage($"询问mes成功:{response2}", MessageLevel.Debug);

                                            if (response2 != "MES功能未启用!")
                                            {
                                                string[] item = response2.Split('\n');


                                                string snItem = item.FirstOrDefault(f => f.Contains("sn="));
                                                if (snItem != null)
                                                {
                                                    ProductMainSN = snItem.Replace("sn=", "").Trim();
                                                    _productService.CurrentProductCode = ProductMainSN;
                                                    SendTaskMessage($"产品主sn:{ProductMainSN}", MessageLevel.Info);
                                                }
                                                string woItem = item.FirstOrDefault(f => f.Contains("wo="));
                                                if (woItem != null)
                                                {
                                                    wo = woItem.Replace("wo=", "").Trim();
                                                    SendTaskMessage($"产品wo:{wo}", MessageLevel.Info);
                                                }
                                                string modelItem = item.FirstOrDefault(f => f.Contains("model_num="));
                                                if (modelItem != null)
                                                {
                                                    model_num = modelItem.Replace("model_num=", "").Trim();
                                                    SendTaskMessage($"model_num：{model_num}", MessageLevel.Info);
                                                }
                                                string colorItem = item.FirstOrDefault(f => f.Contains("color="));
                                                if (colorItem != null)
                                                {
                                                    color = colorItem.Replace("color=", "").Trim();
                                                    SendTaskMessage($"color：{color}", MessageLevel.Info);
                                                }
                                                string ppidItem = item.FirstOrDefault(f => f.Contains("ppid="));
                                                if (ppidItem != null)
                                                {
                                                    ppid = ppidItem.Replace("ppid=", "").Trim();
                                                    SendTaskMessage($"ppid：{ppid}", MessageLevel.Info);
                                                }
                                                string stageItem = item.FirstOrDefault(f => f.Contains("stage="));
                                                if (stageItem != null)
                                                {
                                                    stage = stageItem.Replace("stage=", "").Trim();
                                                    SendTaskMessage($"stage：{revision}", MessageLevel.Info);
                                                }
                                            }
                                            LogHelper.WriteLogMes($"第二次询问mes成功");
                                            SendTaskMessage($"第二次询问mes成功:{response2}", MessageLevel.Debug);

                                            var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num, color);
                                            if (!string.IsNullOrEmpty(q))
                                            {
                                                ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                                                Guid productId = Guid.Empty;
                                                foreach (var itt in ProductList)
                                                {
                                                    if (itt.Name == q)
                                                    {
                                                        productId = itt.ID;
                                                        break;
                                                    }
                                                }
                                                if (currentProduct.ID != productId)
                                                {
                                                    //切换产品
                                                    _productService.LoadProduct(productId);
                                                    _productService.SetCurrentProduct(productId);
                                                    await WritePositionToPlcAsync();
                                                    SendTaskMessage($"切换产品成功", MessageLevel.Debug);
                                                }
                                            }

                                            await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                                        }
                                        else
                                        {
                                            LogHelper.WriteLogMes($"第二次询问mes失败");
                                            SendTaskMessage($"第二次询问mes失败:{response2}", MessageLevel.Error);

                                            await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);
                                        }
                                    }
                                    else
                                    {
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                        await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);

                                        LogHelper.WriteLogMes($"询问mes失败");
                                        SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
                                    }
                                }
                                else
                                {
                                    SendTaskMessage($"扫码失败", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);
                                }
                                return;
                            }

                            if (sysConfig.CodeUse2 == true && cameraIndex == 1)
                            {
                                var cts = new CancellationTokenSource();
                                // CameraProcedureId 存储的是具体的视觉流程 Id（ProcedureModel.Id），
                                // 需要在所有 CameraProcedures 的 ProcedureModels 中查找匹配的流程。
                                ProcedureModel selectedProcedure = null;
                                try
                                {
                                    cameraProcedures = currentProduct.CameraProcedures;

                                    if (cameraProcedures != null)
                                    {
                                        foreach (var cp in cameraProcedures)
                                        {
                                            if (cp?.ProcedureModels == null) continue;
                                            selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == targetPoint.CameraProcedureId1);
                                            if (selectedProcedure != null) break;
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                                }

                                if (selectedProcedure == null)
                                {
                                    SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{cameraIndex} ProcedureId={targetPoint.CameraProcedureId1}", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)2);
                                    return;
                                }
                                var ctsAll = new CancellationTokenSource();

                                if (selectedProcedure.Id == currentProduct.FixedDownCameraProcedureId && sysConfig.TurnOnAllLightUse == true)
                                {
                                    await _remoteCommandService.SetLightBeforePhoto(selectedProcedure);
                                }
                                var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint2(selectedProcedure, null, null, ctsAll.Token);
                                if (visionResult.IsSucceed)
                                {
                                    code = visionResult.X;
                                    ProductMainSN = visionResult.X;
                                    SendTaskMessage($"扫码成功，SN:{code}", MessageLevel.Info);
                                    //这里缺少从MES获取产品配方的内容，需要补充
                                    _LastMesCheckTime[0] = (await _mesService.GetServerTimeAsync(code, 2)).Now;
                                    //_LastMesCheckTime[1] = DateTime.Now;
                                    LogHelper.WriteLogMes($"【mes开始QUERY】");
                                    SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
                                    (bool isSuccess, string response) = await _mesService.StationGetAsync(code, "", 2);//询问mes

                                    if (isSuccess)
                                    {
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                        LogHelper.WriteLogMes($"询问mes成功");
                                        SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);
                                        if (response != "MES功能未启用!")
                                        {
                                            string[] items = response.Split('\n');

                                            string snItem = items.FirstOrDefault(f => f.Contains("sn="));
                                            if (snItem != null)
                                            {
                                                ProductMainSN = snItem.Replace("sn=", "").Trim();
                                                _productService.CurrentProductCode = ProductMainSN;
                                                SendTaskMessage($"产品主sn:{ProductMainSN}", MessageLevel.Info);
                                            }
                                            string woItem = items.FirstOrDefault(f => f.Contains("wo="));
                                            if (woItem != null)
                                            {
                                                wo = woItem.Replace("wo=", "").Trim();
                                                SendTaskMessage($"产品wo:{wo}", MessageLevel.Info);
                                            }
                                            string modelItem = items.FirstOrDefault(f => f.Contains("model_num="));
                                            if (modelItem != null)
                                            {
                                                model_num = modelItem.Replace("model_num=", "").Trim();
                                                SendTaskMessage($"model_num：{model_num}", MessageLevel.Info);
                                            }
                                            string colorItem = items.FirstOrDefault(f => f.Contains("color="));
                                            if (colorItem != null)
                                            {
                                                color = colorItem.Replace("color=", "").Trim();
                                                SendTaskMessage($"color：{color}", MessageLevel.Info);
                                            }
                                            string ppidItem = items.FirstOrDefault(f => f.Contains("ppid="));
                                            if (ppidItem != null)
                                            {
                                                ppid = ppidItem.Replace("ppid=", "").Trim();
                                                SendTaskMessage($"ppid：{ppid}", MessageLevel.Info);
                                            }
                                            string stageItem = items.FirstOrDefault(f => f.Contains("stage="));
                                            if (stageItem != null)
                                            {
                                                stage = stageItem.Replace("stage=", "").Trim();
                                                SendTaskMessage($"stage：{revision}", MessageLevel.Info);
                                            }
                                        }
                                        LogHelper.WriteLogMes($"【mes结束QUERY】");
                                        SendTaskMessage($"mes结束QUERY", MessageLevel.Info);

                                        var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num, color);
                                        if (!string.IsNullOrEmpty(q))
                                        {
                                            ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                                            Guid productId = Guid.Empty;
                                            foreach (var itt in ProductList)
                                            {
                                                if (itt.Name == q)
                                                {
                                                    productId = itt.ID;
                                                    break;
                                                }
                                            }
                                            if (currentProduct.ID != productId)
                                            {
                                                //切换产品
                                                _productService.LoadProduct(productId);
                                                _productService.SetCurrentProduct(productId);
                                                await WritePositionToPlcAsync();
                                                SendTaskMessage($"切换产品成功", MessageLevel.Debug);
                                            }
                                        }

                                        await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                                        return;
                                    }
                                    else
                                    {
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                        await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);

                                        LogHelper.WriteLogMes($"询问mes失败");
                                        SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
                                    }
                                }
                                else
                                {
                                    SendTaskMessage($"扫码失败", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)3);
                                }
                                return;
                            }

                            _ImageTaskList.Clear();
                            
                            foreach (var prcId in procIds)
                            {
                                ProcedureModel selectedProcedure = null;
                                try
                                {
                                    foreach (var cp in cameraProcedures)
                                    {
                                        if (cp?.ProcedureModels == null) continue;
                                        selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == prcId);

                                        if (selectedProcedure != null) break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                                }
                                if (sysConfig.TurnOnAllLightUse == false)
                                {
                                    await _remoteCommandService.SetLightBeforePhoto(selectedProcedure);
                                }
                               
                                if(sysConfig.PhotosUse==true)
                                {
                                    bool Is3dPhoto = Is3D(prcId);
                                    var tt=await GrabImageEx(cameraIndex, prcId, Is3dPhoto);
                                    if(tt.IsSucceed==false)
                                    {
                                        SendTaskMessage($"图像采集失败！{cameraIndex}: {prcId}", MessageLevel.Alarm);
                                        return;
                                    }
                                    await ExecuteProcedureAsync(cameraIndex, prcId, tt.imges, Is3dPhoto);
                                }
                                else
                                {
                                    bool Is3dPhoto = Is3D(prcId);
                                    _ImageTaskList.Add(GrabImageEx(cameraIndex, prcId, Is3dPhoto));
                                }
                                 
                                if (sysConfig.TurnOnAllLightUse == false)
                                {
                                    await _remoteCommandService.TurnOffLightAfterPhoto(selectedProcedure);
                                }
                            }
                            if (cameraIndex != currentProduct.PhotoCountStop)
                            {
                                //直接放行，执行下一个检测点
                                await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                            }
                            if (_ImageTaskList.Count > 0)//如果2D取图有队列
                            {
                                var ImageTaskResults = await Task.WhenAll(_ImageTaskList);
                                foreach (var item in ImageTaskResults)
                                {
                                    if (item.IsSucceed)
                                    {
                                        bool Is3d = Is3D(item.procedureId);
                                        _PrcTaskList.Add(ExecuteProcedureAsync(item.cameraIndex, item.procedureId, item.Images, Is3d));
                                        //_PrcTaskList.Add(ExecuteProcedureAsync(cameraIndex, prcId, imageData.imges));
                                    }
                                    else
                                    {
                                        SendTaskMessage($"图像采集失败！{item.cameraIndex}: {item.procedureId}", MessageLevel.Alarm);
                                    }
                                }
                            }
                            //如果最后一个拍照点，则需要等待前面所有的拍照处理完成
                            if (cameraIndex == currentProduct.PhotoCountStop)
                            {
                                //结果输出
                                bool resultFlog = true;
                                if (sysConfig.PhotosUse == true)
                                {
                                    foreach (var item in lockResultsAll)
                                    {
                                        if (item.PhotoPassed=="NG")
                                        {
                                            resultFlog = false;
                                            break;
                                        }
                                        
                                    }
                                }
                                else
                                {
                                    //等待所有的图像处理流程处理完成
                                    var results = await Task.WhenAll(_PrcTaskList);

                                    
                                    foreach (var item in results)
                                    {
                                        if (!item.IsSucceed || item.Result == null)
                                        {
                                            resultFlog = false;
                                            break;
                                        }
                                        else
                                        {
                                            foreach (var item_1 in item.Result)
                                            {
                                                if (!item_1)
                                                {
                                                    resultFlog = false;
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                                

                                //全部OK
                                if (resultFlog)
                                {
                                    SendTaskMessage($"检测执行成功", MessageLevel.Debug);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
                                }
                                //存在NG
                                else
                                {
                                    SendTaskMessage($"检测执行失败", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)2);
                                }
                            }
                        }
                        else
                        {
                            SendTaskMessage($"触发固定相机检测拍照信号已关闭", MessageLevel.Alarm);
                            await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)0);
                        }
                    }
                }

                //切换成自动运行模式
                else if (addressConfig.AutoRunning.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is bool state)
                    {
                        if (_LastAutoRunning != state)
                        {
                            _LastAutoRunning = state;
                        }
                        else
                        {
                            return;
                        }
                        if (state)
                        {
                            CurrentRunStatus();
                            SendTaskMessage("收到切换成自动模式", MessageLevel.Info);
                        }
                    }
                }
                //切换成维修模式
                else if (addressConfig.ManualMode.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is bool state)
                    {
                        if (_LastManualMode != state)
                        {
                            _LastManualMode = state;
                        }
                        else
                        {
                            return;
                        }
                        if (state)
                        {
                            ClearModeBackground = System.Windows.Media.Brushes.White;
                            RunModelBackground = System.Windows.Media.Brushes.White;
                            ManualModeBackground = System.Windows.Media.Brushes.Orange;
                            SendTaskMessage("收到切换成维修模式", MessageLevel.Info);
                        }
                    }
                }
                //切换成流线模式
                else if (addressConfig.ClearMode.Address.Contains(tuple.nodeId))
                {
                    if (tuple.value is bool state)
                    {
                        if (_LastClearMode != state)
                        {
                            _LastClearMode = state;
                        }
                        else
                        {
                            return;
                        }
                        if (state)
                        {
                            ClearModeBackground = System.Windows.Media.Brushes.Yellow;
                            RunModelBackground = System.Windows.Media.Brushes.White;
                            ManualModeBackground = System.Windows.Media.Brushes.White;
                            SendTaskMessage("收到切换成流线模式", MessageLevel.Info);
                        }
                    }
                }
                // 过站检查
                else
                {
                    for (int i = 0; i < 10; i++)
                    {
                        if (string.Format(addressConfig.In_MesCheck.Address, i).Contains(tuple.nodeId))
                        {
                            if (tuple.value is Int16 state)
                            {
                                if (_LastMesCheck[i] != state)
                                {
                                    _LastMesCheck[i] = state;
                                }
                                else
                                {
                                    return;
                                }
                                var sysConfig = _configService.GetSystemConfiguration();
                                if (sysConfig.CodeUse == true && state == 1)
                                {
                                    await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);
                                    return;
                                }
                                if (sysConfig.CodeUse2 == true && state == 1)
                                {
                                    await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);
                                    return;
                                }
                                if (sysConfig.CodeUse == false && sysConfig.CodeUse2 == false)
                                {
                                    code = plc.ReadNode<string>(string.Format(addressConfig.In_Code.Address, i));
                                }
                                var homeview = _container.Resolve<HomeViewModel>();

                                //过站检查
                                if (state == 1)
                                {
                                    //这里缺少从MES获取产品配方的内容，需要补充
                                    _LastMesCheckTime[i] = (await _mesService.GetServerTimeAsync(code, 2)).Now;
                                    if (homeview.IsNoCode == false)
                                    {
                                        var device = _configService.GetDeviceInfo(0);
                                        code = device.XnSN;
                                    }
                                    LogHelper.WriteLogMes($"【mes开始QUERY】");
                                    SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
                                    ShowMes_Query = false;
                                    (bool isSuccess, string response) = await _mesService.StationGetAsync(code, "", 2);//询问mes


                                    if (i == 0)
                                    {
                                        SendTaskMessage($"收到当前过站检查请求（当站是否生产）...", MessageLevel.Debug);
                                    }
                                    else
                                    {
                                        SendTaskMessage($"收到{i}过站检查请求（当站是否生产）...", MessageLevel.Debug);
                                    }
                                    if (isSuccess)
                                    {

                                        string[] item = response.Split('\n');
                                        //获取产品主sn和wo用于后续上传数据使用
                                        string snItem = item.FirstOrDefault(f => f.Contains("sn="));
                                        if (snItem != null)
                                        {
                                            ProductMainSN = snItem.Replace("sn=", "").Trim();
                                            if (i == 0)
                                            {
                                                _productService.CurrentProductCode = ProductMainSN;
                                            }
                                            SendTaskMessage($"产品主sn：{ProductMainSN[i]}", MessageLevel.Info);
                                        }
                                        string woItem = item.FirstOrDefault(f => f.Contains("wo="));
                                        if (woItem != null)
                                        {
                                            wo = woItem.Replace("wo=", "").Trim();
                                            SendTaskMessage($"工单信息：{wo[i]}", MessageLevel.Info);
                                        }
                                        string modelItem = item.FirstOrDefault(f => f.Contains("model_num="));
                                        if (modelItem != null)
                                        {
                                            model_num = modelItem.Replace("model_num=", "").Trim();
                                            SendTaskMessage($"model_num：{model_num}", MessageLevel.Info);
                                        }
                                        string colorItem = item.FirstOrDefault(f => f.Contains("color="));
                                        if (colorItem != null)
                                        {
                                            color = colorItem.Replace("color=", "").Trim();
                                            SendTaskMessage($"color：{color}", MessageLevel.Info);
                                        }
                                        string ppidItem = item.FirstOrDefault(f => f.Contains("ppid="));
                                        if (ppidItem != null)
                                        {
                                            ppid = ppidItem.Replace("ppid=", "").Trim();
                                            SendTaskMessage($"ppid：{ppid}", MessageLevel.Info);
                                        }
                                        string stageItem = item.FirstOrDefault(f => f.Contains("stage="));
                                        if (stageItem != null)
                                        {
                                            stage = stageItem.Replace("stage=", "").Trim();
                                            SendTaskMessage($"stage：{revision}", MessageLevel.Info);
                                        }
                                        ShowMes_Query = true;
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                        //切换产品
                                        if (i == 0)//i=0时才会切换产品
                                        {
                                            var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num, color);
                                            if (!string.IsNullOrEmpty(q))
                                            {
                                                ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                                                Guid productId = Guid.Empty;
                                                foreach (var itt in ProductList)
                                                {
                                                    if (itt.Name == q)
                                                    {
                                                        productId = itt.ID;
                                                        break;
                                                    }
                                                }
                                                if (currentProduct.ID != productId)
                                                {
                                                    //切换产品
                                                    _productService.LoadProduct(productId);
                                                    _productService.SetCurrentProduct(productId);
                                                    await WritePositionToPlcAsync();
                                                    SendTaskMessage($"切换产品成功", MessageLevel.Debug);
                                                }
                                            }
                                        }


                                        await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);

                                        LogHelper.WriteLogMes($"【mes结束QUERY】");
                                        SendTaskMessage($"mes结束QUERY", MessageLevel.Info);
                                        return;
                                    }
                                    else
                                    {
                                        //产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改

                                        await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)2);

                                        LogHelper.WriteLogMes($"询问mes失败");
                                        SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
                                    }
                                    LogHelper.WriteLogMes($"【mes结束QUERY】");
                                    SendTaskMessage($"mes结束QUERY", MessageLevel.Info);
                                }
                                // 上传本站数据
                                else if (state == 2)
                                {
                                    //获取当前工位的配置
                                    var stationConfig = _configService.GetDeviceInfo(0);

                                    List<DataFormCtq> DFC = new List<DataFormCtq>();
                                    SendTaskMessage($"收到{i}上传本站数据请求...", MessageLevel.Debug);

                                    //这里缺少上传MES的本站数据结果及开始和结束时间，需要补充
                                    //从服务器中获取当前时间
                                    var serverTimeResult = await _mesService.GetServerTimeAsync(ProductMainSN, 2);

                                    double ct = serverTimeResult.Now.Subtract(_LastMesCheckTime[i]).TotalSeconds;
                                    if (i == 0)
                                    {
                                        CTtime = ct;
                                    }

                                    //读取产品结果

                                    Int16 resultIndex = plc.ReadNode<Int16>(string.Format(addressConfig.In_Result.Address, i));
                                    SendTaskMessage($"读取plc结果{resultIndex}", MessageLevel.Debug);
                                    ShowMes_Result = resultIndex == 1 ? true : false;
                                    if (homeview.IsResultTrue == false)
                                    {
                                        resultIndex = 1;
                                    }
                                    //Int16 resultIndex = 1;

                                    //目前只记录当前站
                                    if (i == 0)
                                        await _systemDatabaseService.RecordProductionAsync(new ProductionRecord()
                                        {
                                            ProductName = currentProduct.Name,
                                            ProductCode = ProductMainSN,
                                            DeviceId = i,
                                            DeviceName = "",
                                            Category = resultIndex == 1 ? "OK" : "NG",
                                            Quantity = 1,
                                            Remark = $"TotalSeconds:{DateTime.UtcNow.Subtract(_LastMesCheckTime[i]).TotalSeconds.ToString("F2")}",
                                        });

                                    LogHelper.WriteLogMes($"【mes开始ADD】");
                                    SendTaskMessage($"mes开始ADD", MessageLevel.Info);

                                    StringBuilder submitDataError = new StringBuilder();
                                    foreach (var item in lockResultsAll)
                                    {
                                        if (item.PhotoPassed == "NG")
                                        {
                                            submitDataError.Append(item.PhotoName + "_Fail,");
                                        }
                                    }


                                    StringBuilder submitData = new StringBuilder();
                                    StringBuilder submitData2 = new StringBuilder();
                                    StringBuilder submitData3 = new StringBuilder();
                                    StringBuilder submitData4 = new StringBuilder();
                                    foreach (var item in lockResultsAll)
                                    {
                                        //if (submitData.Length < 3500)
                                        //{
                                        //    submitData.Append($"{item.PhotoName}={item.ResultData}");
                                        //}
                                        string data = $"{item.PhotoName}={item.ResultData}&";

                                        // 按顺序填满，不超过 3500 就加进去
                                        if (submitData.Length + data.Length <= 3500)
                                        {
                                            submitData.Append(data);
                                        }
                                        else if (submitData2.Length + data.Length <= 3500)
                                        {
                                            submitData2.Append(data);
                                        }
                                        else if (submitData3.Length + data.Length <= 3500)
                                        {
                                            submitData3.Append(data);
                                        }
                                        else if (submitData4.Length + data.Length <= 3500)
                                        {
                                            submitData4.Append(data);
                                        }
                                        else
                                        {
                                            SendTaskMessage($"上传数据数据超出4组最大限制", MessageLevel.Error);
                                        }

                                    }
                                    bool allSuccess = true;
                                    bool ok = false;

                                    if (homeview.IsResultTrue)
                                    {
                                        ShowMes_Result = true;
                                    }

                                    if (stationConfig.SaveCsvkeyData)
                                    {
                                       
                                        if (keyData != null)
                                        {
                                            ok = CheckKeyBoardValue(keyData, out string msg);
                                        }

                                        if (ok && resultIndex == 1 ? true : false && isValueOk)
                                        {
                                            ShowMes_Result = true;
                                        }
                                        else
                                        {
                                            ShowMes_Result = false;
                                        }
                                        if (homeview.IsResultTrue == true)
                                        {
                                            ShowMes_Result = true;
                                        }
                                    }
                                    
                                    //StringBuilder submitDataError2 = new StringBuilder();
                                    //foreach (var item in keyData)
                                    //{

                                    //    submitData.Append($"{item.Key}={item.Value}");

                                    //}
                                    //keyData.Clear();
                                    // ShowMes_Result = resultIndex == 1 ? true : false;

                                    //(bool isSuccess, string response) = await _mesService.SubmitGetAsync(ProductMainSN, "", submitData.ToString(), resultIndex == 1 ? true : false, _LastMesCheckTime[i], serverTimeResult.Now);
                                    if (submitData.Length > 0)
                                    {
                                        string data1 = submitData.ToString().TrimEnd('&');
                                        (bool isSuccess, string response) = await _mesService.SubmitGetAsync(0,ProductMainSN, "", submitData.ToString(), ShowMes_Result, submitDataError.ToString(), _LastMesCheckTime[i], serverTimeResult.Now);
                                        allSuccess &= isSuccess;
                                    }
                                    if (submitData2.Length > 0)
                                    {
                                        string data2 = submitData2.ToString().TrimEnd('&');
                                        (bool isSuccess, string response) = await _mesService.SubmitGetAsync(1, ProductMainSN, "", submitData2.ToString(), ShowMes_Result, submitDataError.ToString(), _LastMesCheckTime[i], serverTimeResult.Now);
                                        allSuccess &= isSuccess;
                                    }
                                    if (submitData3.Length > 0)
                                    {
                                        string data3 = submitData3.ToString().TrimEnd('&');
                                        (bool isSuccess, string response) = await _mesService.SubmitGetAsync(2, ProductMainSN, "", submitData3.ToString(), ShowMes_Result   , submitDataError.ToString(), _LastMesCheckTime[i], serverTimeResult.Now);
                                        allSuccess &= isSuccess;
                                    }
                                    if (submitData4.Length > 0)
                                    {
                                        string data4 = submitData4.ToString().TrimEnd('&');
                                        (bool isSuccess, string response) = await _mesService.SubmitGetAsync(3, ProductMainSN, "", submitData4.ToString(), ShowMes_Result, submitDataError.ToString(), _LastMesCheckTime[i], serverTimeResult.Now);
                                        allSuccess &= isSuccess;
                                    }


                                    if (allSuccess)
                                    {
                                        LogHelper.WriteLogMes($"上传mes成功");
                                        SendTaskMessage($"上传mes成功", MessageLevel.Debug);
                                    }
                                    else
                                    {
                                        LogHelper.WriteLogMes($"上传mes失败");
                                        SendTaskMessage($"上传mes失败", MessageLevel.Error);
                                    }
                                    await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)3);

                                    
                                    //是否保存当前的产品记录至CSV?
                                    if (stationConfig.SaveCsv)
                                    {
                                        string saveppid = "NA";
                                        if (stationConfig.SaveCsvPPID) saveppid = ppid;
                                        Dictionary<string, double> adjacentDiffDict = GetAdjacentDiffDict(keyData);
                                       // Dictionary<string, double> adjacentDiffDict1 = GetAdjacentDiffDict(keyData1);
                                        //判断锁付路径字符串是否为空，如果不为空则保存，否则不保存
                                        if (!string.IsNullOrEmpty(stationConfig.SaveCsvPath))
                                        {
                                            foreach (var item in lockResultsAll)
                                            {
                                                for (int k = 1; k <= 8; k++)
                                                {
                                                    if (item.PhotoName == "-" + "_" + k.ToString())
                                                    {
                                                        item.PhotoName = "'-" + "_" + k.ToString();
                                                    }
                                                    if (item.PhotoName == "=" + "_" + k.ToString())
                                                    {
                                                        item.PhotoName = "'=" + "_" + k.ToString();
                                                    }
                                                    //if (item.PhotoName=="-"+k.ToString())
                                                    //{
                                                    //    item.PhotoName = "_" + k.ToString();
                                                    //}
                                                }                                               
                                                DFC.Add(new DataFormCtq
                                                {
                                                    PPID = saveppid,
                                                    PROCESS_NAME = stationConfig.DataInfo.PROCESS_NAME,
                                                    PROCESS_START_TIME = _LastMesCheckTime[i].ToString("o"),
                                                    CTQ_NAME = item.PhotoName,
                                                    CTQ_VALUE = item.ResultData.Replace(",", ";"),
                                                    //CTQ_VALUEE=item.ResultData1,
                                                    CTQ_LSL = item.DownLimit,
                                                    CTQ_USL = item.UpLimit,
                                                    PROCESS_END_TIME = serverTimeResult.Now.ToString("o"),
                                                    SUPPLIER_NAME = stationConfig.DataInfo.SUPPLIER_NAME,
                                                    COMMODITY_TYPE = stationConfig.DataInfo.COMMODITY_TYPE,
                                                    REVISION = stage,//
                                                    WO = wo,//
                                                    MFG_LOT = stationConfig.DataInfo.MFG_LOT,//
                                                    MFG_ASSY_LINE = stationConfig.DataInfo.MFG_ASSY_LINE,
                                                    PROCESS_OUTCOME = item.PhotoPassed == "OK" ? "PASS" : "FAIL",
                                                    PROCESS_MACHINE_ID = stationConfig.DataInfo.PROCESS_MACHINE_ID,
                                                    CTQ_UNIT_OF_MEASURE = "mm",
                                                    ERROR_MESSAGE = item.PhotoPassed == "OK" ? "" : $"{item.PhotoName} OOS",
                                                    PD_ATTR_01 = ProductMainSN,//
                                                    PD_ATTR_02 = item.MidLimit,
                                                    PD_ATTR_03 = "",
                                                    PD_ATTR_04 = code,
                                                    PD_ATTR_05 = "",
                                                });                                      
                                            }
                                            if (stationConfig.SaveCsvkeyData)
                                            {
                                                foreach (var items in adjacentDiffDict)
                                                {
                                                    string pairkey = items.Key;
                                                    string diffvalue = items.Value.ToString("F3");
                                                    DFC.Add(new DataFormCtq
                                                    {
                                                        PPID = saveppid,
                                                        PROCESS_NAME = stationConfig.DataInfo.PROCESS_NAME,
                                                        PROCESS_START_TIME = _LastMesCheckTime[i].ToString("o"),
                                                        CTQ_NAME = pairkey,
                                                        CTQ_VALUE = diffvalue,
                                                        CTQ_LSL = "-0.3",
                                                        CTQ_USL = "0.3",
                                                        PROCESS_END_TIME = serverTimeResult.Now.ToString("o"),
                                                        SUPPLIER_NAME = stationConfig.DataInfo.SUPPLIER_NAME,
                                                        COMMODITY_TYPE = stationConfig.DataInfo.COMMODITY_TYPE,
                                                        REVISION = stage,//
                                                        WO = wo,//
                                                        MFG_LOT = stationConfig.DataInfo.MFG_LOT,//
                                                        MFG_ASSY_LINE = stationConfig.DataInfo.MFG_ASSY_LINE,
                                                        PROCESS_OUTCOME = ok ? "Pass" : "FAIL",
                                                        PROCESS_MACHINE_ID = stationConfig.DataInfo.PROCESS_MACHINE_ID,
                                                        CTQ_UNIT_OF_MEASURE = "mm",
                                                        ERROR_MESSAGE = ok ? "" : $"{diffvalue}",
                                                        PD_ATTR_01 = ProductMainSN,//
                                                        PD_ATTR_02 = "",
                                                        PD_ATTR_03 = "",
                                                        PD_ATTR_04 = code,
                                                        PD_ATTR_05 = "",
                                                    });
                                                }
                                                foreach (var items in keyData1)
                                                {
                                                    string pairkey1 = items.Key;
                                                    string diffvalue1 = items.Value.ToString("F3");
                                                    DFC.Add(new DataFormCtq
                                                    {
                                                        PPID = saveppid,
                                                        PROCESS_NAME = stationConfig.DataInfo.PROCESS_NAME,
                                                        PROCESS_START_TIME = _LastMesCheckTime[i].ToString("o"),
                                                        CTQ_NAME = pairkey1,
                                                        CTQ_VALUE = diffvalue1,
                                                        CTQ_LSL = "0",
                                                        CTQ_USL = "0.3",
                                                        PROCESS_END_TIME = serverTimeResult.Now.ToString("o"),
                                                        SUPPLIER_NAME = stationConfig.DataInfo.SUPPLIER_NAME,
                                                        COMMODITY_TYPE = stationConfig.DataInfo.COMMODITY_TYPE,
                                                        REVISION = stage,//
                                                        WO = wo,//
                                                        MFG_LOT = stationConfig.DataInfo.MFG_LOT,//
                                                        MFG_ASSY_LINE = stationConfig.DataInfo.MFG_ASSY_LINE,
                                                        PROCESS_OUTCOME = ok ? "Pass" : "FAIL",
                                                        PROCESS_MACHINE_ID = stationConfig.DataInfo.PROCESS_MACHINE_ID,
                                                        CTQ_UNIT_OF_MEASURE = "mm",
                                                        ERROR_MESSAGE = ok ? "" : $"{diffvalue1}",
                                                        PD_ATTR_01 = ProductMainSN,//
                                                        PD_ATTR_02 = "0.15",
                                                        PD_ATTR_03 = "",
                                                        PD_ATTR_04 = code,
                                                        PD_ATTR_05 = "",
                                                    });
                                                }
                                            }

                                            bool recordResult = RecordStationResult(i, DFC, ProductMainSN, serverTimeResult.Now.Subtract(_LastMesCheckTime[i]).TotalSeconds, _LastMesCheckTime[i], stationConfig.SaveCsvPath);
                                            //keyData.Clear();
                                            if (recordResult)
                                            {
                                                SendTaskMessage($"{i}:{stationConfig.DeviceName}产品记录保存成功", MessageLevel.Debug);
                                                //上传数据
                                                try
                                                {
                                                    if (stationConfig.EnableMES)
                                                    {
                                                        DateTime dt = DateTime.Now;
                                                        string filename = $"{ProductMainSN}_{dt.ToString("yyyyMMddHHmmss")}";
                                                        var device = _configService.GetDeviceInfo(i);
                                                        var config = _configService.GetSystemConfiguration();
                                                        string filePath = "";
                                                        (bool isSuc, string resp) = await _mesService.SendFtpFileAsync(ProductMainSN, filename);
                                                        if (isSuc)
                                                        {
                                                            LogHelper.WriteLogMes($"上传数据成功");
                                                            SendTaskMessage($"上传数据成功", MessageLevel.Debug);

                                                            //filePath = $"D:\\Image\\Recored\\{dt.ToString("yyyy-MM")}\\{dt.ToString("MM-dd")}\\{currentProduct.Name}\\{ProductMainSN}";
                                                            filePath = $"{PhotoPath}\\Recored\\{dt.ToString("yyyy-MM")}\\{dt.ToString("MM-dd")}\\{currentProduct.Name}\\{ProductMainSN}";
                                                            //string source_csv2 = $"{stationConfig.SaveCsvPath}\\{dt.ToString("yyyy-MM")}\\{i}_{stationConfig.DeviceName}_{dt.ToString("yyyy-MM-dd")}";
                                                            string csvfilename = $"{i}_{stationConfig.DeviceName}_{dt.ToString("yyyy-MM-dd")}";
                                                            //复制csv
                                                            string source_csv = $"{stationConfig.SaveCsvPath}\\{dt.ToString("yyyy-MM")}\\{i}_{stationConfig.DeviceName}_{dt.ToString("yyyy-MM-dd")}.csv";
                                                            //string source_csv1 = $"{stationConfig.SaveCsvPath}\\{dt.ToString("yyyy-MM")}";
                                                            string target_csv = Path.Combine(filePath, Path.GetFileName(source_csv));
                                                            File.Copy(source_csv, target_csv, true);
                                                            //复制log
                                                            string source_log = $"..\\Log\\LogInfo\\{dt.ToString("yyyy-MM")}\\{dt.ToString("yyyy-MM-dd")}.txt";
                                                            string target_log = Path.Combine(filePath, Path.GetFileName(source_log));
                                                            File.Copy(source_log, target_log, true);


                                                            CompressionImage(filePath, filename, device.Station, device.FixtureId);
                                                            //上传csv
                                                            bool isAfter20 = dt.Hour >= 20;
                                                            //判断是否是新的一天
                                                            bool isNewDay = dt.Date != _lastCompressDate.Date;
                                                            //当天还没执行过压缩
                                                            if (isAfter20 && isNewDay && !_hasCompressedToday)
                                                            {
                                                                // 执行压缩
                                                                CompressionSingleCsv(source_csv, csvfilename, device.Station, device.FixtureId);
                                                                _lastCompressDate = dt;
                                                                _hasCompressedToday = true;
                                                                LogHelper.WriteLogMes("csv上传数据成功");
                                                                SendTaskMessage($"csv上传数据成功", MessageLevel.Debug);
                                                            }
                                                            // 跨天后重置当天执行标记
                                                            if (!isNewDay && _hasCompressedToday)
                                                            {
                                                                _hasCompressedToday = false;
                                                            }

                                                        }
                                                        else
                                                        {
                                                            LogHelper.WriteLogMes($"上传数据失败");
                                                            SendTaskMessage($"上传数据失败", MessageLevel.Error);
                                                        }
                                                    }
                                                    else
                                                    {
                                                        LogHelper.WriteLogMes($"未启用mes");
                                                        SendTaskMessage($"未启用mes", MessageLevel.Error);
                                                    }
                                                }
                                                catch (Exception ex)
                                                {
                                                    SendTaskMessage($"上传数据时出错:{ex.Message}", MessageLevel.Error);
                                                    LogHelper.WriteLogError($"上传数据时出错", ex);
                                                }
                                            }
                                            else
                                            {
                                                SendTaskMessage($"{i}:{stationConfig.DeviceName}产品记录保存失败", MessageLevel.Error);
                                            }
                                        }
                                        else
                                        {
                                            SendTaskMessage($"{i}:{stationConfig.DeviceName}工位未配置保存路径，无法保存产品记录", MessageLevel.Error);
                                        }
                                    }
                                    else
                                    {
                                        SendTaskMessage($"{i}:{stationConfig.DeviceName}工位未配置保存产品记录", MessageLevel.Debug);
                                    }

                                    //WriteProductLog(lockResultsAll, code, CTtime);
                                    lock (_stateLock)
                                    {
                                        lockResultsAll.Clear();
                                        keyData.Clear();
                                        keyData1.Clear();
                                    }
                                    
                                    ProductMainSN = "";
                                    LogHelper.WriteLogMes($"【mes结束ADD】");
                                    SendTaskMessage($"mes结束ADD", MessageLevel.Info);
                                }
                                
                                else
                                {
                                    SendTaskMessage($"{i}过站检查信号：state={state}，处理为默认状态", MessageLevel.Alarm);
                                    await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)0);
                                }
                            }
                        }
                    }
                }

                


            }
            catch (Exception ex)
            {
                SendTaskMessage(ex.Message, MessageLevel.Error);
            }
        }

        /// <summary>
        /// 异步执行流程拍照
        /// </summary>
        /// <param name="pointIndex"></param>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        private Task<(bool IsSucceed, bool[] Result, string Message)> ExecuteProcedureAsync(int pointIndex, Guid procedureId)
        {
            return Task.Run(async () =>
            {
                List<bool> results = new List<bool>();
                // 获取当前产品
                var currentProduct = _productService.GetCurrentProduct();
                if (currentProduct == null)
                {
                    return (false, null, "当前产品为空，未加载产品！");
                }

                var cameraProcedures = currentProduct.CameraProcedures;
                if (cameraProcedures == null || cameraProcedures.Count == 0)
                {
                    SendTaskMessage($"当前产品未配置 CameraProcedures，无法执行视觉流程", MessageLevel.Alarm);
                    return (false, null, $"当前产品未配置 CameraProcedures，无法执行视觉流程");
                }


                var ctsAll = new CancellationTokenSource();

                try
                {
                    ProcedureModel selectedProcedure = null;
                    try
                    {
                        foreach (var cp in cameraProcedures)
                        {
                            if (cp?.ProcedureModels == null) continue;
                            selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);

                            if (selectedProcedure != null) break;
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                    }

                    if (selectedProcedure == null)
                    {
                        SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={pointIndex}", MessageLevel.Alarm);
                        return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}");
                    }

                    SendTaskMessage($"开始执行 AOI 流程 (Point#{pointIndex}) 流程Id={pointIndex}", MessageLevel.Debug);
                    try
                    {
                        //1. 执行拍照，图像处理
                        var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint1(selectedProcedure, null, null, ctsAll.Token);
                        if (visionResult.Count == 0)
                        {
                            SendTaskMessage("Count值为0", MessageLevel.Alarm);
                            return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}");
                        }

                        //2. 结果分析
                        for (int i = 1; i <= visionResult.Count; i++)
                        {

                            LockResult lockResult1 = new LockResult();
                            //if (pointIndex == currentProduct.PhotoCount && selectedProcedure.Id == currentProduct.FixedUpCamera1ProcedureId && i == 1)
                            //{
                            //    lockResult1.Number = 1;
                            //}

                            string[] strpoints1 = visionResult.Items[i].Split(',');
                            lockResult1.PhotoName = strpoints1[0];
                            string[] body1 = strpoints1[1].Split(";");
                            string body2 = null;

                            if (body1.Length == 8)
                            {
                                body2 = $"{body1[0]},{body1[2]},{body1[4]},{body1[6]}";
                            }
                            else
                            {
                                body2 = strpoints1[1];
                            }
                            lockResult1.ResultData = body2;
                            lockResult1.PhotoCode = ProductMainSN;
                            var globalParam = currentProduct.GlobalParamListCollection.FirstOrDefault(p => p.Name == strpoints1[0]);
                            if (globalParam != null)
                            {
                                lockResult1.UpLimit = globalParam.Param1;
                                lockResult1.DownLimit = globalParam.Param2;
                                lockResult1.MidLimit = globalParam.Param5;
                                string ResData = strpoints1[1];
                                if (ResData.Contains("NA"))
                                {
                                    ResData = "-1000";
                                }
                                string[] body = ResData.Split(";");
                                bool resultflog = true;
                                foreach (var item in body)
                                {
                                    if (Convert.ToDouble(item) >= Convert.ToDouble(globalParam.Param2) && Convert.ToDouble(item) <= Convert.ToDouble(globalParam.Param1))
                                    {

                                    }
                                    else
                                    {
                                        resultflog = false;
                                    }
                                }
                                if (resultflog)
                                {
                                    lockResult1.PhotoPassed = "OK";
                                    results.Add(true);
                                }
                                else
                                {
                                    lockResult1.PhotoPassed = "NG";
                                    results.Add(false);
                                }
                            }

                            lock (_stateLock)
                            {
                                lockResultsAll.Add(lockResult1);
                            }


                            App.Current.Dispatcher.Invoke(() =>
                            {
                                _eventAggregator.GetEvent<LockFinishNotification>().Publish(lockResult1);
                            });
                        }

                        //排序
                        //lock (_stateLock)
                        //{
                        //    var bf1 = lockResultsAll.OrderBy(p => p.Number);
                        //    lockResultsAll = new List<LockResult>(bf1);
                        //}

                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("执行 AOI 视觉流程时出错", ex);
                        SendTaskMessage($"执行 AOI 视觉流程异常: {ex.Message}", MessageLevel.Alarm);
                    }

                    return (true, results.ToArray(), $"成功");
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("处理固定相机检测拍照时出错", ex);
                    return (false, null, $"处理固定相机检测拍照时出错");
                }
            });
        }

        /// <summary>
        /// 异步执行流程拍照
        /// </summary>
        /// <param name="pointIndex"></param>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        private Task<(bool IsSucceed, bool[] Result, string Message)> ExecuteProcedureAsync(int pointIndex, Guid procedureId, ICogImage[] images, bool is3dmodel)
        {
            return Task.Run(async () =>
            {
                List<bool> results = new List<bool>();
                // 获取当前产品
                var currentProduct = _productService.GetCurrentProduct();
                if (currentProduct == null)
                {
                    return (false, null, "当前产品为空，未加载产品！");
                }

                var cameraProcedures = currentProduct.CameraProcedures;
                if (cameraProcedures == null || cameraProcedures.Count == 0)
                {
                    SendTaskMessage($"当前产品未配置 CameraProcedures，无法执行视觉流程", MessageLevel.Alarm);
                    return (false, null, $"当前产品未配置 CameraProcedures，无法执行视觉流程");
                }


                var ctsAll = new CancellationTokenSource();

                try
                {
                    ProcedureModel selectedProcedure = null;
                    try
                    {
                        foreach (var cp in cameraProcedures)
                        {
                            if (cp?.ProcedureModels == null) continue;
                            selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);

                            if (selectedProcedure != null) break;
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                    }

                    if (selectedProcedure == null)
                    {
                        SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={pointIndex}", MessageLevel.Alarm);
                        return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}");
                    }

                    SendTaskMessage($"开始执行 AOI 流程 (Point#{pointIndex}) 流程Id={pointIndex}", MessageLevel.Debug);
                    try
                    {
                        var sysConfig = _configService.GetSystemConfiguration();
                        if (selectedProcedure.Id == currentProduct.MoveDownCameraLockPhotoProcedureId && sysConfig.TurnOffAllLightUse == true)
                        {
                            await _remoteCommandService.TurnOffLightAfterPhoto(selectedProcedure);
                        }
                        PhotoPath = selectedProcedure.SavePath;
                        //1. 执行拍照，图像处理
                        var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint1(selectedProcedure, images, null, null, ctsAll.Token, is3dmodel);
                        if (visionResult.Count == 0)
                        {
                            SendTaskMessage("Count值为0", MessageLevel.Alarm);
                            return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}");
                        }

                        //2. 结果分析
                        lock (_stateLock)
                        {
                            var stationConfig = _configService.GetDeviceInfo(0);
                            for (int i = 1; i <= visionResult.Count; i++)
                            {

                                LockResult lockResult1 = new LockResult();
                                //if (pointIndex == currentProduct.PhotoCount && selectedProcedure.Id == currentProduct.FixedUpCamera1ProcedureId && i == 1)
                                //{
                                //    lockResult1.Number = 1;
                                //    lock (_stateLock)
                                //    {
                                //        lockResultsAll.Clear();
                                //    }

                                //}
                                try
                                {
                                    
                                    string[] strpoints1 = visionResult.Items[i].Split(',');
                                    string[] body1 = strpoints1[1].Split(";");

                                    if (stationConfig.SaveCsvkeyData)
                                    {
                                        if (body1.Length >= 5)
                                        {
                                            string keyName = strpoints1[0].Split('-').Last().Trim();
                                            List<double> list = new List<double>();

                                            foreach (string v in body1)
                                            {
                                                if (double.TryParse(v.Trim(), out double num))
                                                {
                                                    if (num == 999)
                                                    {
                                                        continue;
                                                    }
                                                    list.Add(num);
                                                }
                                            }
                                            if (list.Count == 0)
                                            {
                                                continue;
                                            }

                                            double max = list.Max();
                                            double min = list.Min();
                                            double chazhi = max - min;
                                            double average = list.Average();
                                            if (max - min <= 0.3)
                                            {
                                                isValueOk = true;
                                            }
                                            else
                                            {
                                                SendTaskMessage($"键盘格{keyName}最大值{max}与最小值{min}相差大于0.3!", MessageLevel.Error);
                                            }
                                            if (keyData != null)
                                            {
                                                if (!keyData.ContainsKey(keyName))
                                                {
                                                    keyData.Add(keyName, average);

                                                }
                                                if (!keyData1.ContainsKey(keyName))
                                                {
                                                    keyData1.Add(keyName, chazhi);
                                                }
                                            }
                                            else
                                            {
                                                keyData.Add(keyName, average);
                                                keyData1.Add(keyName, chazhi);
                                            }
                                        }                                      
                                    }
                                                         
                                    if (body1.Length > 1)
                                    {
                                        for (int j = 1; j <= body1.Length; j++)
                                        {
                                            lockResult1.PhotoName = strpoints1[0] + "_" + j.ToString();
                                            lockResult1.ResultData = body1[j - 1];
                                            lockResult1.PhotoCode = ProductMainSN;
                                            var globalParam = currentProduct.GlobalParamListCollection.FirstOrDefault(p => p.Name == strpoints1[0]);
                                            if (globalParam != null)
                                            {
                                                lockResult1.UpLimit = globalParam.Param1;
                                                lockResult1.DownLimit = globalParam.Param2;
                                                lockResult1.MidLimit = globalParam.Param5;
                                                string ResData = body1[j - 1];
                                                if (ResData.Contains("NA"))
                                                {
                                                    ResData = "-1000";
                                                }

                                                bool resultflog = true;
                                                if (Convert.ToDouble(ResData) >= Convert.ToDouble(globalParam.Param2) && Convert.ToDouble(ResData) <= Convert.ToDouble(globalParam.Param1))
                                                {

                                                }
                                                else
                                                {
                                                    resultflog = false;
                                                }
                                                if (resultflog)
                                                {
                                                    lockResult1.PhotoPassed = "OK";
                                                    results.Add(true);
                                                }
                                                else
                                                {
                                                    lockResult1.PhotoPassed = "NG";
                                                    results.Add(false);
                                                }

                                            }
                                            lockResultsAll.Add(lockResult1.Copy());
                                        }
                                    }
                                    else
                                    {
                                        lockResult1.PhotoName = strpoints1[0];
                                        lockResult1.ResultData = strpoints1[1];
                                        lockResult1.PhotoCode = ProductMainSN;
                                        var globalParam = currentProduct.GlobalParamListCollection.FirstOrDefault(p => p.Name == strpoints1[0]);
                                        if (globalParam != null)
                                        {
                                            lockResult1.UpLimit = globalParam.Param1;
                                            lockResult1.DownLimit = globalParam.Param2;
                                            lockResult1.MidLimit = globalParam.Param5;
                                            string ResData = strpoints1[1];
                                            if (ResData.Contains("NA"))
                                            {
                                                ResData = "-1000";
                                            }

                                            bool resultflog = true;
                                            if (Convert.ToDouble(ResData) >= Convert.ToDouble(globalParam.Param2) && Convert.ToDouble(ResData) <= Convert.ToDouble(globalParam.Param1))
                                            {

                                            }
                                            else
                                            {
                                                resultflog = false;
                                            }
                                            if (resultflog)
                                            {
                                                lockResult1.PhotoPassed = "OK";
                                                results.Add(true);
                                            }
                                            else
                                            {
                                                lockResult1.PhotoPassed = "NG";
                                                results.Add(false);
                                            }
                                        }
                                        lockResultsAll.Add(lockResult1);
                                    }
                                }
                                catch (Exception ex) 
                                {
                                    SendTaskMessage($"拆分视觉结果出错:{ex}",MessageLevel.Error);

                                }
                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    _eventAggregator.GetEvent<LockFinishNotification>().Publish(lockResult1);
                                });
                            }
                        }


                        ////排序
                        //lock (_stateLock)
                        //{
                        //    var bf1 = lockResultsAll.OrderBy(p => int.Parse(p.PhotoName));
                        //    lockResultsAll = new List<LockResult>(bf1);
                        //}
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError("执行 AOI 视觉流程时出错", ex);
                        SendTaskMessage($"执行 AOI 视觉流程异常: {ex.Message}", MessageLevel.Alarm);
                    }

                    return (true, results.ToArray(), $"成功");
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("处理固定相机检测拍照时出错", ex);
                    return (false, null, $"处理固定相机检测拍照时出错");
                }
            });
        }

        /// <summary>
        /// 是否是3D相机
        /// </summary>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        private bool Is3D(Guid procedureId)
        {
            // 获取当前产品
            var currentProduct = _productService.GetCurrentProduct();
            if (currentProduct == null)
            {
                return false;
            }

            var cameraProcedures = currentProduct.CameraProcedures;
            if (cameraProcedures == null || cameraProcedures.Count == 0)
            {
                return false;
            }
            ProcedureModel selectedProcedure = null;
            try
            {
                foreach (var cp in cameraProcedures)
                {
                    if (cp?.ProcedureModels == null) continue;
                    selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);

                    if (selectedProcedure != null) break;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
            }
            if (selectedProcedure == null)
            {
                return false;
            }
            var camera = _cameraService.GetCamera(selectedProcedure.CameraId);
            if (camera == null)
            {
                return false;
            }
            return camera.Is3D;
        }

        /// <summary>
        /// 2D相机先采集图像
        /// </summary>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        private async Task<(bool IsSucceed, ICogImage[] imges, string Message)> GrabImage(int pointIndex, Guid procedureId)
        {
            // 获取当前产品
            var currentProduct = _productService.GetCurrentProduct();
            if (currentProduct == null)
            {
                return (false, null, "当前产品为空，未加载产品！");
            }

            var cameraProcedures = currentProduct.CameraProcedures;
            if (cameraProcedures == null || cameraProcedures.Count == 0)
            {
                SendTaskMessage($"当前产品未配置 CameraProcedures，无法执行视觉流程", MessageLevel.Alarm);
                return (false, null, $"当前产品未配置 CameraProcedures，无法执行视觉流程");
            }

            try
            {
                ProcedureModel selectedProcedure = null;
                try
                {
                    foreach (var cp in cameraProcedures)
                    {
                        if (cp?.ProcedureModels == null) continue;
                        selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);

                        if (selectedProcedure != null) break;
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                }

                if (selectedProcedure == null)
                {
                    SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={pointIndex}", MessageLevel.Alarm);
                    return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}");
                }

                SendTaskMessage($"开始执行 AOI 流程 (Point#{pointIndex}) 流程Id={pointIndex}", MessageLevel.Debug);
                try
                {
                    var sysConfig = _configService.GetSystemConfiguration();
                    if (selectedProcedure.Id == currentProduct.FixedDownCameraProcedureId && sysConfig.TurnOnAllLightUse == true)
                    {
                        await _remoteCommandService.SetLightBeforePhoto(selectedProcedure);
                    }
                    //1. 执行拍照                
                    //return await _remoteCommandService.ExecuteGrabImageAsync(selectedProcedure);
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("执行 AOI 视觉图像采集时出错", ex);
                    SendTaskMessage($"执行 AOI 视觉图像采集时出错: {ex.Message}", MessageLevel.Alarm);
                }

                return (false, null, $"图像采集失败");
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("处理固定相机检测拍照时出错", ex);
                return (false, null, $"处理固定相机检测拍照时出错");
            }
        }

        /// <summary>
        /// 为所有相机设置批处理点数（会调用具体相机实现的 SetBatchPoints）
        /// </summary>
        /// <param name="points"></param>
        public void SetBatchPoints(int CameraNum, int points)
        {
            try
            {
                if (points == 0 || points < 0)
                {
                    return;
                }
                var cameras = _cameraService.GetCameraByNumber(CameraNum);
                if (cameras == null) return;
                try
                {
                    // 优先针对已知的 SSZNCamera 类型直接调用
                    if (cameras is TeamAAS_VP.Core.Cameras.SSZNCamera sszn)
                    {
                        sszn.CameraRevFinish = false;
                        sszn.SetBatchPoints(points);
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError($"SetBatchPoints to camera {cameras?.Name} failed", ex);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("SetBatchPoints failed", ex);
            }
        }

        /// <summary>
        /// 为所有相机设置产品配方（会调用具体相机实现的 SetBatchPoints）
        /// </summary>
        /// <param name="points"></param>
        public void SetProducts(int CameraNum, int points)
        {
            try
            {
                if (points < 0)
                {
                    return;
                }
                var cameras = _cameraService.GetCameraByNumber(CameraNum);
                if (cameras == null) return;
                try
                {
                    // 优先针对已知的 SSZNCamera 类型直接调用
                    if (cameras is TeamAAS_VP.Core.Cameras.SSZNCamera sszn)
                    {
                        sszn.CameraRevFinish = false;
                        sszn.SetProducts(CameraNum,points);
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError($"SetBatchPoints to camera {cameras?.Name} failed", ex);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("SetBatchPoints failed", ex);
            }
        }

        public void SetBatchPoints(int[] CameraSpoints)
        {
            try
            {
                for (int i = 0; i < CameraSpoints.Length; i++)
                {
                    SetBatchPoints(i + 1, CameraSpoints[i]);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("SetBatchPoints failed", ex);
            }
        }
        public void SetProducts(int[] CameraSpoints)
        {
            try
            {
                for (int i = 0; i < CameraSpoints.Length; i++)
                {
                    SetProducts(i + 1, CameraSpoints[i]);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("SetProducts failed", ex);
            }
        }
        #endregion

        #region 方法

        private void SendTaskMessage(string msg, MessageLevel level)
        {
            App.Current.Dispatcher.Invoke(() =>
            {
                _eventAggregator.GetEvent<TaskMessageNotification>().Publish(new Models.MessageStruct() { Message = msg, level = level });
            });
        }
        public bool concurrenty = true;
        public void CurrentRunStatus()
        {
            if (!concurrenty)
            {
                return;
            }
            concurrenty = true;
            bool connectStaus = true;
            bool mesStatus = true;
            bool paraStatus = true;
            try
            {


                var stationConfig = _configService.GetDeviceInfo(0);
                if (!stationConfig.EnableMES || !stationConfig.EnableDoubleMes || !stationConfig.SaveCsv)
                {
                    mesStatus = false;
                    
                }


                foreach (var item in Status)
                {
                    if (item.Background == System.Windows.Media.Brushes.Red)
                    {
                        connectStaus = false;
                        break;
                    }
                }
            }
            catch (Exception)
            {
                connectStaus = false;
            }
            if (connectStaus && mesStatus && _LastAutoRunning)
            {
                RunModelBackground = System.Windows.Media.Brushes.Green;
                ClearModeBackground = System.Windows.Media.Brushes.White;
                ManualModeBackground = System.Windows.Media.Brushes.White;
                SendTaskMessage("当前为运行模式", MessageLevel.Info);
            }
            else
            {
                RunModelBackground = System.Windows.Media.Brushes.White;
                ClearModeBackground = System.Windows.Media.Brushes.White;
                ManualModeBackground = System.Windows.Media.Brushes.Orange;
                SendTaskMessage("当前为调机模式", MessageLevel.Info);
            }
            concurrenty = true;
        }

        /// <summary>
        /// 校验键盘所有按键值，相邻差值不能大于 0.3
        /// </summary>
        public bool CheckKeyBoardValue(Dictionary<string, double> keyDic, out string errorMsg)
        {
            errorMsg = "";
            try
            {
                // 2. 获取每个按键的【真实相邻按键】
                Dictionary<string, List<string>> neighborMap = GetKeyboardNeighborMap();

                // 3. 开始校验：每个按键 和 相邻按键 差值 ≤0.3
                foreach (var item in keyDic)
                {
                    string key = item.Key.ToUpper();
                    double val = item.Value;

                    // 没有相邻关系就跳过
                    if (!neighborMap.ContainsKey(key))
                        continue;

                    // 遍历所有相邻按键
                    foreach (string neighbor in neighborMap[key])
                    {
                        string n = neighbor.ToUpper();
                        if (!keyDic.ContainsKey(n))
                            continue;

                        double nVal = keyDic[n];
                        double diff = Math.Abs(val - nVal);

                        // 超过 0.3 直接报错
                        if (diff > 0.3)
                        {
                            SendTaskMessage($"按键 {key}({val}) 与相邻按键 {n}({nVal}) 差值 {diff:F3} > 0.3，校验不通过", MessageLevel.Error);
                            return false;
                        }
                    }
                }
                SendTaskMessage("所有键盘按键相邻差值校验通过", MessageLevel.Debug);
                return true;
            }
            catch (Exception ex)
            {
                errorMsg = "校验异常：" + ex.Message;
                return false;
            }
        }

        /// <summary>
        /// 键盘相邻关系
        /// </summary>
        private Dictionary<string, List<string>> GetKeyboardNeighborMap()
        {
            return new Dictionary<string, List<string>>
            {
                // ==============================================
                // 第一行：ESC + F1~F12
                // ==============================================
                ["ESC"] = new List<string> { "F1", "~",  },
                ["F1"] = new List<string> { "ESC", "F2", "1" },
                ["F2"] = new List<string> { "F1", "F3",  "2" },
                ["F3"] = new List<string> { "F2", "F4", "2", "3"},
                ["F4"] = new List<string> { "F3", "F5", "3", "4" },
                ["F5"] = new List<string> { "F4", "F6", "4", "5" },
                ["F6"] = new List<string> { "F5", "F7", "5", "6" },
                ["F7"] = new List<string> { "F6", "F8", "6", "7" },
                ["F8"] = new List<string> { "F7", "F9", "7", "8" },
                ["F9"] = new List<string> { "F8", "F10", "8", "9" },
                ["F10"] = new List<string> { "F9", "F11", "9", "0" },
                ["F11"] = new List<string> { "F10", "F12", "0", "-" },
                ["F12"] = new List<string> { "F11", "-", "=", "Insert" },
                ["Insert"] = new List<string> { "F12", "Power", "Backspace" },
                ["Power"] = new List<string> {"Backspace" },

                // ==============================================
                // 第二行：` 1 2 3 4 5 6 7 8 9 0 - = Backspace
                // ==============================================
                ["~"] = new List<string> { "ESC", "1", "TAB" },
                ["1"] = new List<string> {  "F1", "`", "2", "TAB", "Q" },
                ["2"] = new List<string> {  "F2", "1", "3", "Q", "W" },
                ["3"] = new List<string> {  "F3", "F4", "2", "4", "W", "E" },
                ["4"] = new List<string> {  "F4", "F5", "3", "5", "E", "R" },
                ["5"] = new List<string> {  "F5", "F6", "4", "6", "R", "T" },
                ["6"] = new List<string> {  "F6", "F7", "5", "7", "T", "Y" },
                ["7"] = new List<string> {  "F7", "F8", "6", "8", "Y", "U" },
                ["8"] = new List<string> {  "F8", "F9", "7", "9", "U", "I" },
                ["9"] = new List<string> {  "F9", "F10", "8", "0", "I", "O" },
                ["0"] = new List<string> {  "F10", "F11", "9", "-", "O", "P" },
                ["-"] = new List<string> {  "F11", "F12", "0", "=", "P", "{" },
                ["="] = new List<string> {  "F12", "-", "Backspace", "{", "}" },
                ["Backspace"] = new List<string> { "Insert", "=", "}", "|", "Power" },

                // ==============================================
                // 第三行：TAB Q W E R T Y U I O P [ ] \
                // ==============================================
                ["TAB"] = new List<string> { "`", "1", "Q", "CapsLock" },
                ["Q"] = new List<string> { "TAB", "`", "1", "2", "W", "A", "CapsLock" },
                ["W"] = new List<string> { "Q", "1", "2", "3", "E", "A", "S" },
                ["E"] = new List<string> { "W", "2", "3", "4", "R", "S", "D" },
                ["R"] = new List<string> { "E", "3", "4", "5", "T", "D", "F" },
                ["T"] = new List<string> { "R", "4", "5", "6", "Y", "F", "G" },
                ["Y"] = new List<string> { "T", "5", "6", "7", "U", "G", "H" },
                ["U"] = new List<string> { "Y", "6", "7", "8", "I", "H", "J" },
                ["I"] = new List<string> { "U", "7", "8", "9", "O", "J", "K" },
                ["O"] = new List<string> { "I", "8", "9", "0", "P", "K", "L" },
                ["P"] = new List<string> { "O", "9", "0", "-", "{", "L", ";" }, 
                ["{"] = new List<string> { "P", "0", "-", "=", "}", ";", "'" },
                ["}"] = new List<string> { "{", "-", "=", "Backspace", "|", "'", "Enter" },
                ["|"] = new List<string> { "}", "Backspace", "Enter" },

                // ==============================================
                // 第四行：CapsLock A S D F G H J K L ; ' Enter
                // ==============================================
                ["CapsLock"] = new List<string> { "TAB", "Q", "A", "LeftShift" },
                ["A"] = new List<string> { "CapsLock", "Q", "W", "S", "LeftShift", "Z" },
                ["S"] = new List<string> { "A", "W", "E", "D", "Z", "X", "LeftShift" },
                ["D"] = new List<string> { "S", "E", "R", "F", "X", "C", "LeftShift" },
                ["F"] = new List<string> { "D", "R", "T", "G", "C", "V" },
                ["G"] = new List<string> { "F", "T", "Y", "H", "V", "B" }, 
                ["H"] = new List<string> { "G", "Y", "U", "J", "B", "N" },
                ["J"] = new List<string> { "H", "U", "I", "K", "N", "M" },
                ["K"] = new List<string> { "J", "I", "O", "L", "M", "," },
                ["L"] = new List<string> { "K", "O", "P", ";", "<", ">", "?" },
                [";"] = new List<string> { "L", "P", "{", "'", ">", "?" },
                ["'"] = new List<string> { ";", "{", "}", "Enter", "?" },
                ["Enter"] = new List<string> { "'", "}", "|", "RightShift" },

                // ==============================================
                // 第五行：LeftShift Z X C V B N M , . / RightShift
                // ==============================================
                ["Shift"] = new List<string> { "CapsLock", "A", "S", "D", "Z", "Ctrl", "Fn" },
                ["Z"] = new List<string> { "Shift", "A", "S", "X" },
                ["X"] = new List<string> { "Z", "S", "D", "C" },
                ["C"] = new List<string> { "X", "D", "F", "V" },
                ["V"] = new List<string> { "C", "F", "G", "B" },
                ["B"] = new List<string> { "V", "G", "H", "N" },
                ["N"] = new List<string> { "B", "H", "J", "M" },
                ["M"] = new List<string> { "N", "J", "K", "<" },
                ["<"] = new List<string> { "M", "K", "L", ">" },
                [">"] = new List<string> { "<", "L", ";", "?" },
                ["?"] = new List<string> { ">", ";", "'", "Shift2" },
                ["Shift2"] = new List<string> { "?", "Enter" },

                // ==============================================
                // 第六行：Ctrl Fn Win Alt Space Alt Fn Ctrl ← ↓ →
                // ==============================================
                ["Ctrl1"] = new List<string> { "Fn", "Shift" },
                ["Fn"] = new List<string> { "Ctrl", "Win", "Shift" },
                ["Win"] = new List<string> { "Fn", "Alt" },
                ["Alt1"] = new List<string> { "Win", "Space" },
                ["Space1"] = new List<string> { "Alt", "Alt2" },
                ["Alt2"] = new List<string> { "Space", "Ctrl2" },
               // ["RightFn"] = new List<string> { "RightAlt", "RightCtrl" },
                ["Ctrl2"] = new List<string> { "Alt2", "Left", "Updown", "Right" },
                ["Left"] = new List<string> { "RightCtrl", "Updown" },
                ["Updown"] = new List<string> { "Left", "Right", "Ctrl2" },
                ["Right"] = new List<string> { "Updown", "Ctrl2" }
            };
        }

        private Dictionary<string, double> GetAdjacentDiffDict(Dictionary<string, double> keyData)
        {
            Dictionary<string, double> diffDict = new Dictionary<string, double>();
            var neighborMap = GetKeyboardNeighborMap(); // 引用你的键盘相邻表

            foreach (var kvp in keyData)
            {
                string key1 = kvp.Key;
                double val1 = kvp.Value;

                if (!neighborMap.TryGetValue(key1, out var neighbors)) continue;

                foreach (string key2 in neighbors)
                {
                    if (!keyData.TryGetValue(key2, out double val2)) continue;

                    // 去重核心：保证 A-S 和 S-A 只存一次
                    string pairKey = string.Compare(key1, key2) < 0 ? $"_{key1}_{key2}" : $"_{key2}_{key1}";

                    if (diffDict.ContainsKey(pairKey)) continue; // 跳过已存的

                    double diff = Math.Abs(val1 - val2);
                    diffDict.Add(pairKey, diff);
                }
            }
            return diffDict;
        }


        private async void DoYieldTime(object state)
        {
            try
            {
                //获取当前产品
                CurrentProduct = _productService.GetCurrentProduct();
                var currentproduct = _productService.GetCurrentProduct();
                if (currentproduct == null) return;
                TotalQuantity = await _systemDatabaseService.GetOverallProductionAsync(currentproduct.Name);
                TotalQuantityToday = await _systemDatabaseService.GetTodayProductionAsync(currentproduct.Name);
                CurrentUPH = await _systemDatabaseService.GetLastHourProductionAsync(currentproduct.Name);
                NgNumber = await _systemDatabaseService.GetNGProductionAsync(currentproduct.Name);
                Yield = ((double)TotalQuantityToday - (double)NgNumber) / (double)TotalQuantityToday * 100;
            }
            catch (Exception)
            {

            }
        }

        #region vm启动检测

        /// <summary>
        /// 杀死所有VM有关进程
        /// </summary>
        public void KillVMProcess()
        {
            KillProcess("VisionMasterServerApp");
            KillProcess("VisionMaster");
            KillProcess("VmModuleProxy.exe");
            KillProcess("vServerApp.exe");
        }

        /// <summary>
        /// 杀死指定进程名的进程
        /// </summary>
        /// <param name="strKillName"></param>
        public void KillProcess(string strKillName)
        {
            foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcesses())
            {
                if (p.ProcessName.Contains(strKillName))
                {
                    try
                    {
                        p.Kill();
                        p.WaitForExit();
                    }
                    catch (Exception ex)
                    {
                        LogHelper.WriteLogError($"杀死进程:{strKillName}时失败！", ex);
                    }
                }
            }
        }
        #endregion


        /// <summary>
        /// 记录工位的结果，其他工位要存储的数据项按照键值对集合的形式传入，键为数据项名称，值为数据项的值
        /// </summary>
        /// <param name="stationIndex"></param>
        /// <param name="dfcs"></param>
        /// <param name="productMainSN"></param>
        /// <param name="ct"></param>
        /// <param name="timestamp"></param>
        /// <param name="savePath"></param>
        /// <param name="isFirstEnter"></param>
        /// <returns></returns>
        private bool RecordStationResult(int stationIndex, IEnumerable<DataFormCtq> dfcs, string productMainSN, double ct, DateTime timestamp, string savePath, bool isFirstEnter = true)
        {
            try
            {
                //获取当前工位的配置
                var stationConfig = _configService.GetDeviceInfo(0);
                if (stationConfig == null) return false;
                //如果保存路径为空，则不保存
                if (string.IsNullOrEmpty(savePath)) return false;
                string fullPath = savePath;
                //如果保存路径是一个文件路径，则直接保存，否则按照工位和日期进行保存
                if (File.Exists(savePath) || Path.HasExtension(savePath))
                {
                    fullPath = savePath;
                    //如果路径不存在，则创建
                    // 创建目录
                    string directory = Path.GetDirectoryName(fullPath);
                    if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
                    {
                        Directory.CreateDirectory(directory);
                    }
                }
                else
                {
                    //结果保存至CSV文件，文件名格式：savePath\yyyy-MM\工位编号_工位名称_yyyy-MM-dd.csv
                    string datePath = timestamp.ToString("yyyy-MM") + "\\";
                    string dirPath = Path.Combine(savePath, datePath);
                    if (!Directory.Exists(dirPath)) Directory.CreateDirectory(dirPath);
                    string fileName = $"{stationIndex}_{stationConfig.DeviceName}_{timestamp.ToString("yyyy-MM-dd")}.csv";
                    fullPath = Path.Combine(dirPath, fileName);
                }
                StringBuilder sb = new StringBuilder();
                if (!File.Exists(fullPath))
                {
                    sb.Append("PPID,PROCESS_NAME,PROCESS_START_TIME,CTQ_NAME,CTQ_VALUE,CTQ_LSL,CTQ_USL,PROCESS_END_TIME,SUPPLIER_NAME,COMMODITY_TYPE,REVISION,WO#,MFG_LOT#," +
                        "MFG_ASSY_LINE,PROCESS_OUTCOME,PROCESS_MACHINE_ID,CTQ_UNIT_OF_MEASURE,ERROR_MESSAGE,PD_ATTR_01,PD_ATTR_02,PD_ATTR_03,PD_ATTR_04,PD_ATTR_05");
                    sb.AppendLine();
                }
                if (dfcs == null || dfcs.Count() == 0)
                {
                    return false;
                }
                foreach (var dfc in dfcs)
                {
                    sb.Append($"{dfc.PPID},{dfc.PROCESS_NAME},{dfc.PROCESS_START_TIME},{dfc.CTQ_NAME},{dfc.CTQ_VALUE},{dfc.CTQ_LSL},{dfc.CTQ_USL},{dfc.PROCESS_END_TIME},{dfc.SUPPLIER_NAME},{dfc.COMMODITY_TYPE},{dfc.REVISION},{dfc.WO},{dfc.MFG_LOT},{dfc.MFG_ASSY_LINE},{dfc.PROCESS_OUTCOME},{dfc.PROCESS_MACHINE_ID},{dfc.CTQ_UNIT_OF_MEASURE},{dfc.ERROR_MESSAGE},{dfc.PD_ATTR_01},{dfc.PD_ATTR_02},{dfc.PD_ATTR_03},{dfc.PD_ATTR_04},{dfc.PD_ATTR_05}");
                    sb.AppendLine();
                }
                // 使用 StreamWriter 以追加模式打开文件
                StreamWriter sw = new StreamWriter(fullPath, true, Encoding.UTF8);
                sw.Write(sb.ToString());
                sw.Close();
                sw.Dispose();
                return true;
            }
            catch (Exception ex)
            {
                if (!isFirstEnter)
                {
                    return false;
                }
                LogHelper.WriteLogError("记录其他工位结果时出错!", ex);
                //我希望在这里生成一个临时文件来保存这次的记录，因为如果本地文件被打开时可能会导致无法写入，如果不保存的话可能会丢失这次的记录，所以我想在这里生成一个临时文件来保存这次的记录
                //生成临时文件的路径，格式为savePath\yyyy-MM\工位编号_yyyy-MM-dd_temp\工位编号_yyyy-MM-dd_HH-mm-ss-fff_temp.csv
                string datePath = timestamp.ToString("yyyy-MM") + "\\";
                string tempDirPath = Path.Combine(savePath, datePath, $"{stationIndex}_{timestamp.ToString("yyyy-MM-dd")}_temp");
                string tempFileName = $"{stationIndex}_{timestamp.ToString("yyyy-MM-dd_HH-mm-ss-fff")}_temp.csv";
                RecordStationResult(stationIndex, dfcs, productMainSN, ct, timestamp, tempFileName, false);
                return false;
            }
        }
        #endregion

        // 用于等待“指定相机的下一张图到达”
        private readonly object _imageSyncLock = new object();
        private readonly Dictionary<Guid, TaskCompletionSource<ICogImage>> _nextImageTcsByCamera =
            new Dictionary<Guid, TaskCompletionSource<ICogImage>>();

        private Task<ICogImage> PrepareNextImageWait(Guid cameraId)
        {
            lock (_imageSyncLock)
            {
                var tcs = new TaskCompletionSource<ICogImage>(TaskCreationOptions.RunContinuationsAsynchronously);
                _nextImageTcsByCamera[cameraId] = tcs;
                return tcs.Task;
            }
        }
        public async Task SignalImageArrived(Guid cameraId, ICogImage image)
        {
            await Task.Delay(500);
            TaskCompletionSource<ICogImage> tcs = null;
            lock (_imageSyncLock)
            {
                _nextImageTcsByCamera.TryGetValue(cameraId, out tcs);
            }
            tcs?.TrySetResult(image);
        }

        public async Task<ICogImage> WaitNextImageAsync(Guid cameraId, int timeoutMs, CancellationToken token)
        {
            var waitTask = PrepareNextImageWait(cameraId);
            var completed = await Task.WhenAny(waitTask, Task.Delay(timeoutMs, token)).ConfigureAwait(false);
            if (completed != waitTask) return null;
            return await waitTask.ConfigureAwait(false);
        }

        //public async Task<bool> WaitImageFlagAsync(int cameraNo, int timeoutMs, CancellationToken token)
        //{
        //    if (cameraNo < 0 || cameraNo >= ImageData.Length)
        //    {
        //        SendTaskMessage($"等待相机图像失败：CameraNo={cameraNo} 越界", MessageLevel.Alarm);
        //        return false;
        //    }

        //    var start = DateTime.UtcNow;
        //    while (ImageData[cameraNo] == 0)
        //    {
        //        token.ThrowIfCancellationRequested();

        //        if ((DateTime.UtcNow - start).TotalMilliseconds >= timeoutMs)
        //        {
        //            SendTaskMessage($"等待相机图像超时：CameraNo={cameraNo} Timeout={timeoutMs}ms", MessageLevel.Alarm);
        //            return false;
        //        }

        //        await Task.Delay(100, token).ConfigureAwait(false);
        //    }

        //    return true;
        //}
        // ====== 新增：最简等待：TCS + 超时（比 SemaphoreSlim + CurrentCount 轮询更轻、更可靠）======
        private async Task<string> ScanT1Async(int timeoutMs)
        {
            var scannerId = GetDefaultScannerId();
            if (scannerId == Guid.Empty) return null;

            var scanner = _scannerService.GetScanner(scannerId);
            if (scanner == null || !scanner.IsConnected) return null;

            // 关键：先注册等待，再发送 T1，避免“回包先到”导致丢信号
            var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
            _scanTcs = tcs;

            await scanner.SendAsync("T1").ConfigureAwait(false);

            var completed = await Task.WhenAny(tcs.Task, Task.Delay(timeoutMs)).ConfigureAwait(false);
            if (completed != tcs.Task)
            {
                // 超时：清掉本次等待，避免下次误用
                if (ReferenceEquals(_scanTcs, tcs)) _scanTcs = null;
                return null;
            }

            var reply = await tcs.Task.ConfigureAwait(false);
            if (ReferenceEquals(_scanTcs, tcs)) _scanTcs = null;
            return reply;
        }
        private Guid GetDefaultScannerId()
        {
            if (_defaultScannerId != Guid.Empty) return _defaultScannerId;

            var scannerInfo = _configService.GetAllScanners()
                .OrderBy(s => s.ScannerNo)
                .FirstOrDefault();

            _defaultScannerId = scannerInfo == null ? Guid.Empty : scannerInfo.Id;
            return _defaultScannerId;
        }

        private async Task Scan_DataReceived(ISerialPortClient client, ReceivedDataEventArgs e)
        {
            try
            {
                // 串口名
                string portName = client.MainSerialPort.PortName;
                // 注意：DataReceived 可能一次收到多段/包含回车换行
                string data = e.ByteBlock.Span.ToString(Encoding.ASCII);
                await Console.Out.WriteLineAsync(data);
                // 取第一段（到 \r 之前），并去掉首尾空白
                string response = data.Split('\r')[0].Trim();
                // 过滤：空数据不要当成一次有效扫码
                if (string.IsNullOrWhiteSpace(response))
                    return;
                SendTaskMessage($"扫码机:{portName} Receive:{response}", MessageLevel.Info);
                // 写入结果
                ScanValue = response;
                // 通知等待方继续执行（PLC 逻辑里 Wait 的地方）
                _scanDoneEvent.Set();
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("扫码枪接收信息时出错！", ex);
                SendTaskMessage(Lang.扫码枪接收信息时出错 + ex.Message, MessageLevel.Error);
            }
        }

        /// <summary>
        /// 2D相机先采集图像
        /// </summary>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        private async Task<(bool IsSucceed, ICogImage[] imges, string Message, int pointIndex, Guid procedureId)> GrabImageEx(int pointIndex, Guid procedureId,bool Is3dPhoto)
        {
            // 获取当前产品
            var currentProduct = _productService.GetCurrentProduct();
            if (currentProduct == null)
            {
                return (false, null, "当前产品为空，未加载产品！", pointIndex, procedureId);
            }

            var cameraProcedures = currentProduct.CameraProcedures;
            if (cameraProcedures == null || cameraProcedures.Count == 0)
            {
                SendTaskMessage($"当前产品未配置 CameraProcedures，无法执行视觉流程", MessageLevel.Alarm);
                return (false, null, $"当前产品未配置 CameraProcedures，无法执行视觉流程", pointIndex, procedureId);
            }

            try
            {
                ProcedureModel selectedProcedure = null;
                try
                {
                    foreach (var cp in cameraProcedures)
                    {
                        if (cp?.ProcedureModels == null) continue;
                        selectedProcedure = cp.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);

                        if (selectedProcedure != null) break;
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("查找 AOI 点位对应视觉流程时出错", ex);
                }

                if (selectedProcedure == null)
                {
                    SendTaskMessage($"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={pointIndex}", MessageLevel.Alarm);
                    return (false, null, $"未找到 AOI 点位对应的视觉流程，Point#{pointIndex} ProcedureId={procedureId}", pointIndex, procedureId);
                }

                SendTaskMessage($"开始执行 AOI 流程 (Point#{pointIndex}) 流程Id={pointIndex}", MessageLevel.Debug);
                try
                {
                    var sysConfig = _configService.GetSystemConfiguration();
                    if (selectedProcedure.Id == currentProduct.FixedDownCameraProcedureId && sysConfig.TurnOnAllLightUse == true)
                    {
                        await _remoteCommandService.SetLightBeforePhoto(selectedProcedure);
                    }
                    //1. 执行拍照
                    var res = await _remoteCommandService.ExecuteGrabImageAsync(selectedProcedure,Is3dPhoto);
                    return (res.IsSucceed, res.Image, res.Msg, pointIndex, procedureId);
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("执行 AOI 视觉图像采集时出错", ex);
                    SendTaskMessage($"执行 AOI 视觉图像采集时出错: {ex.Message}", MessageLevel.Alarm);
                }

                return (false, null, $"图像采集失败", pointIndex, procedureId);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("处理固定相机检测拍照时出错", ex);
                return (false, null, $"处理固定相机检测拍照时出错", pointIndex, procedureId);
            }
        }

        #region 压缩图片文件夹
        /// <summary>
        /// 压缩文件
        /// </summary>
        /// <param name="sourcePath">原路径</param>
        /// <param name="zipname">压缩后文件的名称</param>
        /// <param name="station">mes中的station</param>
        /// <param name="fixid">mes中的fixtureID</param>
        public async void CompressionImage(string sourcePath, string zipname, string station, string fixid)
        {
            string zipPath = "";
            try
            {
                SendTaskMessage($"开始压缩文件", MessageLevel.Info);
                await Task.Run(() =>
                {
                    zipPath = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}\\{zipname}.zip";//生成的zip文件路径
                    string path = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}";
                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }

                    ZipFile.CreateFromDirectory(sourcePath, zipPath);
                });
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError($"压缩文件时出错", ex);
            }
        }


        public async void CompressionSingleCsv(string csvFilePath, string zipname, string station, string fixid)
        {
            string zipPath = "";
            try
            {
                SendTaskMessage("开始压缩CSV文件", MessageLevel.Info);
                await Task.Run(() =>
                {
                    if (!File.Exists(csvFilePath))
                    {
                        LogHelper.WriteLogMes($"CSV文件不存在，不压缩：{csvFilePath}");
                        return;
                    }

                    zipPath = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}\\{zipname}.zip";
                    string path = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}";

                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }

                    using (FileStream fs = new FileStream(zipPath, FileMode.Create))
                    {
                        using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Create))
                        {
                            archive.CreateEntryFromFile(csvFilePath, Path.GetFileName(csvFilePath));
                        }
                    }
                });
                SendTaskMessage("CSV文件压缩完成", MessageLevel.Debug);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("压缩CSV文件失败", ex);
            }
        }

        #endregion
    }
}