xiaomiMes/MainForm/FaForm/Form_Home.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
//using System.Text;
using Microsoft.Win32;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using HslCommunication.LogNet;
using MainForm.FaForm;
using Sunny.UI;
using MainForm.ClassFile.XiaomiAPI;
using System.Diagnostics;
using MainForm.Models;
using SqlSugar;
using EasyModbus;
using ModBusClientSimple.Util;
using csharp_networkprotocol_hpsocket;
using MqttnetServerWin;
using Sunny.UI.Win32;
using MainForm.ClassFile.XiaomiAPI_AGV;
using MainForm.ClassFile.XiaomiAPI_RouteCom;
using HslCommunication.Controls;
using EIP_Protocol;
using MainForm.ClassFile.XiaomiAPI_MES;
using NPOI.Util;
using static MainForm.SQLHelper;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationInbound;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationOutbound;
using MainForm.ClassFile.ProjectClass;
using CommonLib;
using Org.BouncyCastle.Asn1.IsisMtt;
using System.Web.Services.Description;
using System.Numerics;
using MathNet.Numerics.RootFinding;
using HslCommunication.Enthernet;
using BZFAStandardLib;
using MainForm.ClassFile;
using NPOI.SS.Formula.Functions;
using static MainForm.ClassFile.XiaomiAPI.XiaomiMqttClient_Extend;
using System.Net.Http;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_UpLoadFile;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.Tab;
using System.Reflection;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationOutbound.XmMES_StationOutRequest_Body;
using FaFrameUI;
using System.Security.Policy;
using static MainForm.ClassFile.XiaomiClass.MesHelper;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationOutbound.XmMES_StationOutRequest_Body;
using System.Drawing.Imaging;
using System.Drawing;
using ICSharpCode.SharpZipLib.Zip;
using System.Text.RegularExpressions;

/*
 * 注：本源码对外提供，所以有些地方使用中文命名方法及变量
 */
namespace MainForm
{
    /// <summary>
    /// 记录日志的委托
    /// </summary>
    /// <param name="logType">日志类型</param>
    /// <param name="message">日志信息</param>
    public delegate void HomeMessageHandler(LogType logType, string message);

    /// <summary>
    /// 主页窗体
    /// </summary>
    public partial class Form_Home : Form
    {
        #region 常量

        //文本常量
        private const string Head = "开始采集";
        private const string Tail = "采集完成";
        private const string Body = "工位出站数据";
        private const string BodyCheck = "工位点检数据";
        private const string BodyRun = "整线运行数据";
        private const string BodyAlarm = "整线报警数据";

        #endregion 常量

        #region 变量

        /// <summary>
        /// 委托-记录日志的方法
        /// </summary>
        public event HomeMessageHandler MessageEvent;

        /// <summary>
        /// 日志接口
        /// </summary>
        ILogNet _PLCLogNet;

        /// <summary>
        /// 用于记录IOT MQTT日志
        /// </summary>
        ILogNet _IOTMqttLogNet;

        /// <summary>
        /// 用于记录AGV MQTT日志
        /// </summary>
        ILogNet _AGVMqttLogNet;

        //private int DataSwitch = 1;          // 1-SQLServer；2-Excel
        // 定义信号量,index0给MES（true有信号,false无信号；set()让被控线程运行,Reset()让被控线程停止；WaitOne(等待时间)等待线程运行）

        // 间隔时间
        private int IntervalReadPLC = 300; //ms 读PLC
        private int IntervalMonitorMES = 1000; //ms MES心跳

        private int IntervalAlarm = 1000; //ms 数据(报警)查询与设备运行信息

        /// <summary>
        /// 设备报警数据
        /// </summary>
        uint[] _FaultDatas = { };

        uint[] _FaultDatas_Old = { };

        uint[] _FaultDatas2 = { };
        uint[] _FaultDatas_Old2 = { };

        // 软件状态
        private bool IsRun = true;

        #region PLC 与 TCP对象

        // 定义一个字典，存plc对象(通讯)
        ModbusClientHelper plc1Alarm; // PLC‘运行数据’与‘报警数据’线程用ModbusTCP

        Dictionary<int, ModbusClientHelper> Funs = new Dictionary<int, ModbusClientHelper>();

        // 定义TCPClient对象列表
        Dictionary<int, HPSocket_TcpClientHelper>
            _HPSocket_TcpClients = new Dictionary<int, HPSocket_TcpClientHelper>();

        // 定义MQTTHelper对象
        MQTTHelper _MQTTHelper = new MQTTHelper();

        #endregion PLC 与 TCP对象

        /// <summary>
        /// 上次的设备运行信息
        /// </summary>
        private string lineWorkingData1_OldStr = string.Empty;

        /// <summary>
        /// 设备报警字典-当前结果
        /// Dictionary<工位代码,List<报警信息>>
        /// </summary>
        private Dictionary<string, List<Alarm>> DicAlarms_Cur = new Dictionary<string, List<Alarm>>();

        Dictionary<int, Inovance_EIP> FunsEip = new Dictionary<int, Inovance_EIP>();

        /// <summary>
        /// 单机用-设备状态
        /// </summary>
        //XiaomiDeviceState xmDeviceState = XiaomiDeviceState.Uninitialized;
        XiaomiDeviceStateData xmDeviceStateData = new XiaomiDeviceStateData();

        private int test_item_num = 0; //iot 过站数据序号
        public static string uuid = "";
        private bool inpass = false; //保存进站测试状态

        public static XiaoMiParm xiaomiParm = new XiaoMiParm();

        //记录上传附件的信息
        public static FileUpload_FileData fileUploadData = new FileUpload_FileData();

        #endregion 变量

        #region 窗体基础事件

        /// <summary>
        /// 初始化
        /// </summary>
        public Form_Home()
        {
            InitializeComponent();
            CheckForIllegalCrossThreadCalls = false; // 不检查跨线程访问


            _PLCLogNet = new LogNetDateTime(GlobalContext.PlcLogDir, GenerateMode.ByEveryDay); // 按天记录日志
            _IOTMqttLogNet = new LogNetDateTime(GlobalContext.MqttLogDir, GenerateMode.ByEveryDay); // 按天记录日志
            _AGVMqttLogNet = new LogNetDateTime(GlobalContext.MqttLogDir, GenerateMode.ByEveryDay); // 按天记录日志

            GlobalContext.Set += new Action(UpdateProductInfo); // 产品信息变化时更新UI
        }

        /// <summary>
        /// 窗体加载事件
        /// </summary>
        public void Form_Home_Load(object sender, EventArgs e)
        {
            try
            {
                AddMessage(LogType.Info, "开始初始化程序");

                //组建plc对象字典
                //plc1Alarm = new ModbusClientHelper(GlobalContext.Machine1Address, GlobalContext.MachinePort);
                //plc1Alarm = new Inovance_EIP(GlobalContext.PCAddress, GlobalContext.Machine1Address);

                if (GlobalContext.IsUsePLC1)
                {
                    GlobalContext.IsUsePLCNow = 1;
                    GlobalContext.IsUseStationName = "[OP10]壳体清洁上料";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC1Address, GlobalContext.Machine1Address)); //OP10 壳体清洁上料装备
                }

                if (GlobalContext.IsUsePLC2)
                {
                    GlobalContext.IsUsePLCNow = 2;
                    GlobalContext.IsUseStationName = "[OP20]上盖板上料装备";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC2Address, GlobalContext.Machine2Address)); //OP20 顶盖上料设备
                }

                if (GlobalContext.IsUsePLC3)
                {
                    GlobalContext.IsUsePLCNow = 3;
                    GlobalContext.IsUseStationName = "[OP30]点散热胶装备";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC3Address, GlobalContext.Machine3Address)); //OP30 点胶设备
                }

                if (GlobalContext.IsUsePLC4)
                {
                    GlobalContext.IsUsePLCNow = 4;
                    GlobalContext.IsUseStationName = "[OP40]胶线检测";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC4Address, GlobalContext.Machine4Address)); //OP40 3D胶线检测  
                }

                if (GlobalContext.IsUsePLC5)
                {
                    GlobalContext.IsUsePLCNow = 5;
                    GlobalContext.IsUseStationName = "[OP50]ADD板上料组装装备";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC5Address, GlobalContext.Machine5Address)); //OP50 ADD PCB板上料
                }

                if (GlobalContext.IsUsePLC6)
                {
                    GlobalContext.IsUsePLCNow = 6;
                    GlobalContext.IsUseStationName = "[OP70]组上盖板";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC6Address, GlobalContext.Machine6Address)); //OP60 顶盖装配
                }

                if (GlobalContext.IsUsePLC7)
                {
                    GlobalContext.IsUsePLCNow = 7;
                    GlobalContext.IsUseStationName = "[OP80]上盖板锁螺丝";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC7Address, GlobalContext.Machine7Address)); //OP70 锁螺丝
                }

                if (GlobalContext.IsUsePLC8)
                {
                    GlobalContext.IsUsePLCNow = 8;
                    GlobalContext.IsUseStationName = "[OP90]NG下料";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC8Address,
                            GlobalContext.Machine8Address)); //OP80 3D螺丝高度检测，NG出料站
                }

                if (GlobalContext.IsUsePLC9)
                {
                    GlobalContext.IsUsePLCNow = 9;
                    GlobalContext.IsUseStationName = "[OP100]半成品下料";
                    FunsEip.Add(GlobalContext.IsUsePLCNow,
                        new Inovance_EIP(GlobalContext.PC9Address, GlobalContext.Machine9Address)); //OP90 下料站
                }

                (bool, string) DicResult = InitalDicAlarm(); // 实例化报警字典
                AddMessage(LogType.Info, DicResult.Item2);

                foreach (Inovance_EIP plcEIP in FunsEip.Values)
                {
                    if (plcEIP != null)
                    {
                        try
                        {
                            (int, string) result = plcEIP.Connect();
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show($"PLC[{plcEIP._pcIPStr}]连接失败！失败信息：" + ex.Message,
                                "PLC连接提示", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1,
                                MessageBoxOptions.ServiceNotification);
                        }
                    }
                }

                // 采集任务
                Task TaskReadAlarm = new Task(ReadAlarmAllPLC); // 线程-获取线体报警数据
                List<Task> TaskReadProcess = new List<Task>(); // 线程-触发点位(PLC)的线程
                //TaskReadProcess.Add(new Task(() => { ReadStation_DownOrderInfo(1); }));  // 下发机种

                if (GlobalContext.IsUsePLC1)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S1(1); })); //OP10 壳体清洁上料装备
                if (GlobalContext.IsUsePLC2)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S2(2); })); //OP20 顶盖上料设备
                if (GlobalContext.IsUsePLC3)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S3(3); })); //OP30 点胶设备
                if (GlobalContext.IsUsePLC4)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S4(4); })); //OP40 点胶检测设备
                if (GlobalContext.IsUsePLC5)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S5(5); })); //OP50 ADD PCB板上料设备
                if (GlobalContext.IsUsePLC6)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S6(6); })); //OP60 顶盖装配设备
                if (GlobalContext.IsUsePLC7)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S7(7); })); //OP70 锁螺丝设备
                if (GlobalContext.IsUsePLC8)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S8(8); })); //OP80 3D螺丝高度检测设备
                if (GlobalContext.IsUsePLC9)
                    TaskReadProcess.Add(new Task(() => { ReadStation_S9(9); }));

                #region 初始化

                try
                {
                    // 开启MES（Http）
                    if (GlobalContext.IsUseMES)
                    {
                        bool mesret = HttpUitls.PingIP(GlobalContext.ServerIp);
                        if (mesret)
                        {
                            picMESStatus.Image = imageListState.Images[1];
                            GlobalContext.MESIsConnect = true;
                            AddMessage(LogType.Info, "小米MES初始连接成功!");
                        }
                        else
                        {
                            picMESStatus.Image = imageListState.Images[0];
                            GlobalContext.MESIsConnect = false;
                            AddMessage(LogType.Info, $"小米MES[{GlobalContext.ServerHost}]初始连接失败!");
                        }
                    }

                    // 开启IOT（MQTT）
                    if (GlobalContext.IsUseIot)
                    {
                        string addr = GlobalContext.MQTTServerHost;
                        int port = GlobalContext.MQTTServerPort;
                        //生产环境需要修改
                        (int, string) qmttResult = XiaomiMqttClient_Extend.OpenWithMqttServer("127.0.0.1", 6666,
                            GlobalContext.MqttServerPath, GlobalContext.MqttServerName);
                        XiaomiMqttResponse_ErrCode response_ErrCode = (XiaomiMqttResponse_ErrCode)qmttResult.Item1;
                        if (response_ErrCode == XiaomiMqttResponse_ErrCode.OK)
                        {
                            picIot.Image = imageListState.Images[1];
                            AddMessage(LogType.Info, "小米IOT MQTT初始连接成功!");

                            // 设置回调函数
                            //XiaomiMqttClient_Extend.SetCallbackWithDataId(CallbackWithDataId);
                            // 配置参数
                            XiaomiMqttLoginFunAndParam param = new XiaomiMqttLoginFunAndParam();
                            // fds
                            param.parameter.fds.address = GlobalContext.address;
                            param.parameter.fds.appId = GlobalContext.appId;
                            param.parameter.fds.appKey = GlobalContext.appKey;
                            // mes
                            param.parameter.mes.address = GlobalContext.ServerIp;
                            param.parameter.mes.appId = GlobalContext.MESAppId;
                            param.parameter.mes.appKey = GlobalContext.MESAppKey;
                            // mqtt
                            param.parameter.mqtt.address = GlobalContext.MQTTServerHost;
                            param.parameter.mqtt.port = GlobalContext.MQTTServerPort;
                            param.parameter.mqtt.username = GlobalContext.MQTTAppId;
                            param.parameter.mqtt.password = GlobalContext.MQTTAppPwd;
                            // 设备配置
                            param.parameter.equipment.factoryCode = GlobalContext.Factory_Code;
                            if (GlobalContext.IsUsePLC1)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.S1_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.S1_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.S1_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC2)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.S2_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.S2_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.S2_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC3)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s3_1_device_code; // 装备编码
                                //param.parameter.equipment.stationCode = GlobalContext.s3_1_station;     // ⼯位Id
                            }

                            if (GlobalContext.IsUsePLC4)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s4_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.s4_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.s4_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC5)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s5_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.s5_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.s5_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC6)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s6_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.s6_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.s6_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC7)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s7_1_device_code; // 装备编码
                                //param.parameter.equipment.stationCode = GlobalContext.s7_1_station;     // ⼯位Id
                                xiaomiParm.stationCode = GlobalContext.s7_1_station;
                            }

                            if (GlobalContext.IsUsePLC8)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s8_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.s8_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.s8_work_station; //工站
                            }

                            if (GlobalContext.IsUsePLC9)
                            {
                                param.parameter.equipment.deviceCode = GlobalContext.s9_device_code; // 装备编码
                                param.parameter.equipment.stationCode = GlobalContext.s9_station; // ⼯位Id
                                xiaomiParm.workstation = GlobalContext.s9_work_station; //工站
                            }

                            param.parameter.equipment.project = GlobalContext.Project_Code;
                            param.parameter.equipment.productMode = "debug";

                            param.parameter.other.logLevel = 0;
                            param.parameter.other.LogPath = GlobalContext.MqttLogDir;

                            XiaomiMqttClient_Extend.ParameterConfig(param);
                            //保存全局变量
                            xiaomiParm.stationCode = param.parameter.equipment.stationCode;
                            xiaomiParm.deviceCode = param.parameter.equipment.deviceCode;
                        }
                        else
                        {
                            picIot.Image = imageListState.Images[0];
                            AddMessage(LogType.Info,
                                $"小米IOT MQTT[{GlobalContext.MQTTServerHost}:{GlobalContext.MQTTServerPort}]初始连接失败!--- {response_ErrCode.ToString()}");
                        }
                    }

                    // 开启AGV（Http与MQTT）
                    if (GlobalContext.IsUseAGV)
                    {
                        // AGV HTTP
                        bool mesret1 = HttpUitls.PingIP(GlobalContext.AGVHttpIp);
                        if (mesret1)
                        {
                            picAgvHttp.Image = imageListState.Images[1];
                            AddMessage(LogType.Info, "AGV Http初始连接成功!");
                        }
                        else
                        {
                            picAgvHttp.Image = imageListState.Images[0];
                            AddMessage(LogType.Info, $"AGV Http[{GlobalContext.AGVHttpHost}]初始连接失败!");
                        }

                        string agvMqttIp = GlobalContext.MQTTServerHost;
                        int agvMqttPort = GlobalContext.MQTTServerPort;
                        Action<ResultData_MQTT> callback = AGVMqttShowLog;
                        ResultData_MQTT result_MQTT = _MQTTHelper
                            .CreateMQTTClientAndStart(agvMqttIp, agvMqttPort, null, null, callback).Result; // 连接MQTT服务器
                        // AGV MQTT
                        if (result_MQTT.ResultCode == 1)
                        {
                            picAgvMqtt.Image = imageListState.Images[1];
                            GlobalContext.AGVMQTTIsConnect = true;
                            AddMessage(LogType.Info, "小米AGV MQTT初始连接成功!");

                            ResultData_MQTT result =
                                XiaomiAGVMQTT_Base.DeviceTopicAGV(ref _MQTTHelper, GlobalContext.AGVMQTTDeviceCode);
                            AddMessage(LogType.Info,
                                $"小米AGV MQTT订阅{GlobalContext.AGVMQTTDeviceCode}--- [{result.ResultCode}]{result.ResultMsg}!");
                        }
                        else
                        {
                            picAgvMqtt.Image = imageListState.Images[0];
                            GlobalContext.AGVMQTTIsConnect = false;
                            AddMessage(LogType.Info,
                                $"小米AGV MQTT[{GlobalContext.AGVMQTTHost}:{GlobalContext.AGVMQTTPort}]初始连接失败!--- [{result_MQTT.ResultCode}]{result_MQTT.ResultMsg}");
                        }
                    }

                    // 持续监视MES、IOT、AGV HTTP、AGV MQTT连接状态
                    Task.Run(MonitorMESConnect);

                    // 查询PLC连接状态
                    foreach (int plcNo in FunsEip.Keys)
                    {
                        bool connected = FunsEip[plcNo].IsConnected;
                        if (connected)
                        {
                            string msg = plcNo.ToString() + "工位初始连接成功---" + FunsEip[plcNo]._pcIPStr;
                            AddMessage(LogType.Info, msg);
                            UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI
                        }
                        else
                        {
                            string msg = plcNo.ToString() + "工位初始连接失败---" + FunsEip[plcNo]._pcIPStr;
                            AddMessage(LogType.Info, msg);
                            UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        }
                    }
                    // PLC4时 初始化扫码器TCP
                    //if (GlobalContext.IsUsePLC4)
                    //    HpTCPClientInit();

                    // 开启PLC的业务处理线程-监听PLC点位+状态
                    foreach (Task task in TaskReadProcess)
                    {
                        if (task != null)
                            task.Start();
                    }

                    //// 开启iot的线程
                    TaskReadAlarm.Start();
                    ////下传MES信息给1工位（先判断下plc对象数量）
                    //if (Funs.Count > 1)
                    //    DownLoadProductInfo(1);

                    if (GlobalContext.IsUsePLC3 || GlobalContext.IsUsePLC7)
                    {
                        state_l.Text = "设备状态(左):";
                        state_r.Text = "设备状态(右):";
                        state_r.Visible = true;
                        lblDeviceStates2.Visible = true;
                    }

                    //上传操作记录
                    operateToIot("startup", "开启");
                    AddMessage(LogType.Info, "程序初始化完成");
                }
                catch (Exception ex)
                {
                    string str = ex.StackTrace;

                    this.BeginInvoke(new Action(() =>
                    {
                        AddMessage(LogType.Error,
                            "初始化PLC连接失败!异常信息：" + ex.Message + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                                str.Length - str.LastIndexOf("\\") - 1));
                    }));
                }

                #endregion
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;

                OnMessage(LogType.Info,
                    "主窗体的首页初始化出错！异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1) + "；异常信息：" +
                    ex.Message.ToString());
                if (ex.Message != null && ex.Message.Contains("timed out"))
                    MessageBox.Show("主窗体的首页初始化出错！异常信息：PLC连接超时！" + ex.Message);
                else
                    MessageBox.Show("主窗体的首页初始化出错！异常信息：" + ex.Message);
            }
        }

        /// <summary>
        /// 窗体关闭事件
        /// </summary>
        private void Form_Home_FormClosed(object sender, FormClosedEventArgs e)
        {
            Closed2();
        }

        public void Closed2()
        {
            try
            {
                IsRun = false;
                Thread.Sleep(IntervalReadPLC);

                // 断开TCP
                int count = _HPSocket_TcpClients.Count();
                for (int i = 0; i < count; i++)
                {
                    try
                    {
                        if (_HPSocket_TcpClients[i] != null && _HPSocket_TcpClients[i]._client.IsConnected)
                        {
                            _HPSocket_TcpClients[i].Stop();
                            _HPSocket_TcpClients[i]._client.OnPrepareConnect -= OnPrepareConnect; // 准备连接了事件
                            _HPSocket_TcpClients[i]._client.OnConnect -= OnConnect; // 连接事件
                            _HPSocket_TcpClients[i]._client.OnSend -= OnSend; // 数据包发送事件
                            _HPSocket_TcpClients[i]._client.OnReceive -= OnReceive; // 数据包到达事件
                            _HPSocket_TcpClients[i]._client.OnClose -= OnClose; // TCP连接关闭事件
                        }
                    }
                    catch
                    {
                    }
                }

                // 关闭Iot
                try
                {
                    XiaomiMqttClient_Extend.CloseWithMqttServer(GlobalContext.MqttServerPath,
                        GlobalContext.MqttServerName);
                }
                catch
                {
                }

                // 关闭AGV Mqtt
                try
                {
                    _MQTTHelper.DisconnectAsync_Client().Wait();
                }
                catch
                {
                }
            }
            catch
            {
            }
        }

        #endregion 窗体基础事件

        #region 监控MES状态

        /// <summary>
        /// 监控MES连接状态
        /// </summary>
        private void MonitorMESConnect()
        {
            while (IsRun) // 运行被控线程
            {
                try
                {
                    // 开启MES（Http）
                    if (GlobalContext.IsUseMES)
                    {
                        bool mesret = HttpUitls.PingIP(GlobalContext.ServerIp);
                        if (mesret)
                        {
                            picMESStatus.Image = imageListState.Images[1];
                            GlobalContext.MESIsConnect = true;
                        }
                        else
                        {
                            picMESStatus.Image = imageListState.Images[0];
                            GlobalContext.MESIsConnect = false;
                            OnMessage(LogType.Info, $"小米MES[{GlobalContext.ServerHost}]连接失败");
                        }
                    }

                    // 开启IOT（MQTT）
                    if (GlobalContext.IsUseIot)
                    {
                        bool iIot = XiaomiMqttClient.IsOpen;
                        if (iIot)
                            picIot.Image = imageListState.Images[1];
                        else
                        {
                            picIot.Image = imageListState.Images[0];
                            OnMessage(LogType.Info,
                                $"小米IOT MQTT[{GlobalContext.MQTTServerHost}:{GlobalContext.MQTTServerPort}]连接失败");
                        }
                    }

                    // 开启AGV（Http与MQTT）
                    if (GlobalContext.IsUseAGV)
                    {
                        // AGV Http
                        bool mesret1 = HttpUitls.PingIP(GlobalContext.AGVHttpIp);
                        if (mesret1)
                            picAgvHttp.Image = imageListState.Images[1];
                        else
                        {
                            picAgvHttp.Image = imageListState.Images[0];
                            OnMessage(LogType.Info, $"小米AGV Http[{GlobalContext.AGVHttpHost}]连接失败");
                        }

                        // AGV MQTT
                        if (GlobalContext.AGVMQTTIsConnect)
                            picAgvMqtt.Image = imageListState.Images[1];
                        else
                        {
                            picAgvMqtt.Image = imageListState.Images[0];
                            OnMessage(LogType.Info,
                                $"小米AGV MQTT[{GlobalContext.AGVMQTTHost}:{GlobalContext.AGVMQTTPort}]连接失败");
                        }
                    }
                }
                catch (Exception ex)
                {
                    string str = ex.StackTrace;
                    AddMessage(LogType.Error,
                        "监控MES心跳失败!异常信息：" + ex.Message + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                            str.Length - str.LastIndexOf("\\") - 1));
                }

                Thread.Sleep(IntervalMonitorMES);
            }
        }

        #endregion 监控MES连接状态

        #region 采集设备状态、运行数据、报警数据

        /// <summary>
        /// 请求设备状态 5000
        /// </summary>
        /// <param name="no">1</param>
        /// <param name="stationNameStr"></param>
        /// <returns>0：证明未连接到PLC；1,代表设备控制状态处于运行状态;2,代表设备控制状态处于故障状态;3,代表设备控制状态处于缺料状态;4,代表设备控制状态处于待机状态;5,代表设备控制状态处于维修状态;</returns>
        public int GetDeviceStatus(int plcNo, string stationNameStr = "[S0]壳体上料")
        {
            try
            {
                if (Funs[plcNo].IsConnected) // 检查PLC是否已连接上
                {
                    short result = Funs[plcNo].ReadHoldingRegisters<short>(5000); // 5000
                    return result;
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    "请求设备状态失败！" + ex.Message.ToString() + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));
                return 0;
            }
        }

        /// <summary>
        /// 检查是否可采集点检数据 - 不取新值
        /// 5000不为1时可点检
        /// </summary>
        /// <returns></returns>
        public bool CheckCanSpotcheck1(int deviceState)
        {
            //return true;
            //D5000 = 1,代表设备控制状态处于运行状态
            //D5000 = 2, 代表设备控制状态处于故障状态
            //D5000 = 3,代表设备控制状态处于缺料状态
            //D5000 = 4, 代表设备控制状态处于待机状态
            //D5000 = 5,代表设备控制状态处于维修状态
            return deviceState != 1;
        }

        /// <summary>
        /// 检查是否可采集产品数据 - 不取新值
        /// </summary>
        /// <returns></returns>
        public bool CheckCanCollData(int deviceState)
        {
            return deviceState == 0; // 点检时该值不为0
        }

        /// <summary>
        /// 采集到的设备状态
        /// </summary>
        private string _DeviceStates = "未知状态";

        private string _DeviceStates_Old = "未知状态";

        private string _DeviceStates2 = "未知状态";
        private string _DeviceStates_Old2 = "未知状态";

        /// <summary>
        /// 获取设备报警数据与获取设备运行信息
        /// </summary>
        private async void ReadAlarmAllPLC()
        {
            /// 获取设备报警数据与状态信息
            string stationNameStr = "获取设备报警数据与状态信息";
            // 已连接到PLC
            while (IsRun)
            {
                try
                {
                    #region 报警数据

                    try
                    {
                        //_FaultDatas = new uint[] { 4, 0, 30, 10 };
                        if (_FaultDatas.Length > 0)
                        {
                            ReadPLCAlarmToIot(_FaultDatas, _FaultDatas_Old, stationNameStr);
                        }
                        else
                        {
                            AddMessage_Station(stationNameStr, LogType.Error, $"【报警日志】{stationNameStr}_获取报警数据出错！");
                        }

                        if (_FaultDatas2.Length > 0)
                        {
                            ReadPLCAlarmToIot(_FaultDatas2, _FaultDatas_Old2, stationNameStr);
                        }
                        else
                        {
                            AddMessage_Station(stationNameStr, LogType.Error, $"【报警日志】{stationNameStr}_获取报警数据出错！");
                        }
                    }
                    catch (Exception ex)
                    {
                        string str = ex.StackTrace;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"【报警日志】{stationNameStr}_获取报警数据出错！错误信息：" + ex.Message.ToString() + "异常位置：" +
                            str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                    }

                    #endregion 报警数据


                    #region 设备状态

                    //if (!GlobalContext._IsCon_plc1Alarm)
                    //{
                    //    UpdatePLCMonitor(1, -2, 0);
                    //    continue;
                    //}
                    foreach (Inovance_EIP plcEIP in FunsEip.Values)
                    {
                        if (plcEIP != null)
                        {
                            if (plcEIP.IsConnected)
                            {
                                #region 主页展示设备运行状态并上传到IOT中,有双工位left就是左工位，没有双工位left就是单工位

                                switch (xmDeviceStateData.left)
                                {
                                    case XiaomiDeviceState.Uninitialized: // 未初始化状态（未初始状态，需先初始化装备才能运行）
                                        _DeviceStates = "未初始化状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Initializing: // 初始化状态（初始化进行中）
                                        _DeviceStates = "初始化状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Initialized: // 初始化完成状态（初始化完成）
                                        _DeviceStates = "初始化完成状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Running: // 运行状态（正常运行中）
                                        _DeviceStates = "运行状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Paused: // 暂停状态（设备运行中人工操作暂停，进入此状态）
                                        _DeviceStates = "暂停状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Fault: // 故障状态（发生故障后进入此状态，同时停止运行）
                                        _DeviceStates = "故障状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                    case XiaomiDeviceState.Alarm: // 警报状态（产生报警后进入此状态，同时停止运行）
                                        _DeviceStates = "警报状态";
                                        lblDeviceStates.Text = _DeviceStates;
                                        break;
                                }

                                if (!_DeviceStates.Equals(_DeviceStates_Old))
                                {
                                    var iotResult =
                                        SaveDeviceStateData(stationNameStr, xmDeviceStateData.left, "left"); // 上传+保存
                                    if (iotResult.Item1 == 1)
                                    {
                                        _DeviceStates_Old = _DeviceStates;
                                        AddMessage_Station(stationNameStr, LogType.Info,
                                            "【设备状态】" + stationNameStr + $"_上传设备状态到Iot成功!");
                                    }
                                    else
                                        AddMessage_Station(stationNameStr, LogType.Info,
                                            "【设备状态】" + stationNameStr +
                                            $"_上传设备状态到Iot失败!报错信息:[{iotResult.Item1}]_{iotResult.Item2}");
                                }

                                #endregion 主页展示设备运行状态并上传到IOT中


                                #region 右工位

                                if (GlobalContext.IsUsePLC3 || GlobalContext.IsUsePLC7)
                                {
                                    switch (xmDeviceStateData.right)
                                    {
                                        case XiaomiDeviceState.Uninitialized: // 未初始化状态（未初始状态，需先初始化装备才能运行）
                                            _DeviceStates2 = "未初始化状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Initializing: // 初始化状态（初始化进行中）
                                            _DeviceStates2 = "初始化状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Initialized: // 初始化完成状态（初始化完成）
                                            _DeviceStates2 = "初始化完成状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Running: // 运行状态（正常运行中）
                                            _DeviceStates2 = "运行状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Paused: // 暂停状态（设备运行中人工操作暂停，进入此状态）
                                            _DeviceStates2 = "暂停状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Fault: // 故障状态（发生故障后进入此状态，同时停止运行）
                                            _DeviceStates2 = "故障状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                        case XiaomiDeviceState.Alarm: // 警报状态（产生报警后进入此状态，同时停止运行）
                                            _DeviceStates2 = "警报状态";
                                            lblDeviceStates.Text = _DeviceStates2;
                                            break;
                                    }

                                    if (!_DeviceStates2.Equals(_DeviceStates_Old2))
                                    {
                                        var iotResult = SaveDeviceStateData(stationNameStr, xmDeviceStateData.left,
                                            "right"); // 上传+保存
                                        if (iotResult.Item1 == 1)
                                        {
                                            _DeviceStates_Old2 = _DeviceStates2;
                                            AddMessage_Station(stationNameStr, LogType.Info,
                                                "【设备状态】" + stationNameStr + $"_上传Iot成功!");
                                        }
                                        else
                                            AddMessage_Station(stationNameStr, LogType.Info,
                                                "【设备状态】" + stationNameStr +
                                                $"_上传Iot失败!报错信息:[{iotResult.Item1}]_{iotResult.Item2}");
                                    }
                                }

                                #endregion 右工位
                            }
                        }
                    }

                    #endregion


                    //if (plc1Alarm.IsConnected)  // 检查PLC是否已连接上
                    //{


                    //    DateTime dtNow = DateTime.Now;
                    //    //#region 获取设备运行信息
                    //    //try
                    //    //{
                    //    //    LineWorkingData_ThisTime lineWorkingData1 = new LineWorkingData_ThisTime();
                    //    //    lineWorkingData1.GUID = Guid.NewGuid().ToString();
                    //    //    lineWorkingData1.LineName = GlobalContext.LineCode;

                    //    //    // 
                    //    //    lineWorkingData1.BootTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5500);     // 本次开机时间（整线）D5500 h
                    //    //    lineWorkingData1.NormalTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5502);   // 本次开机运行时间（整线）D5502 h
                    //    //    lineWorkingData1.StandbyTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5504);  // 本次开机待机时间（整线）D5504 h
                    //    //    lineWorkingData1.FaultTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5506);    // 本次开机故障时间（整线）D5506 h
                    //    //    lineWorkingData1.MaterialShortageTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5508);  // 本次开机缺料时间（整线）D5508 h
                    //    //    lineWorkingData1.MaintenanceTimeLong = plc1Alarm.ReadHoldingRegisters<float>(5510);       // 本次开机维修时间（整线）D5510 h
                    //    //    lineWorkingData1.FaultNumber = plc1Alarm.ReadHoldingRegisters<short>(5514);      // 本次开机故障停机次数（整线）D5514
                    //    //    lineWorkingData1.OutputNumber = plc1Alarm.ReadHoldingRegisters<short>(5700);     // 本次开机产量(整线) D5700
                    //    //    lineWorkingData1.QualifiedNumber = plc1Alarm.ReadHoldingRegisters<short>(5704);  // 本次开机合格数量(整线) D5704
                    //    //    lineWorkingData1.QualifiedRate = plc1Alarm.ReadHoldingRegisters<float>(5710);    // 本次开机合格率(整线) D5710
                    //    //    lineWorkingData1.DesignRhythm = plc1Alarm.ReadHoldingRegisters<float>(5714);     // 设计节拍(整线) D5714
                    //    //    lineWorkingData1.RealityRhythm = plc1Alarm.ReadHoldingRegisters<float>(5716);    // 本次开机实际节拍(整线) D5716
                    //    //    lineWorkingData1.CreateTime = DateTime.Now;

                    //    //    string lineWorkingData1_Str = JsonConvert.SerializeObject(lineWorkingData1);

                    //    //    // UI展示-展示到设备状态页
                    //    //    if (string.IsNullOrEmpty(lineWorkingData1_OldStr))  //  软件启动后第一次运行
                    //    //    {
                    //    //        // 查询数据库最新一条数据，确定是不是更新
                    //    //        string qSql = @"SELECT top(1) [GUID]
                    //    //          ,[LineName]
                    //    //          ,[BootTimeLong]
                    //    //          ,[NormalTimeLong]
                    //    //          ,[StandbyTimeLong]
                    //    //          ,[FaultTimeLong]
                    //    //          ,[MaterialShortageTimeLong]
                    //    //          ,[MaintenanceTimeLong]
                    //    //          ,[FaultNumber]
                    //    //          ,[OutputNumber]
                    //    //          ,[QualifiedNumber]
                    //    //          ,[QualifiedRate]
                    //    //          ,[DesignRhythm]
                    //    //          ,[RealityRhythm]
                    //    //          ,[CreateTime]
                    //    //      FROM [LineWorkingData]
                    //    //      where [CreateTime] > '{0}'
                    //    //      and [LineName]='{1}'
                    //    //      order by [CreateTime] desc
                    //    //    ";
                    //    //        qSql = string.Format(qSql, DateTime.Now.ToString("yyyy-MM-dd") + " 00:00:00", lineWorkingData1.LineName);

                    //    //        var ds = SQLHelper_New.Query(qSql, null);
                    //    //        if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                    //    //        {
                    //    //            var dataDBlast = new LineWorkingData_ThisTime();
                    //    //            dataDBlast.GUID = ds.Tables[0].Rows[0][0].ToString();                             // 主键
                    //    //            dataDBlast.LineName = ds.Tables[0].Rows[0][1].ToString();                         // 线体名称
                    //    //            dataDBlast.BootTimeLong = Convert.ToSingle(ds.Tables[0].Rows[0][2].ToString());   // 本次开机时间（整线）
                    //    //            dataDBlast.CreateTime = Convert.ToDateTime(ds.Tables[0].Rows[0][14].ToString());  // 创建时间

                    //    //            if (lineWorkingData1.BootTimeLong > dataDBlast.BootTimeLong)  // 需要更新的情况；不需要更新的走后面的插入
                    //    //            {
                    //    //                dataDBlast.BootTimeLong = lineWorkingData1.BootTimeLong;        // 本次开机时间（整线）
                    //    //                dataDBlast.NormalTimeLong = lineWorkingData1.NormalTimeLong;    // 本次开机运行时间（整线）
                    //    //                dataDBlast.StandbyTimeLong = lineWorkingData1.StandbyTimeLong;  // 本次开机待机时间（整线）
                    //    //                dataDBlast.FaultTimeLong = lineWorkingData1.FaultTimeLong;      // 本次开机故障时间（整线）
                    //    //                dataDBlast.MaterialShortageTimeLong = lineWorkingData1.MaterialShortageTimeLong;  // 本次开机缺料时间（整线）
                    //    //                dataDBlast.MaintenanceTimeLong = lineWorkingData1.MaintenanceTimeLong;            // 本次开机维修时间（整线）
                    //    //                dataDBlast.FaultNumber = lineWorkingData1.FaultNumber;          // 本次开机故障停机次数（整线）
                    //    //                dataDBlast.OutputNumber = lineWorkingData1.OutputNumber;        // 本次开机产量(整线)
                    //    //                dataDBlast.QualifiedNumber = lineWorkingData1.QualifiedNumber;  // 本次开机合格数量(整线)
                    //    //                dataDBlast.QualifiedRate = lineWorkingData1.QualifiedRate;      // 本次开机合格率(整线)
                    //    //                dataDBlast.DesignRhythm = lineWorkingData1.DesignRhythm;        // 设计节拍(整线)
                    //    //                dataDBlast.RealityRhythm = lineWorkingData1.RealityRhythm;      // 本次开机实际节拍(整线)

                    //    //                string usql = dataDBlast.ToStringUpdate();
                    //    //                SQLHelper_New.ExecuteSQL(usql, null);
                    //    //                lineWorkingData1_OldStr = JsonConvert.SerializeObject(dataDBlast);

                    //    //                AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyRun}完毕！[{lineWorkingData1_OldStr}]");
                    //    //                //AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyRun}完毕！");
                    //    //            }
                    //    //        }
                    //    //        else
                    //    //        {
                    //    //            // 插入
                    //    //            SQLHelper_New.ExecuteSQL(lineWorkingData1.ToStringInsert(), null);
                    //    //            lineWorkingData1_OldStr = String.Copy(lineWorkingData1_Str);
                    //    //            AddMessage_Station(stationNameStr, LogType.Info, $"保存{BodyRun}完毕！[{lineWorkingData1_OldStr}]");
                    //    //            //AddMessage_Station(stationNameStr, LogType.Info, $"保存{BodyRun}完毕！");
                    //    //        }
                    //    //    }
                    //    //    else if (!lineWorkingData1_Str.Equals(lineWorkingData1_OldStr))  // 非“软件启动后第一次运行”
                    //    //    {
                    //    //        LineWorkingData_ThisTime lineWorkingData1_Old = string.IsNullOrEmpty(lineWorkingData1_OldStr) ? lineWorkingData1 : JsonConvert.DeserializeObject<LineWorkingData_ThisTime>(lineWorkingData1_OldStr);  // 上次的状态信息

                    //    //        //// 本次开机设备运行情况
                    //    //        //LineWorkingData1_ThisTime lineWorkingData_UI = JsonConvert.DeserializeObject<LineWorkingData1_ThisTime>(lineWorkingData1_OldStr);
                    //    //        //Task.Run(() =>
                    //    //        //{
                    //    //        //    if (Form_Main.formDevAlarm != null && !Form_Main.formDevAlarm.IsDisposed && Form_Main.formDevAlarm.Visible)
                    //    //        //    {
                    //    //        //        Form_Main.formDevAlarm.UpdDeviceStatus_ThisTime(lineWorkingData_UI);  // UI更新
                    //    //        //    }
                    //    //        //});

                    //    //        // 本日设备运行情况
                    //    //        // 存数据库（开机时间>上次的开机时间，则更新上次记录；<则作为新数据插入）
                    //    //        if (lineWorkingData1.BootTimeLong > lineWorkingData1_Old.BootTimeLong)
                    //    //        {
                    //    //            // 更新
                    //    //            lineWorkingData1_Old.BootTimeLong = lineWorkingData1.BootTimeLong;        // 本次开机时间（整线）
                    //    //            lineWorkingData1_Old.NormalTimeLong = lineWorkingData1.NormalTimeLong;    // 本次开机运行时间（整线）
                    //    //            lineWorkingData1_Old.StandbyTimeLong = lineWorkingData1.StandbyTimeLong;  // 本次开机待机时间（整线）
                    //    //            lineWorkingData1_Old.FaultTimeLong = lineWorkingData1.FaultTimeLong;      // 本次开机故障时间（整线）
                    //    //            lineWorkingData1_Old.MaterialShortageTimeLong = lineWorkingData1.MaterialShortageTimeLong;  // 本次开机缺料时间（整线）
                    //    //            lineWorkingData1_Old.MaintenanceTimeLong = lineWorkingData1.MaintenanceTimeLong;            // 本次开机维修时间（整线）
                    //    //            lineWorkingData1_Old.FaultNumber = lineWorkingData1.FaultNumber;          // 本次开机故障停机次数（整线）
                    //    //            lineWorkingData1_Old.OutputNumber = lineWorkingData1.OutputNumber;        // 本次开机产量(整线)
                    //    //            lineWorkingData1_Old.QualifiedNumber = lineWorkingData1.QualifiedNumber;  // 本次开机合格数量(整线)
                    //    //            lineWorkingData1_Old.QualifiedRate = lineWorkingData1.QualifiedRate;      // 本次开机合格率(整线)
                    //    //            lineWorkingData1_Old.DesignRhythm = lineWorkingData1.DesignRhythm;        // 设计节拍(整线)
                    //    //            lineWorkingData1_Old.RealityRhythm = lineWorkingData1.RealityRhythm;      // 本次开机实际节拍(整线)

                    //    //            SQLHelper_New.ExecuteSQL(lineWorkingData1_Old.ToStringUpdate(), null);
                    //    //            lineWorkingData1_OldStr = JsonConvert.SerializeObject(lineWorkingData1_Old);
                    //    //            AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyRun}完毕！[{lineWorkingData1_OldStr}]");
                    //    //            //AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyRun}完毕！");
                    //    //        }
                    //    //        else if (lineWorkingData1.BootTimeLong < lineWorkingData1_Old.BootTimeLong)
                    //    //        {
                    //    //            // 插入
                    //    //            SQLHelper_New.ExecuteSQL(lineWorkingData1.ToStringInsert(), null);
                    //    //            lineWorkingData1_OldStr = String.Copy(lineWorkingData1_Str);
                    //    //            AddMessage_Station(stationNameStr, LogType.Info, $"保存{BodyRun}完毕！[{lineWorkingData1_OldStr}]");
                    //    //            //AddMessage_Station(stationNameStr, LogType.Info, $"保存{BodyRun}完毕！");
                    //    //        }

                    //    //        await Task.Run(() =>
                    //    //        {
                    //    //            try
                    //    //            {
                    //    //                if (Form_Main.formDevAlarm != null && !Form_Main.formDevAlarm.IsDisposed && Form_Main.formDevAlarm.Visible)
                    //    //                {
                    //    //                    Form_Main.formDevAlarm.UpdDeviceStatus_Today();  // UI更新
                    //    //                }
                    //    //            }
                    //    //            catch { }
                    //    //        });
                    //    //    }
                    //    //}
                    //    //catch (Exception ex)
                    //    //{
                    //    //    string str = ex.StackTrace;
                    //    //    AddMessage_Station(stationNameStr, LogType.Error, $"PLC1_{stationNameStr}_获取设备运行信息出错！错误信息：" + ex.Message.ToString() + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                    //    //}
                    //    //#endregion 获取设备运行信息

                    //    #region 报警数据
                    //    try
                    //    {
                    //        List<DeviceAlarm_Cur> deviceAlarm_Curs = new List<DeviceAlarm_Cur>();  // 同步到报警页面用传输载体
                    //        bool isNeedUpdUI = false;  // 是否需要更新历史报警UI

                    //        // 同步“设备报警信息”到“设备报警临时字典DicAlarms_Cur”
                    //        var dicAlarms_Cur_PLC1 = DicAlarms_Cur[GlobalContext.LineCode];
                    //        for (int i = 0; i < dicAlarms_Cur_PLC1.Count; i++)  // 读取
                    //        {
                    //            short shortBuf = plc1Alarm.ReadHoldingRegisters<short>(dicAlarms_Cur_PLC1[i].关联的PLC地址);

                    //            dicAlarms_Cur_PLC1[i].是否报警 = shortBuf != 0;
                    //            if (dicAlarms_Cur_PLC1[i].上次的运行状态 != dicAlarms_Cur_PLC1[i].是否报警)
                    //            {
                    //                isNeedUpdUI = true;  // 需要更新历史报警UI信息
                    //                // 记录
                    //                dicAlarms_Cur_PLC1[i].上次的运行状态 = dicAlarms_Cur_PLC1[i].是否报警;

                    //                switch (dicAlarms_Cur_PLC1[i].是否报警)
                    //                {
                    //                    case true:  // 报警
                    //                        dicAlarms_Cur_PLC1[i].报警数据 = new AlarmData()
                    //                        {
                    //                            GUID = Guid.NewGuid().ToString(),
                    //                            LineName = GlobalContext.LineCode,  // 线体
                    //                            AlarmType = dicAlarms_Cur_PLC1[i].报警类型,  // 报警类型
                    //                            AlarmDesc = dicAlarms_Cur_PLC1[i].报警详情,  // 报警内容
                    //                            StartTime = dtNow  // 开始时间
                    //                        };

                    //                        // 传输到页面
                    //                        deviceAlarm_Curs.Add(new DeviceAlarm_Cur()
                    //                        {
                    //                            线体名称 = dicAlarms_Cur_PLC1[i].报警数据.LineName,
                    //                            报警类型 = dicAlarms_Cur_PLC1[i].报警数据.AlarmType,
                    //                            报警内容 = dicAlarms_Cur_PLC1[i].报警数据.AlarmDesc,
                    //                            开始时间 = dtNow
                    //                        });

                    //                        // 新增到数据库
                    //                        var data1 = dicAlarms_Cur_PLC1[i].报警数据;
                    //                        SaveAlarmDataByDB(stationNameStr, data1, false);
                    //                        AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyAlarm}完毕！");
                    //                        break;
                    //                    case false:  // 消除报警
                    //                        if (dicAlarms_Cur_PLC1[i].报警数据 == null || string.IsNullOrEmpty(dicAlarms_Cur_PLC1[i].报警数据.GUID))
                    //                        {
                    //                            dicAlarms_Cur_PLC1[i].报警数据 = new AlarmData()
                    //                            {
                    //                                GUID = Guid.NewGuid().ToString(),
                    //                                LineName = GlobalContext.LineCode,      // 线体
                    //                                AlarmType = dicAlarms_Cur_PLC1[i].报警类型,  // 报警类型
                    //                                AlarmDesc = dicAlarms_Cur_PLC1[i].报警详情,  // 报警内容
                    //                                StartTime = dtNow,  // 开始时间
                    //                                EndTime = dtNow,    // 开始时间
                    //                                PersistTime = 1,    // 耗时1s
                    //                            };

                    //                            // 新增
                    //                            var data2 = dicAlarms_Cur_PLC1[i].报警数据;
                    //                            SaveAlarmDataByDB(stationNameStr, data2, false);
                    //                            AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyAlarm}完毕！");
                    //                        }
                    //                        else
                    //                        {
                    //                            dicAlarms_Cur_PLC1[i].报警数据.EndTime = dtNow;  // 开始时间
                    //                            dicAlarms_Cur_PLC1[i].报警数据.PersistTime = Convert.ToInt32((dicAlarms_Cur_PLC1[i].报警数据.EndTime
                    //                                - dicAlarms_Cur_PLC1[i].报警数据.StartTime).TotalSeconds);  // 耗时s

                    //                            // 修改
                    //                            var data3 = dicAlarms_Cur_PLC1[i].报警数据;
                    //                            SaveAlarmDataByDB(stationNameStr, data3, true);
                    //                            AddMessage_Station(stationNameStr, LogType.Info, $"更新{BodyAlarm}完毕！");
                    //                        }
                    //                        break;
                    //                    default:
                    //                        break;
                    //                }
                    //            }
                    //        }
                    //        DicAlarms_Cur[GlobalContext.LineCode] = dicAlarms_Cur_PLC1;

                    //        // 有新报警则更新
                    //        if (isNeedUpdUI)
                    //        {
                    //            // UI展示 - 展示到设备状态页
                    //            await Task.Run(() =>
                    //            {
                    //                try
                    //                {
                    //                    if (Form_Main.formDevAlarm != null && !Form_Main.formDevAlarm.IsDisposed)
                    //                    {
                    //                        Form_Main.formDevAlarm.UpdDeviceAlarm_Cur(deviceAlarm_Curs);  // 报警UI 更新
                    //                        if (Form_Main.formDevAlarm.Visible)
                    //                        {
                    //                            Form_Main.formDevAlarm.UpdDeviceAlarm_History_48H();  //  历史报警UI 更新
                    //                        }
                    //                    }
                    //                }
                    //                catch { }
                    //            });
                    //        }
                    //    }
                    //    catch (Exception ex)
                    //    {
                    //        string str = ex.StackTrace;
                    //        AddMessage_Station(stationNameStr, LogType.Error, $"PLC1_{stationNameStr}_获取报警数据出错！错误信息：" + ex.Message.ToString() + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                    //    }
                    //    #endregion 报警数据

                    //    UpdatePLCMonitor(1, -2, 1);
                    //}
                    //else
                    //{
                    //    UpdatePLCMonitor(1, -2, 0);
                    //}
                }
                catch (Exception ex)
                {
                    //AddMessage_Station(stationNameStr, LogType.Error, $"PLC1_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC1_{stationNameStr}_采集运行数据与报警数据出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalAlarm);
            }
        }

        #endregion 轮询PLC

        #region 下发订单信息

        ///// <summary>
        ///// 壳体上料(下发工单)的交互逻辑
        ///// </summary>
        ///// <param name="no"></param>
        ///// <exception cref="NotImplementedException"></exception>
        //private void ReadStation_DownOrderInfo(int plcNo)
        //{
        //    // [S1] Tray盘上料装备（板测）
        //    // [S2] FCT（板测）
        //    // [S3] 值板机
        //    // [S4] 取放桁架
        //    // [S5] Tray盘下料装备
        //    /// 上位机心跳
        //    /// 获取设备报警数据与状态信息
        //    string stationNameStr = "[S0]壳体上料";

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs1)
        //            {
        //                UpdatePLCMonitor(plcNo, 0);
        //                continue;
        //            }

        //            if (Funs[plcNo].isConnected)  // 检查PLC是否已连接上
        //            {
        //                #region 壳体上料(下发工单)
        //                try
        //                {
        //                    Funs[plcNo].Read_Int_Tag("500", 1, out short[] iiMes0);
        //                    Funs[plcNo].Read_Int_Tag("501", 1, out short[] iiPlc0);
        //                    bool mES_FLAG_1 = iiMes0[0] == 1 ? true : false;  // MES_FLAG_1
        //                    bool pLC_Flag_1 = iiPlc0[0] == 1 ? true : false;  // PLC_FLAG_1

        //                    // 重置数据和信号
        //                    if (mES_FLAG_1 && pLC_Flag_1)  // 1 1
        //                    {
        //                        // 清空写给PLC的数据

        //                        int[] i497 = new int[1] { 0 };
        //                        Funs[plcNo].Write_DInt_Tag("497", 1, i497);  // SN号（数字部分）重置信号
        //                        // MES_Flag重置为0
        //                        int[] i500 = new int[1] { 0 };
        //                        Funs[plcNo].Write_DInt_Tag("500", 1, i500);  // MES_FLAG_1
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}下发订单信息运行出错！错误信息：" + ex.Message.ToString() + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 壳体上料(下发工单)

        //                UpdatePLCMonitor(plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");
        //
        //                Funs[plcNo].Connect();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
        //
        //            Funs[plcNo].ReConnect();
        //       }
        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        ///// <summary>
        ///// 下发订单信息到PLC
        ///// </summary>
        ///// <param name="no">PLC编号</param>
        //private void DownLoadProductInfo(int plcNo, string stationNameStr = "[S0]壳体上料")
        //{
        //    try
        //    {
        //        if (!string.IsNullOrEmpty(GlobalContext.Mtltmrk))
        //        {
        //            Funs[plcNo].Write_String_Tag("568", 1, GlobalContext.Mtltmrk);        // 产品型号(mtltmrk)
        //            WritePLCLog(LogType.Debug, GlobalContext.Mtltmrk);
        //        }

        //        Funs[plcNo].Write_DInt_Tag("500", 1, new Int32[1] { 1 });  // MES_FLAG_1
        //    }
        //    catch (Exception ex)
        //    {
        //        string str = ex.StackTrace;
        //        AddMessage_Station(stationNameStr, LogType.Error, "下发订单信息到PLC失败！" + ex.Message.ToString() + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //    }
        //}

        /// <summary>
        /// 下发清料信号
        /// </summary>
        /// <param name="no">PLC编号</param>
        public bool ClearProducts(int plcNo, string stationNameStr = "[S0]壳体上料")
        {
            try
            {
                //Funs[plcNo].ReadHoldingRegisters<int>(496);  // 
                AddMessage_Station(stationNameStr, LogType.Info, "下发了清料信号！");
                return true;
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    "下发清料信号失败！" + ex.Message.ToString() + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));
                return false;
            }
        }

        #endregion 下发订单信息

        #region Xiaomi 贲流

        #region 公共方法

        private static bool ProgressState = false;
        private static readonly object lockObj = new object(); // 锁对象
        private static bool isCollectingFlagLeft;
        private static bool isCollectingFlagRight;
        private bool OpenDailogFalg = true; //是否开启扫码弹窗标识
        public static bool isNoStop = false; //是否停止循环

        public void ConnectToIOT()
        {
            XiaomiMqttLoginFunAndParam param = new XiaomiMqttLoginFunAndParam();
            // fds
            param.parameter.fds.address = GlobalContext.address;
            param.parameter.fds.appId = GlobalContext.appId;
            param.parameter.fds.appKey = GlobalContext.appKey;
            // mes
            param.parameter.mes.address = GlobalContext.ServerIp;
            param.parameter.mes.appId = GlobalContext.MESAppId;
            param.parameter.mes.appKey = GlobalContext.MESAppKey;
            // mqtt
            param.parameter.mqtt.address = GlobalContext.MQTTServerHost;
            param.parameter.mqtt.port = GlobalContext.MQTTServerPort;
            param.parameter.mqtt.username = GlobalContext.MQTTAppId;
            param.parameter.mqtt.password = GlobalContext.MQTTAppPwd;
            // 设备配置
            param.parameter.equipment.factoryCode = GlobalContext.Factory_Code;
            if (GlobalContext.IsUsePLC1)
            {
                param.parameter.equipment.deviceCode = GlobalContext.S1_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.S1_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.S1_work_station; //工站
            }

            if (GlobalContext.IsUsePLC2)
            {
                param.parameter.equipment.deviceCode = GlobalContext.S2_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.S2_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.S2_work_station; //工站
            }

            if (GlobalContext.IsUsePLC3)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s3_1_device_code; // 装备编码
                //param.parameter.equipment.stationCode = GlobalContext.s3_1_station;     // ⼯位Id
            }

            if (GlobalContext.IsUsePLC4)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s4_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.s4_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.s4_work_station; //工站
            }

            if (GlobalContext.IsUsePLC5)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s5_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.s5_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.s5_work_station; //工站
            }

            if (GlobalContext.IsUsePLC6)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s6_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.s6_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.s6_work_station; //工站
            }

            if (GlobalContext.IsUsePLC7)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s7_1_device_code; // 装备编码
                //param.parameter.equipment.stationCode = GlobalContext.s7_1_station;     // ⼯位Id
                xiaomiParm.stationCode = GlobalContext.s7_1_station;
            }

            if (GlobalContext.IsUsePLC8)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s8_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.s8_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.s8_work_station; //工站
            }

            if (GlobalContext.IsUsePLC9)
            {
                param.parameter.equipment.deviceCode = GlobalContext.s9_device_code; // 装备编码
                param.parameter.equipment.stationCode = GlobalContext.s9_station; // ⼯位Id
                xiaomiParm.workstation = GlobalContext.s9_work_station; //工站
            }

            param.parameter.equipment.project = GlobalContext.Project_Code;
            param.parameter.equipment.productMode = "debug";

            param.parameter.other.logLevel = 0;
            param.parameter.other.LogPath = GlobalContext.MqttLogDir;

            XiaomiMqttClient_Extend.ParameterConfig(param);
        }

        /// <summary>
        /// float[]转为string
        /// </summary>
        public string FloatArrayToString(float[] nScrewResults)
        {
            // 使用 "R" 格式说明符来保证浮点数的往返精度，不添加 'f' 后缀
            return string.Join(",", Array.ConvertAll(nScrewResults, element => element.ToString("R")));
        }

        /// <summary>
        /// short[]转为string
        /// </summary>
        public string ShortArrayToString(short[] nScrewResults)
        {
            // 使用 string.Join 来连接数组元素，并使用逗号作为分隔符
            return string.Join(",", nScrewResults);
        }

        /// <summary>
        /// 写入PLC重复三次
        /// </summary>
        public (int, string) WriteResultToPlc<T>(int plcNo, string stationNameStr, string strTagName, int nCount,
            T inObj)
        {
            int i = 0;
            int nRet = 0;
            string strRet = "";
            try
            {
                while (i < 3) // 最多上传三次
                {
                    (nRet, strRet) = FunsEip[plcNo].Write_SingleTag<T>(strTagName, nCount, inObj);
                    if (nRet == 0) //成功
                    {
                        break;
                    }
                    else
                    {
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_{stationNameStr} 进站结果写入PLC出错！错误信息：" + strRet);
                        i++;
                    }
                }

                return (nRet, strRet);
            }
            catch (Exception ex)
            {
                return (1, ex.Message);
            }
        }

        public (int, string) SaveScrewDataToTxt(string direction, string ProductBarcode, float[] fScrewTimes,
            short[] nScrewOrders, short[] nScrewResults)
        {
            try
            {
                // 获取当前日期
                string dateFolder = DateTime.Now.ToString("yyyyMMdd");

                // 构建保存路径
                string basePath = AppDomain.CurrentDomain.BaseDirectory; // 获取执行文件的目录
                string savePath = Path.Combine(basePath, "screw", dateFolder, ProductBarcode, direction, "螺丝Mes数据");

                // 确保目录存在
                Directory.CreateDirectory(savePath);

                // 文件名
                string fileName = $"{ProductBarcode}_{DateTime.Now.ToString("HHmmss")}.txt";
                string filePath = Path.Combine(savePath, fileName);
                // 确保不会超出数组长度，只取前14个或数组的实际长度
                int count = Math.Min(14, fScrewTimes.Length);

                using (StreamWriter sw = new StreamWriter(filePath))
                {
                    for (int i = 0; i < count; i++)
                    {
                        sw.WriteLine($"{ProductBarcode}{"_"}{i + 1}");
                        sw.WriteLine($"锁附时间:{fScrewTimes[i]}");
                        sw.WriteLine($"锁附顺序:{nScrewOrders[i]}");
                        sw.WriteLine($"锁附结果:{nScrewResults[i]}");
                        sw.WriteLine(); // 空行分隔不同螺丝的信息
                    }
                }

                return (0, "");
            }
            catch (Exception ex)
            {
                return (1, ex.Message);
            }
        }


        public Dictionary<string, string> GetLastLineCompensation(string path, string direction, string sn)
        {
            // 创建字典存储补偿点及其对应的值
            Dictionary<string, string> compensationDict = new Dictionary<string, string>();

            try
            {
                //string path = GlobalContext.MESLaserRPath;
                // 获取当前日期并格式化为 "yyyy-MM-dd" 格式
                string currentDate = DateTime.Now.ToString("yyyy-MM-dd");
                string filename = $"Laser-{currentDate}-W0.txt";
                // 拼接完整路径
                string fullPath = Path.Combine(path, filename);
                string lastNonEmptyLine = "";

                // 判断文件是否存在
                if (File.Exists(fullPath))
                {
                    //读取文件内容
                    string[] lines = File.ReadAllLines(fullPath);

                    // 获取最后一行数据（忽略标题行）
                    if (lines.Length > 1)
                    {
                        string lastLine = "";
                        for (int i = lines.Length - 1; i > 0; i--)
                        {
                            if (!string.IsNullOrEmpty(lines[i]))
                            {
                                lastLine = lines[i];
                                break;
                            }
                        }

                        // 将最后一行按逗号分隔
                        string[] values = lastLine.Split(',');
                        values[1] = sn;

                        string key = "三点激光_" + direction; // 构造键名
                        string value = string.Join(",", values); // 获取值并去除多余空格
                        compensationDict[key] = value;

                        //// 提取“1点补偿”到“6点补偿”的值
                        //for (int i = 2; i <= 7 && i < values.Length; i++) // 从索引2开始，最多提取6个值
                        //{
                        //    string key = $"{i - 1}点补偿"; // 构造键名
                        //    string value = values[i].Trim(); // 获取值并去除多余空格
                        //    compensationDict[key] = value;
                        //}
                    }
                }
                else
                {
                    Console.WriteLine($"文件不存在: {fullPath}");
                }
            }
            catch (Exception ex)
            {
                // 捕获异常并输出错误信息
                Console.WriteLine($"发生错误: {ex.Message}");
            }

            return compensationDict;
        }

        public int PCBStationOutData(BarcodeSet_t Barcode, IoT_DataSet_t iotData)
        {
            int res = 0;
            string jsonstr1 = "";
            try
            {
                XmMES_StationOutRequest_Body outRequest_Body = new XmMES_StationOutRequest_Body();
                outRequest_Body.machineId = GlobalContext.S5_MachineId; // 装备id（可配置） 
                outRequest_Body.stationId = GlobalContext.s5_station; // ⼯位ID（可配置）  
                outRequest_Body.clientMac = GlobalContext.MacStr; // 客⼾端本机MAC地址，格式：XX-XX-XX-XX-XX-XX
                outRequest_Body.clientTime =
                    DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); // 客⼾端请求时间,格式yyyy-MM-dd HH:mm:ss.fff
                outRequest_Body.unitSn = Barcode.strPCBBarcode; // 产品SN
                int a1Result = (int)iotData.testStatus;
                //bool pass = a1Result == 1;
                //outRequest_Body.state = pass ? "PASS" : "FAIL"; ;      // 出站条件 PASS或FAIL
                outRequest_Body.state = "PASS";
                outRequest_Body.userId = GlobalContext.MESUserId; // ⽤⼾ID
                outRequest_Body.factoryId = GlobalContext.Factory_Code; // ⼯⼚id
                XmStationOut_KeyMaterial keyMaterial = new XmStationOut_KeyMaterial();
                keyMaterial.bindSort = 1;
                keyMaterial.materialSn = Barcode.strProductBarcode;
                outRequest_Body.unitData.keyMaterial.Add(keyMaterial); // 产品码


                jsonstr1 = JsonConvert.SerializeObject(outRequest_Body);

                XmMES_StationOutResponse response = new XmMES_StationOutResponse();

                response = XiaomiMESHttp_StationOutbound.StationOut(outRequest_Body);

                if (response != null && response.header.code == "200")
                {
                    res = 1;
                    AddMessage(LogType.Info,
                        "上传PCB出站数据到MES服务器---成功！请求信息：" + jsonstr1 + ",返回信息：" +
                        JsonConvert.SerializeObject(response.body));
                }
                else
                {
                    res = 0;
                    AddMessage(LogType.Error,
                        "上传PCB出站数据到MES服务器---失败！错误信息：" + response.header.desc + ",请求信息：" + jsonstr1 + ",返回信息：" +
                        JsonConvert.SerializeObject(response.body));
                }
            }
            catch (Exception e)
            {
                res = 0;
                AddMessage(LogType.Info, "上传PCB出站数据到MES服务器---失败！请求信息：" + jsonstr1 + ",返回信息：" + e.Message);
            }


            return res;
        }

        public int PCBStationInData(BarcodeSet_t Barcode, IoT_DataSet_t iotData)
        {
            int res = 0;
            string json_Body = "";
            try
            {
                XmMES_StationInRequest_Body inRequest_Body = new XmMES_StationInRequest_Body();
                inRequest_Body.machineId = GlobalContext.S5_MachineId; // 装备ID（可配置）
                inRequest_Body.stationId = GlobalContext.s5_station; // ⼯位ID（可配置）
                inRequest_Body.clientMac = GlobalContext.MacStr; // 客⼾端本机MAC地址，格式：XX-XX-XX-XX-XX-XX
                inRequest_Body.clientTime =
                    DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // 客⼾端请求时间,格式yyyy-MM-dd HH:mm:ss.fff
                inRequest_Body.unitSn = Barcode.strPCBBarcode; // 产品SN
                inRequest_Body.userId = GlobalContext.MESUserId; // 用户ID；
                inRequest_Body.factoryId = GlobalContext.Factory_Code; // 工厂ID；

                json_Body = JsonConvert.SerializeObject(inRequest_Body);
                var response = XiaomiMESHttp_StationInbound.StationIn(inRequest_Body);

                string resultJson = JsonConvert.SerializeObject(response);

                if (response != null && response.header.code == "200")
                {
                    res = 1;
                    AddMessage(LogType.Info,
                        "上传PCB进站数据到MES服务器---成功！请求信息：" + json_Body + ",返回信息：" +
                        JsonConvert.SerializeObject(response.body));
                }
                else
                {
                    res = 0;
                    AddMessage(LogType.Error,
                        "上传PCB进站数据到MES服务器---失败！错误信息：" + response.header.desc + ",请求信息：" + json_Body + ",返回信息：" +
                        JsonConvert.SerializeObject(response.body));
                }
            }
            catch (Exception e)
            {
                res = 0;
                AddMessage(LogType.Info, "上传PCB进站数据到MES服务器---失败！请求信息：" + json_Body + ",返回信息：" + e.Message);
            }

            return res;
        }

        /// <summary>
        /// 调用进站接口并保存进站数据
        /// </summary>
        /// <param name="stationNameStr">工站信息</param>
        /// <param name="workorder_code">工单号</param>
        /// <param name="mtltmrk">型号（物料号）</param>
        /// <param name="sn">产品SN</param>
        /// <param name="items">进站数据</param>
        /// <returns>1成功；5MES报警；6上位机报警</returns>
        public int SaveStationInData(string stationNameStr, string workorder_code, string mtltmrk, string sn,
            List<TestItem> items, string MachineId, string StationId, bool pass, string slot)
        {
            int result = 0;

            XmMES_StationInRequest_Body inRequest_Body = new XmMES_StationInRequest_Body();
            inRequest_Body.machineId = MachineId; // 装备ID（可配置）
            inRequest_Body.stationId = StationId; // ⼯位ID（可配置）
            inRequest_Body.clientMac = GlobalContext.MacStr; // 客⼾端本机MAC地址，格式：XX-XX-XX-XX-XX-XX
            inRequest_Body.clientTime =
                DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // 客⼾端请求时间,格式yyyy-MM-dd HH:mm:ss.fff
            inRequest_Body.unitSn = sn; // 产品SN
            inRequest_Body.uuidInspection = uuid;
            inRequest_Body.state = pass ? "PASS" : "FAIL";
            inRequest_Body.userId = GlobalContext.MESUserId; // 用户ID；
            inRequest_Body.factoryId = GlobalContext.Factory_Code; // 工厂ID；

            string json_Body = JsonConvert.SerializeObject(inRequest_Body);

            StationIn stationIn = new StationIn()
            {
                Workorder_code = workorder_code, // 车间订单号
                Mtltmrk = mtltmrk, // 产品型号（物料号）
                Sn = sn, // SN
                StationIn_body = json_Body, // 进站接口Json数据 - Body
                Parameter_values = items, // 进站数据
                Write_user = inRequest_Body.userId, // 员工Id
                Test_time = inRequest_Body.clientTime // 进站时间
            };
            // 本地数据
            string sql = stationIn.ToStringInsert(0);
            string ret = SQLHelper_New.ExecuteNonQuery(sql, null);
            result = ret == "成功" ? 1 : 6;

            #region MES

            if (GlobalContext.IsSendStationIn)
            {
                try
                {
                    XmMES_StationInResponse response = new XmMES_StationInResponse();
                    string resultJson = "";
                    string mesRet = string.Empty;
                    int i = 0;
                    while (i < 2) // 1009会多次尝试上传
                    {
                        response = XiaomiMESHttp_StationInbound.StationIn(inRequest_Body);

                        resultJson = JsonConvert.SerializeObject(response);

                        if (response != null && response.header.code == "200")
                            break;
                        else if (!mesRet.Contains("1009")) // 1009是未知错误
                            i++;

                        i++;

                        mesRet = $"[{response?.header?.code}]{response?.header?.desc}";
                        // 记录失败原因
                        OnMessage(LogType.Error, $"上传出站数据到MES服务器---失败！正在重新上传！接口报错信息：{mesRet}，请求参数：{json_Body}");
                    }

                    if (response?.header?.code == "200")
                    {
                        string sql_Upd = stationIn.ToStringUpdateStatusByID(1);
                        string ret_Upd = SQLHelper_New.ExecuteNonQuery(sql_Upd, null);
                        result = ret_Upd == "成功" ? 1 : 6;
                        AddMessage(LogType.Info,
                            $"【进站数据 SN {stationIn.Sn}】上传MES服务器---成功,返回参数：{resultJson}，请求参数：{json_Body}");
                    }
                    else
                    {
                        result = 5;
                        AddMessage(LogType.Info,
                            $"【进站数据 SN {stationIn.Sn}】上传MES服务器---失败！接口报错信息： {mesRet}，请求参数：{json_Body}");
                    }

                    string sql_response =
                        stationIn.ToStringUpdateStationInReturn_body(JsonConvert.SerializeObject(response));
                    SQLHelper_New.ExecuteNonQuery(sql_response, null);
                }
                catch (Exception ex)
                {
                    result = 6;
                    string str = ex.StackTrace;
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC上传进站数据MES报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                        str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                }
            }

            #endregion


            #region IOT

            //过站结果
            if (GlobalContext.IsMqttSendProcessData)
            {
                PassStationResultRequest request = new PassStationResultRequest();
                request.project_code = GlobalContext.Project_Code; // 项⽬编码
                request.factory_code = GlobalContext.Factory_Code; // ⼯⼚Id
                request.process_section_code = GlobalContext.Process_Section_Code; // ⼯段编码
                request.line_code = GlobalContext.LineCode; // 线体编码
                request.work_station = xiaomiParm.workstation; // ⼯站ID
                request.device_code = xiaomiParm.deviceCode; // 装备编码
                request.station = xiaomiParm.stationCode;
                request.process_time =
                    DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // 节拍发⽣时间（2022-06-01 14:27:57.283）
                request.slot = slot; // 槽位编码
                request.sn = sn; // 产品SN
                // request.enter_status = inpass ? "PASS" : "FAIL";  // 进站状态
                request.enter_status = pass ? "PASS" : "FAIL"; // 进站状态
                request.result = ""; // 出站条件 PASS或FAIL;              // 过站结果
                request.work_type = "OUT_STATION"; // 作业类型

                // 上传过站结果
                (int, string) iotResult = XiaomiMqttClient_Extend.Write_PassStationResult(request);
                if (iotResult.Item1 != 0)
                {
                    OnMessage(LogType.Info,
                        $"【IOT过站结果】上传失败！错误原因：{iotResult.Item2}，过站结果；产品码[{sn}]  进站结果[{request.enter_status}]  出站结果[{request.result}]");
                }
            }

            #endregion

            return result;
        }

        /// <summary>
        /// 选择如何记录出站数据
        /// </summary>
        /// <param name="items">出站数据</param>
        /// <param name="equipmentCode">设备编号</param>
        /// <param name="processItem">测试项目</param>
        /// <param name="workorder_code">车间订单号</param>
        /// <param name="batch_num">批次号</param>
        /// <param name="mtltmrk">型号</param>
        /// <param name="proDate">日期</param>
        /// <param name="supplierCode">供应商代码</param>
        /// <param name="sn_Number">产品序列号的 数字序列部分</param>
        /// <returns>上传成功时返回1；失败返回0</returns>
        private int SwitctProcessData(string stationNameStr, List<TestItem> items, string equipmentCode,
            string processItem,
            string workorder_code, string batch_num, string mtltmrk, string proDate,
            string supplierCode, string sn, bool pass, string vehicleSn, string vehicleSlot, string MachineId,
            string StationId, string PartBarcode, string jsonParm, string direction = "")
        {
            return SaveProcessDataByDB(stationNameStr, items, equipmentCode, processItem, workorder_code, batch_num,
                mtltmrk,
                proDate, supplierCode, sn, pass, vehicleSn, vehicleSlot, MachineId, StationId, PartBarcode, jsonParm,
                direction);
        }

        /// <summary>
        /// 添加出站数据（提交到MES+本地保存到数据库）
        /// </summary>
        /// <param name="items">出站数据</param>
        /// <param name="equipmentCode">设备编号</param>
        /// <param name="processItem">测试项目</param>
        /// <param name="workorder_code">车间订单号</param>
        /// <param name="batch_num">批次号</param>
        /// <param name="mtltmrk">型号</param>
        /// <param name="proDate">日期</param>
        /// <param name="supplierCode">供应商代码</param>
        /// <param name="sn_Number">产品序列号的 数字序列部分</param>
        /// <returns>上传成功时返回1；失败返回0</returns>
        public int SaveProcessDataByDB(string stationNameStr, List<TestItem> items, string equipmentCode,
            string processItem, string workorder_code, string batch_num, string mtltmrk,
            string proDate, string supplierCode, string sn, bool pass, string vehicleSn, string vehicleSlot,
            string machineId, string stationId, string partBarcode, string jsonParm, string direction = "")
        {
            int upload = 0;
            int result = 0;
            ProcessData processData = new ProcessData()
            {
                Equipment_code = equipmentCode,
                Workorder_code = workorder_code,
                Batch_number = batch_num,
                Sn = sn, // SN
                Testitem = processItem,
                Parameter_values = items,
                Write_user = GlobalContext.CurrentUser,
                Test_time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
            };
            // 本地数据
            string sql = processData.ToStringInsert(upload);
            string ret = SQLHelper_New.ExecuteNonQuery(sql, null);
            //AddMessage_Station(stationNameStr, LogType.Info, string.Concat("[[", equipmentCode, "]", stationNameStr, "]保存本地出站数据---" + ret));

            #region MES

            if (GlobalContext.IsSendProcessData)
            {
                try
                {
                    string id = processData.ID.Copy();

                    XmMES_StationOutRequest_Body outRequest_Body = new XmMES_StationOutRequest_Body();
                    outRequest_Body.uuidInspection = uuid;
                    outRequest_Body.machineId = machineId; // 装备id（可配置） 
                    outRequest_Body.stationId = stationId; // ⼯位ID（可配置）  
                    outRequest_Body.clientMac = GlobalContext.MacStr; // 客⼾端本机MAC地址，格式：XX-XX-XX-XX-XX-XX
                    outRequest_Body.clientTime = processData.Test_time; // 客⼾端请求时间,格式yyyy-MM-dd HH:mm:ss.fff
                    outRequest_Body.unitSn = sn; // 产品SN
                    outRequest_Body.state = pass ? "PASS" : "FAIL"; // 出站条件 PASS或FAIL
                    outRequest_Body.userId = GlobalContext.MESUserId; // ⽤⼾ID
                    outRequest_Body.factoryId = GlobalContext.Factory_Code; // ⼯⼚id
                    outRequest_Body.unitData.vehicleData.vehicleSn = vehicleSn;
                    outRequest_Body.unitData.vehicleData.vehicleType = string.Empty;
                    outRequest_Body.unitData.vehicleData.slot = vehicleSlot;


                    if (!string.IsNullOrEmpty(partBarcode))
                    {
                        outRequest_Body.unitData.keyMaterial.Add(
                            new XmMES_StationOutRequest_Body.XmStationOut_KeyMaterial()
                            {
                                bindSort = 1,
                                materialSn = partBarcode
                            }); // 设备数据 - 部件码
                    }

                    //OP30站读txt数据
                    if (stationNameStr.Contains("CPAPHD"))
                    {
                        string path = "";
                        if (direction == "Left")
                            path = GlobalContext.MESLaserLPath;
                        else
                            path = GlobalContext.MESLaserRPath;
                        //字典存储数据
                        Dictionary<string, string> compensationDict = GetLastLineCompensation(path, direction, sn);
                        foreach (var kvp in compensationDict)
                        {
                            outRequest_Body.unitData.processData.Add(
                                new XmMES_StationOutRequest_Body.XmStationOut_ProcessData()
                                {
                                    dataName = kvp.Key.ToString(),
                                    dataValue = kvp.Value.ToString()
                                });
                        }
                    }

                    //过站明细
                    if (GlobalContext.IsSendProcessDetail)
                    {
                        if (jsonParm.Length > 0)
                        {
                            // 解析JSON字符串为字典
                            var dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonParm);
                            foreach (var kvp in dictionary)
                            {
                                outRequest_Body.unitData.processData.Add(
                                    new XmMES_StationOutRequest_Body.XmStationOut_ProcessData()
                                    {
                                        dataName = kvp.Key.ToString(),
                                        dataValue = string.IsNullOrEmpty(kvp.Value) ? "" : kvp.Value.ToString()
                                    });
                            }
                        }
                    }

                    if (GlobalContext.MESIsSendUpFile)
                    {
                        foreach (var item in fileUploadData.fileData)
                        {
                            if (!string.IsNullOrEmpty(item.FileName))
                            {
                                outRequest_Body.unitData.fileData.Add(
                                    new XmStationOut_FileData()
                                    {
                                        fileName = item.FileName,
                                        fileId = item.FileId,
                                        bucket = item.Bucket
                                    });
                            }
                        }
                    }

                    string jsonstr1 = JsonConvert.SerializeObject(outRequest_Body);

                    if (GlobalContext.IsSendProcessData)
                    {
                        XmMES_StationOutResponse response = new XmMES_StationOutResponse();
                        string mesRet = string.Empty;
                        int i = 0;
                        while (i < 2) // 1009会多次尝试上传
                        {
                            response = XiaomiMESHttp_StationOutbound.StationOut(outRequest_Body);
                            if (response != null && response.header.code == "200")
                            {
                                OnMessage(LogType.Info,
                                    $"【出站数据 SN {sn}】上传出站数据到MES服务器---成功！请求信息：" + jsonstr1 + "返回信息：" +
                                    JsonConvert.SerializeObject(response.body));
                                break;
                            }
                            else if (!mesRet.Contains("1009")) // 1009是未知错误
                                i++;

                            i++;

                            mesRet = $"[{response?.header?.code}]{response?.header?.desc}";
                            // 记录失败原因
                            OnMessage(LogType.Error,
                                $"【出站数据 SN {sn}】上传出站数据到MES服务器---失败！正在重新上传！接口报错信息：" + mesRet + "参数：" + jsonstr1);
                        }

                        if (response?.header?.code == "200")
                        {
                            string sql_Upd = ProcessData.ToStringUpdateStatusByID(1, id);
                            string ret_Upd = SQLHelper_New.ExecuteNonQuery(sql_Upd, null);
                            result = 1;
                            //AddMessage_Station(stationNameStr, LogType.Info, $"更新【出站数据 id {id}】上传状态---" + ret_Upd);
                            AddMessage(LogType.Info, $"【出站数据 SN {sn}】上传MES服务器---成功");
                        }
                        else
                        {
                            AddMessage(LogType.Info, $"【出站数据 SN {sn}】上传MES服务器---失败！接口报错信息：" + mesRet);
                        }

                        string sql_UpStationout = ProcessData.ToStringUpdateStationOut_body(
                            JsonConvert.SerializeObject(outRequest_Body),
                            JsonConvert.SerializeObject(response), id);
                        SQLHelper_New.ExecuteNonQuery(sql_UpStationout, null);
                    }
                }
                catch (Exception ex)
                {
                    string str = ex.StackTrace;
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC上传出站数据MES报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                        str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                }
            }

            #endregion


            #region IOT

            //过站明细
            if (GlobalContext.IsMqttSendProcessData)
            {
                test_item_num += 1;
                PassStationDetailRequest request = new PassStationDetailRequest();
                request.pass_station_id = uuid;
                request.sn = sn; // 产品SN
                request.slot = vehicleSlot; // 槽位编码
                request.test_item_num = test_item_num.ToString();
                request.function_name = "Machine_加⼯模块";
                request.status = "PASS";
                (int, string) iotResult = (0, "");
                if (jsonParm.Length > 0)
                {
                    // 解析JSON字符串为字典
                    var dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonParm);
                    foreach (var kvp in dictionary)
                    {
                        request.test_item = kvp.Key.ToString();
                        request.result_val = string.IsNullOrEmpty(kvp.Value) ? "" : kvp.Value.ToString();
                        request.description = request.test_item;
                        // 上传过站明细
                        iotResult = XiaomiMqttClient_Extend.Write_PassStationDetail(request);
                        if (iotResult.Item1 != 0)
                        {
                            OnMessage(LogType.Info,
                                $"【IOT过站明细】上传失败！错误原因：{iotResult.Item2}，过站明细；产品码[{sn}]  测试项目[{request.test_item}]  测试值[{request.result_val}]");
                        }
                    }
                }
            }

            //过站结果
            if (GlobalContext.IsMqttSendProcessData)
            {
                PassStationResultRequest request = new PassStationResultRequest();
                request.project_code = GlobalContext.Project_Code; // 项⽬编码
                request.factory_code = GlobalContext.Factory_Code; // ⼯⼚Id
                request.process_section_code = GlobalContext.Process_Section_Code; // ⼯段编码
                request.line_code = GlobalContext.LineCode; // 线体编码
                request.work_station = xiaomiParm.workstation; // ⼯站ID
                request.device_code = xiaomiParm.deviceCode; // 装备编码
                request.station = xiaomiParm.stationCode;
                request.process_time =
                    DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // 节拍发⽣时间（2022-06-01 14:27:57.283）
                request.slot = vehicleSlot; // 槽位编码
                request.sn = sn; // 产品SN
                // request.enter_status = inpass ? "PASS" : "FAIL";  // 进站状态
                request.enter_status = ""; // 进站状态
                request.result = pass ? "PASS" : "FAIL"; // 出站条件 PASS或FAIL;              // 过站结果
                request.work_type = "OUT_STATION"; // 作业类型

                // 上传过站结果
                (int, string) iotResult = XiaomiMqttClient_Extend.Write_PassStationResult(request);
                if (iotResult.Item1 != 0)
                {
                    OnMessage(LogType.Info,
                        $"【IOT过站结果】上传失败！错误原因：{iotResult.Item2}，过站结果；产品码[{sn}]  进站结果[{request.enter_status}]  出站结果[{request.result}]");
                }
            }

            #endregion

            return result;
        }

        //private void CollectAndProcessDataLeft(string sn, string direction, string ip, string port, int connectTimeOut, int sendDataTimeOut)
        //{
        //    Stopwatch stopwatch = new Stopwatch();
        //    stopwatch.Start();

        //    try
        //    {
        //        // 初始化 AtlasScrew 实例
        //        AtlasScrew atlasScrew1 = new AtlasScrew(ip, port, connectTimeOut, sendDataTimeOut);
        //        atlasScrew1.Initial();

        //        // 存储结果的列表
        //        List<(double Angle, double Torque, double StartTorque, double MaxTorque)> results = new List<(double, double, double, double)>();

        //        // 存储角度和扭力的字符串列表
        //        List<string> angleStrs = new List<string>();
        //        List<string> torqueStrs = new List<string>();

        //        // 上一次获取的数据
        //        (double JD_MEAN, double NL_MEAN) lastResult = (-1, -1);

        //        while (isExitAtlasLeft) // 检查是否收集数据
        //        {
        //            // 获取当前数据
        //            var currentResult = atlasScrew1.GetResults();

        //            // 判断是否为新数据
        //            if (currentResult.JD_MEAN != lastResult.JD_MEAN || currentResult.NL_MEAN != lastResult.NL_MEAN)
        //            {
        //                OnMessage(LogType.Info, $"检测到新数据: JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN}");

        //                // 更新角度和扭力的字符串列表
        //                angleStrs.Add(currentResult.JD_MEAN.ToString());
        //                torqueStrs.Add(currentResult.NL_MEAN.ToString());

        //                // 计算角度、扭力、起始扭力和最大扭力
        //                double[] angles = angleStrs.Select(a => double.Parse(a)).ToArray();
        //                double[] torques = torqueStrs.Select(a => double.Parse(a)).ToArray();

        //                double startTorque = torques.Length > 0 ? torques[0] : -1; // 起始扭力
        //                double maxTorque = torques.Length > 0 ? torques.Max() : -1; // 最大扭力

        //                // 将新数据添加到结果列表
        //                results.Add((angles.Last(), torques.Last(), startTorque, maxTorque));

        //                // 更新上一次获取的数据
        //                lastResult = currentResult;
        //            }

        //            // 等待一段时间后再次检查
        //            Thread.Sleep(20); // 轮询间隔时间

        //            // 如果触发了出站，则退出循环
        //            if (!isExitAtlasLeft)
        //            {
        //                break;
        //            }
        //        }

        //        // 生成文件名
        //        string fileName = $"{sn}_{direction}_{DateTime.Now:yyyyMMddHHmmss}.txt";

        //        // 写入数据到文件
        //        using (StreamWriter writer = new StreamWriter(fileName))
        //        {
        //            // 写入标题行
        //            writer.WriteLine("角度, 扭力, 起始扭力, 最大扭力");

        //            // 写入每一行数据
        //            foreach (var result in results)
        //            {
        //                writer.WriteLine($"{result.Angle}, {result.Torque}, {result.StartTorque}, {result.MaxTorque}");
        //            }
        //        }

        //        stopwatch.Stop();
        //        AddMessage(LogType.Info, $"数据采集完成并保存到文件 {fileName}; 总用时 {stopwatch.ElapsedMilliseconds}ms");
        //    }
        //    catch (Exception ex)
        //    {
        //        AddMessage(LogType.Error, $"数据采集过程中发生错误: {ex.Message}");
        //    }
        //    finally
        //    {
        //        // 重置标志变量
        //        isExitAtlasLeft = false;
        //    }
        //}


        //private void CollectAndProcessDataRight(string sn, string direction, string ip, string port, int connectTimeOut, int sendDataTimeOut)
        //{
        //    Stopwatch stopwatch = new Stopwatch();
        //    stopwatch.Start();

        //    try
        //    {
        //        // 初始化 AtlasScrew 实例
        //        AtlasScrew atlasScrew2 = new AtlasScrew(ip, port, connectTimeOut, sendDataTimeOut);
        //        atlasScrew2.Initial();

        //        // 存储结果的列表
        //        List<(double JD_MEAN, double NL_MEAN)> results = new List<(double JD_MEAN, double NL_MEAN)>();

        //        // 上一次获取的数据
        //        (double JD_MEAN, double NL_MEAN) lastResult = (-1, -1);

        //        while (isExitAtlasRight) // 检查是否收集数据
        //        {
        //            // 获取当前数据
        //            var currentResult = atlasScrew2.GetResults();

        //            // 判断是否为新数据
        //            if (currentResult.JD_MEAN != lastResult.JD_MEAN || currentResult.NL_MEAN != lastResult.NL_MEAN)
        //            {
        //                AddMessage(LogType.Info, $"检测到新数据: JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN}");

        //                // 将新数据写入PLC
        //                //WriteDataToPlc(plcNo, stationNameStr, tagMesCommName, currentResult.JD_MEAN, currentResult.NL_MEAN);

        //                // 将新数据添加到结果列表
        //                results.Add(currentResult);

        //                // 更新上一次获取的数据
        //                lastResult = currentResult;
        //            }

        //            // 等待一段时间后再次检查
        //            Thread.Sleep(20); // 轮询间隔时间

        //            // 如果触发了出站，则退出循环
        //            if (!isExitAtlasRight)
        //            {
        //                break;
        //            }
        //        }

        //        // 将所有数据写入文件
        //        //WriteDataToFile(sn, direction, results);

        //        stopwatch.Stop();
        //        OnMessage(LogType.Info, $"螺丝数据采集完成;总用时{stopwatch.ElapsedMilliseconds}ms");
        //    }
        //    catch (Exception ex)
        //    {
        //        OnMessage(LogType.Error, $"螺丝数据采集过程中发生错误: {ex.Message}");
        //    }
        //    finally
        //    {
        //        // 重置标志变量
        //        isExitAtlasRight = false;
        //    } 
        //}


        private void CollectAndProcessDataLeft(AtlasScrew atlasScrew, string sn, string direction)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            int nRet = 0;
            string strRet = "";

            try
            {
                int fileCounter = 1; // 文件计数器，用于生成文件名中的序号

                while (isCollectingFlagLeft)
                {
                    // 从缓存中获取所有未处理的数据
                    var cachedData = atlasScrew.GetCachedDataLeft();

                    foreach (var currentResult in cachedData)
                    {
                        if (currentResult.JD_MEAN == 0 || currentResult.NL_MEAN == 0)
                        {
                            continue; // 跳过无效数据
                        }

                        OnMessage(LogType.Info,
                            $"检测到新数据: JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN}");

                        // 写入PLC
                        OP70_ScrewDataSet_t resultToPlC = new OP70_ScrewDataSet_t
                        {
                            fTorque = float.Parse(currentResult.NL_MEAN.ToString()),
                            fCircles = float.Parse(currentResult.JD_MEAN.ToString())
                        };

                        (nRet, strRet) = WriteResultToPlc(7, "", $"g_OP70_MES.{direction}.screwDriver", 1, resultToPlC);
                        if (nRet != 0)
                        {
                            OnMessage(LogType.Info,
                                $"SN:{sn}, JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN} 写入PLC失败");
                        }
                        else
                        {
                            OnMessage(LogType.Info,
                                $"SN:{sn}, JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN} 写入PLC成功");
                        }

                        // 构建保存路径
                        string dateFolder = DateTime.Now.ToString("yyyyMMdd");
                        string basePath = AppDomain.CurrentDomain.BaseDirectory;
                        string savePath = Path.Combine(basePath, "screw", dateFolder, sn, direction, "曲线");

                        Directory.CreateDirectory(savePath); // 确保目录存在

                        // 构建文件名（以 SN + 序号命名）
                        string fileName = $"{sn}_{fileCounter}.txt";
                        string filePath = Path.Combine(savePath, fileName);

                        // 写入文件
                        using (StreamWriter writer = new StreamWriter(filePath))
                        {
                            writer.WriteLine("精度, 扭力");

                            // 遍历 Pearkdegree 和 PearkTorque 的所有值
                            for (int i = 0;
                                 i < currentResult.Pearkdegree.Length && i < currentResult.PearkTorque.Length;
                                 i++)
                            {
                                double precision = Math.Round(currentResult.Pearkdegree[i]); // 精度
                                double torque = Math.Round(currentResult.PearkTorque[i], 2); // 扭力

                                writer.WriteLine($"{precision}, {torque}");
                            }
                        }

                        OnMessage(LogType.Info, $"保存文件成功: {filePath}");

                        // 增加文件计数器
                        fileCounter++;
                    }

                    // 如果没有更多数据，则短暂休眠以节省资源
                    if (!cachedData.Any())
                    {
                        Thread.Sleep(10); // 根据需要调整休眠时间
                    }

                    // 如果触发了出站，则退出循环
                    if (!isCollectingFlagLeft)
                    {
                        break;
                    }
                }

                stopwatch.Stop();
                OnMessage(LogType.Info, $"数据采集完成; 总用时 {stopwatch.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                OnMessage(LogType.Error, $"数据采集过程中发生错误: {ex.Message}");
            }
            finally
            {
                isCollectingFlagLeft = false;
            }
        }

        private void CollectAndProcessDataRight(AtlasScrew atlasScrew, string sn, string direction)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            int nRet = 0;
            string strRet = "";

            try
            {
                int fileCounter = 1; // 文件计数器，用于生成文件名中的序号

                while (isCollectingFlagRight)
                {
                    // 从缓存中获取所有未处理的数据
                    var cachedData = atlasScrew.GetCachedDataLeft();

                    foreach (var currentResult in cachedData)
                    {
                        if (currentResult.JD_MEAN == 0 || currentResult.NL_MEAN == 0)
                        {
                            continue; // 跳过无效数据
                        }

                        OnMessage(LogType.Info,
                            $"检测到新数据: JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN}");

                        // 写入PLC
                        OP70_ScrewDataSet_t resultToPlC = new OP70_ScrewDataSet_t
                        {
                            fTorque = float.Parse(currentResult.NL_MEAN.ToString()),
                            fCircles = float.Parse(currentResult.JD_MEAN.ToString())
                        };

                        (nRet, strRet) = WriteResultToPlc(7, "", $"g_OP70_MES.{direction}.screwDriver", 1, resultToPlC);
                        if (nRet != 0)
                        {
                            OnMessage(LogType.Info,
                                $"SN:{sn}, JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN} 写入PLC失败");
                        }
                        else
                        {
                            OnMessage(LogType.Info,
                                $"SN:{sn}, JD_MEAN={currentResult.JD_MEAN}, NL_MEAN={currentResult.NL_MEAN} 写入PLC成功");
                        }

                        // 构建保存路径
                        string dateFolder = DateTime.Now.ToString("yyyyMMdd");
                        string basePath = AppDomain.CurrentDomain.BaseDirectory;
                        string savePath = Path.Combine(basePath, "screw", dateFolder, sn, direction, "曲线");

                        Directory.CreateDirectory(savePath); // 确保目录存在

                        // 构建文件名（以 SN + 序号命名）
                        string fileName = $"{sn}_{fileCounter}.txt";
                        string filePath = Path.Combine(savePath, fileName);

                        // 写入文件
                        using (StreamWriter writer = new StreamWriter(filePath))
                        {
                            writer.WriteLine("精度, 扭力");

                            // 遍历 Pearkdegree 和 PearkTorque 的所有值
                            for (int i = 0;
                                 i < currentResult.Pearkdegree.Length && i < currentResult.PearkTorque.Length;
                                 i++)
                            {
                                double precision = Math.Round(currentResult.Pearkdegree[i]); // 精度
                                double torque = Math.Round(currentResult.PearkTorque[i], 2); // 扭力

                                writer.WriteLine($"{precision}, {torque}");
                            }
                        }

                        OnMessage(LogType.Info, $"保存文件成功: {filePath}");

                        // 增加文件计数器
                        fileCounter++;
                    }

                    // 如果没有更多数据，则短暂休眠以节省资源
                    if (!cachedData.Any())
                    {
                        Thread.Sleep(10); // 根据需要调整休眠时间
                    }

                    // 如果触发了出站，则退出循环
                    if (!isCollectingFlagRight)
                    {
                        break;
                    }
                }

                stopwatch.Stop();
                OnMessage(LogType.Info, $"数据采集完成; 总用时 {stopwatch.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                OnMessage(LogType.Error, $"数据采集过程中发生错误: {ex.Message}");
            }
            finally
            {
                isCollectingFlagRight = false;
            }
        }

        public static (int, string) CompressFolder(string folderPath, string zipFilePath)
        {
            try
            {
                // 创建zip文件，将指定文件夹内的所有内容压缩到这个zip文件中
                System.IO.Compression.ZipFile.CreateFromDirectory(folderPath, zipFilePath);
                return (1, "文件夹已成功压缩！");
            }
            catch (Exception ex)
            {
                return (0, "文件压缩出错！" + ex.Message);
            }
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="BarcodeSet_t">条码集合</param>
        /// <param name="stationCode">工站编号</param>
        /// <param name="stationName">工站名称</param>
        /// <param name="path">文件路径</param>
        public async Task<(int, string)> SaveDBbyFileInfo(BarcodeSet_t BarcodeSet, string stationCode,
            string stationName, int pass, string path, string guid = "")
        {
            string sql, filename = "";
            int result = 0;
            var formData = new MultipartFormDataContent();
            string msg = "";
            string file_category = "IMAGE"; //IMAGE 、TEXT 、UNKNOWN 
            string file_type = "IMAGE";
            string project = GlobalContext.ProgramName;
            string run_mode = GlobalContext.run_mode;
            string product_mode = GlobalContext.product_mode;
            string pass_result = (pass == 1 ? "PASS" : "Fail");
            string device_code = xiaomiParm.deviceCode;
            string sn = BarcodeSet.strProductBarcode;
            string staion_id = xiaomiParm.stationCode;
            string bucket =
                $"{file_category}/{file_type}/{project}/{product_mode}/{run_mode}/{pass_result}/{device_code}/{sn}/{staion_id}";
            // 获取所有图片文件

            if (guid == "")
            {
                guid = Guid.NewGuid().ToString();
            }

            try
            {
                if (GlobalContext.MESIsSendUpFile)
                {
                    List<string> imageFiles = GetAllImageFiles(path);

                    string toPath = GlobalContext.MqttFileBackupLogDir;
                    filename =
                        $"{xiaomiParm.workstation}_{file_type}_{sn}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.zip";
                    //string directoryPath = Path.GetDirectoryName(path);
                    string strFilePath = toPath + "\\" + filename;

                    if (imageFiles.Count > 0)
                    {
                        var r = CompressFolder(path, strFilePath);
                        if (r.Item1 == 0)
                        {
                            return (0, r.Item2);
                        }
                        else
                        {
                            msg = r.Item2 + "\r\n";
                        }
                    }
                    else
                    {
                        return (0, "文件不存在!");
                    }

                    FileUpload_X5 fileUpload_X5 = new FileUpload_X5();
                    fileUpload_X5.bucket = bucket;
                    fileUpload_X5.name = filename;
                    fileUpload_X5.uuid = guid.ToString();
                    ///需要上传文件
                    FileInfo file = new FileInfo(strFilePath);
                    string fileMd5Hex = GetMD5Hex(file);
                    fileUpload_X5.md5 = fileMd5Hex;
                    fileUpload_X5.uploadCloud = true;
                    fileUpload_X5.informMqtt = true;

                    FileMqttPayload fileMqttPayload = new FileMqttPayload();
                    fileMqttPayload.factory = GlobalContext.Factory_Code;
                    fileMqttPayload.project_name = GlobalContext.Project_Code;
                    fileMqttPayload.product_mode = GlobalContext.product_mode;
                    fileMqttPayload.line_no = GlobalContext.LineCode;
                    fileMqttPayload.work_station_no = xiaomiParm.workstation;
                    fileMqttPayload.equipment_no = xiaomiParm.deviceCode;
                    fileMqttPayload.station_no = xiaomiParm.stationCode;
                    fileMqttPayload.file_id = guid;
                    fileMqttPayload.file_name = filename;
                    fileMqttPayload.sn = BarcodeSet.strProductBarcode;
                    //fileMqttPayload.opt_time = "";
                    //fileMqttPayload.file_type = "";
                    //fileMqttPayload.file_category = "";
                    //fileMqttPayload.tag = "";
                    fileMqttPayload.reference_info.pass_station_id = uuid;

                    var fileresult = await
                        XiaomiMESHttp_UpLoadFile.FileUoladToMes(strFilePath, fileUpload_X5, fileMqttPayload);
                    if (fileresult.Item1 != 1)
                    {
                        return (0, msg + fileresult.Item2 + "\r\n");
                    }
                    else
                    {
                        msg = msg + fileresult.Item2 + "\r\n";
                    }


                    foreach (var imageFile in imageFiles)
                    {
                        if (File.Exists(imageFile))
                        {
                            //删除文件
                            (bool, string) newResult = DeleteFile(imageFile);
                            if (!newResult.Item1)
                            {
                                return (0, Path.GetFileName(imageFile) + newResult.Item2);
                            }
                        }
                    }
                }

                return (1, msg);
            }
            catch (Exception e)
            {
                return (0,
                    filename + $"文件上传错误！载具码：{BarcodeSet.strCarrierBarcode}产品码{BarcodeSet.strProductBarcode},错误原因：" +
                    e.Message);
            }
        }

        /// <summary>
        /// 获取路径下的所有图片
        /// </summary>
        /// <param name="directoryPath"></param>
        /// <returns></returns>
        public List<string> GetAllImageFiles(string directoryPath)
        {
            var imageExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
                { ".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff" };
            var imageFiles = new List<string>();

            try
            {
                // 遍历目录及子目录中的所有文件
                foreach (string file in Directory.EnumerateFiles(directoryPath, "*.*", SearchOption.AllDirectories))
                {
                    // 获取文件扩展名并检查是否为图片格式
                    string extension = Path.GetExtension(file);
                    if (imageExtensions.Contains(extension))
                    {
                        imageFiles.Add(file);
                    }
                }
            }
            catch (Exception ex)
            {
                OnMessage(LogType.Error, $"图片查询发生错误: {ex.Message}");
            }

            return imageFiles;
        }

        /// <summary>
        /// 实例化报警字典
        /// </summary>
        private (bool, string) InitalDicAlarm()
        {
            #region 加载报警表

            string excelPath = "";
            switch (GlobalContext.IsUsePLCNow)
            {
                case 1:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_10_壳体清洁上料.xlsx";
                    break;
                case 2:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_20_上盖板上料装备.xlsx";
                    break;
                case 3:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_30_点散热胶装备.xlsx";
                    break;
                case 4:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_40_胶线检测.xlsx";
                    break;
                case 5:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_50_ADD板上料组装装备.xlsx";
                    break;
                case 6:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_60_组上盖板.xlsx";
                    break;
                case 7:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_70_上盖板锁螺丝.xlsx";
                    break;
                case 8:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_80_NG下料.xlsx";
                    break;
                case 9:
                    excelPath = AppDomain.CurrentDomain.BaseDirectory + "DBFile\\小米-IoT报警字典_90_半成品下料.xlsx";
                    break;
                default:
                    return (false, $"不支持当前PLC[{GlobalContext.IsUsePLCNow}]的报警点位表!请在设置页切换到正确的plc后重启该软件！");
            }

            if (!File.Exists(excelPath))
                return (false, $"未找到当前PLC[{GlobalContext.IsUsePLCNow}]的报警点位表!请检查文件路径:'{excelPath}'。");

            DataTable DtModel = NPOIHelper.ReadExcel(excelPath);
            if (DtModel == null || DtModel.Rows.Count < 1)
                return (false, $"报警点位表未包含任何报警数据！请检查‘{excelPath}’文件！");

            // 检查列名
            List<string> isNeedParms = new List<string>()
            {
                "设备分类名称", "设备分类编码", "分类层级1", "分类层级2", "分类层级3", "分类层级4", "事件名称", "事件ID", "描述", "标签", "PLC地址", "工位"
            }; // 必须要有的列

            // 指定列名 + 检查列是否完整
            DataRow dtRowName = DtModel.Rows[0];
            int count = DtModel.Columns.Count;
            for (int i = 0; i < count; i++)
            {
                string columeName = dtRowName[i]?.ToString();
                if (!string.IsNullOrEmpty(columeName))
                    DtModel.Columns[i].ColumnName = columeName;

                if ((!string.IsNullOrEmpty(columeName)) && isNeedParms.Count > 0 && isNeedParms.Contains(columeName))
                    isNeedParms.Remove(columeName);
            }

            DtModel.Rows.RemoveAt(0);

            if (isNeedParms.Count > 0)
            {
                string msg1 = string.Join(",", isNeedParms);
                return (false, $"报警点位表未包含列:{msg1}！请检查‘{excelPath}’文件！");
            }

            #endregion 加载报警表

            List<Alarm> keyValues1 = new List<Alarm>();
            for (int i = 0; i < DtModel.Rows.Count; i++)
            {
                Alarm alarm = new Alarm();
                alarm.plcName = DtModel.Rows[i]["设备分类名称"]?.ToString(); // 设备名；
                string type1Str = DtModel.Rows[i]["分类层级1"]?.ToString(); // 分类层级1；
                alarm.type1CH = type1Str; // 分类层级1 中文
                alarm.type1 = type1Str; // 分类层级1
                if (!string.IsNullOrEmpty(type1Str) && type1Str.Contains("\n"))
                {
                    string[] type1Strs = type1Str.Split('\n');
                    if (type1Strs.Length >= 2)
                    {
                        alarm.type1CH = type1Strs[0].Trim(); // 分类层级1 中文
                        alarm.type1 = type1Strs[1].Trim(); // 分类层级1 
                        if (string.IsNullOrEmpty(alarm.type1))
                            alarm.type1 = alarm.type1CH;
                    }
                }

                string type2Str = DtModel.Rows[i]["分类层级2"]?.ToString(); // 分类层级2；电气控制 electric_control
                alarm.type2CH = type2Str; // 分类层级2 中文
                alarm.type2 = type2Str; // 分类层级2
                if (!string.IsNullOrEmpty(type2Str) && type2Str.Contains("\n"))
                {
                    string[] type2Strs = type2Str.Split('\n');
                    if (type2Strs.Length >= 2)
                    {
                        alarm.type2CH = type2Strs[0].Trim(); // 分类层级2 中文
                        alarm.type2 = type2Strs[1].Trim(); // 分类层级2
                        if (string.IsNullOrEmpty(alarm.type2))
                            alarm.type2 = alarm.type2CH;
                    }
                }

                string type3Str = DtModel.Rows[i]["分类层级3"]?.ToString(); // 分类层级3；故障 Fault
                alarm.type3CH = type3Str; // 分类层级3 中文
                alarm.type3 = type3Str; // 分类层级3
                if (!string.IsNullOrEmpty(type3Str) && type3Str.Contains("\n"))
                {
                    string[] type3Strs = type3Str.Split('\n');
                    if (type3Strs.Length >= 2)
                    {
                        alarm.type3CH = type3Strs[0].Trim(); // 分类层级3 中文
                        alarm.type3 = type3Strs[1].Trim(); // 分类层级3
                        if (string.IsNullOrEmpty(alarm.type3))
                            alarm.type3 = alarm.type3CH;
                    }
                }

                string faultStr = DtModel.Rows[i]["分类层级4"]?.ToString(); // 故障部件；overall_module
                alarm.type4 = faultStr; // 分类层级4 中文
                alarm.type4CH = faultStr; // 分类层级4 
                if (!string.IsNullOrEmpty(faultStr) && faultStr.Contains("\n"))
                {
                    string[] faultStrs = faultStr.Split('\n');
                    if (faultStrs.Length >= 2)
                    {
                        alarm.type4CH = faultStrs[0].Trim(); // 故障部件；overall_module
                        alarm.type4 = faultStrs[1].Trim(); // 故障部件
                        if (string.IsNullOrEmpty(alarm.type4))
                            alarm.type4 = alarm.type4CH;
                    }
                }

                alarm.fault_code = DtModel.Rows[i]["事件ID"]?.ToString(); // 故障编码；A40001
                alarm.fault_name = DtModel.Rows[i]["事件名称"]?.ToString(); // 故障名称；AL[1000]_系统_HMI急停故障
                alarm.fault_desc = alarm.fault_name; // 故障描述；AL[1000]_系统_HMI急停故障
                string plcAdress = DtModel.Rows[i]["PLC地址"]?.ToString();
                alarm.PLC地址 = plcAdress;
                plcAdress = plcAdress.Replace("fault_codes[", "");
                plcAdress = plcAdress.Replace("]", "");
                alarm.group_index = Convert.ToInt32(plcAdress.Split(".")[0]);

                keyValues1.Add(alarm);
            }

            DicAlarms_Cur.Add(GlobalContext.IsUseStationName, keyValues1); // 这里使用线体代替工位
            return (true, "报警字典表初始化成功！");
        }

        private async void ReadPLCAlarmToIot(uint[] FaultData, uint[] FaultDataOld, string stationNameStr)
        {
            DateTime dtNow = DateTime.Now;
            try
            {
                List<DeviceAlarm_Cur> deviceAlarm_Curs = new List<DeviceAlarm_Cur>(); // 同步到报警页面用传输载体
                List<(int, int)> AlarmIndexList = new List<(int, int)>(); //收集所有报警信息的位置

                AlarmData alarmData = new AlarmData();

                bool isNeedUpdUI = false; // 是否需要更新历史报警UI
                bool isNoAlarm = false; //是否有报警
                string binaryString = "";
                bool isNoNewAlarm = false; //是否有新的报警

                if (FaultData.Length > 0)
                {
                    foreach (var item in FaultData)
                    {
                        isNoAlarm = item > 0 ? true : false;
                    }

                    if (!FaultData.SequenceEqual(FaultDataOld))
                    {
                        isNoNewAlarm = true;
                        isNeedUpdUI = true;
                    }

                    if (FaultData.Length > 0 && isNoAlarm && isNoNewAlarm)
                    {
                        //解析报警信息，分析当前报警在字典中的定位
                        for (int i = 0; i <= FaultData.Length - 1; i++)
                        {
                            var num = 0;
                            if (FaultData[i] > 0)
                            {
                                //转换二进制
                                binaryString = Convert.ToString(FaultData[i], 2);
                                for (int j = binaryString.Length - 1; j >= 0; j--)
                                {
                                    num++;
                                    char s = binaryString[j];
                                    if (binaryString[j] == '1')
                                    {
                                        //记录1的位置
                                        AlarmIndexList.Add((i, num - 1));
                                    }
                                }
                            }
                        }

                        // 同步“设备报警信息”到“设备报警临时字典DicAlarms_Cur”
                        var dicAlarms_Cur_PLC1 = DicAlarms_Cur[GlobalContext.IsUseStationName];
                        foreach ((int index, int row) in AlarmIndexList)
                        {
                            var tempDic = dicAlarms_Cur_PLC1.Where(x => x.group_index == index).ToList();
                            for (int i = 0; i < tempDic.Count - 1; i++) // 读取
                            {
                                //若报警字典第[group_index]个数据，第[i]行与AlarmIndexList中的定位匹配，则添加进对应行的报警数据
                                if (tempDic[i].group_index == index && i == row)
                                {
                                    dicAlarms_Cur_PLC1.Where(x => x.group_index == index).ToList()[row].报警数据 =
                                        new AlarmData()
                                        {
                                            GUID = Guid.NewGuid().ToString(),
                                            LineName = GlobalContext.IsUseStationName, // 工站
                                            PlcStation = tempDic[i].plcName, // 工站全称；[S1]
                                            Type1 = tempDic[i].type1, // 故障层级1
                                            Type2 = tempDic[i].type2, // 故障层级2
                                            Type3 = tempDic[i].type3, // 故障层级3
                                            Type4 = tempDic[i].type4, // 故障层级4
                                            AlarmType = tempDic[i].fault_code, // 报警类型
                                            AlarmDesc = tempDic[i].fault_name, // 报警内容
                                            StartTime = dtNow // 开始时间
                                        };
                                    // 传输到页面
                                    deviceAlarm_Curs.Add(new DeviceAlarm_Cur()
                                    {
                                        线体名称 = tempDic[i].plcName,
                                        报警类型 = tempDic[i].fault_code,
                                        报警内容 = tempDic[i].fault_name,
                                        开始时间 = dtNow
                                    });
                                    // 新增到数据库
                                    //var data1 = dicAlarms_Cur_PLC1.Where(x => x.group_index == index).ToList()[row].报警数据;
                                    //SaveAlarmDataByDB(stationNameStr, data1, false);
                                    //OnMessage(LogType.Info, $"更新{BodyAlarm}完毕！");
                                }
                            }
                        }

                        //筛选含报警数据的字典
                        var dicAlarms_Cur = dicAlarms_Cur_PLC1.Where(x => x.报警数据 != null).ToList();
                        if (dicAlarms_Cur.Count > 0)
                        {
                            foreach (var item in dicAlarms_Cur)
                            {
                                //上传
                                SaveAlarmDataByDB(GlobalContext.IsUseStationName, item.报警数据, false);
                            }
                        }

                        // 有新报警则更新
                        if (isNeedUpdUI)
                            // UI展示 - 展示到设备状态页
                            await Task.Run(() =>
                            {
                                try
                                {
                                    if (Form_Main.formDevAlarm != null && !Form_Main.formDevAlarm.IsDisposed)
                                    {
                                        Form_Main.formDevAlarm.UpdDeviceAlarm_Cur(deviceAlarm_Curs); // 报警UI 更新
                                        if (Form_Main.formDevAlarm.Visible)
                                            Form_Main.formDevAlarm.UpdDeviceAlarm_History_48H(); //  历史报警UI 更新
                                    }
                                }
                                catch
                                {
                                }
                            });
                        FaultDataOld = FaultData.ToArray();
                    }
                }

                //FaultLogRequest request = new FaultLogRequest();
                //request.station = mesStation;        // 工位
                //request.fault_name = xmFaultName;    // 故障名称(同数据字典中的事件名称)
                //request.fault_code = xmFaultCode2;   // 故障编码（A，B，C，D，E）
                //request.fault_cmpnt = xmFaultCmpnt;  // 故障部件
                //request.fault_desc = xmFaultDesc;    // 故障描述
                //request.fault_tm = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");  // 故障发生时间 2022-06-01 14:27:57.283
                //                                                                      // 上传
                //(int, string) iotResult = XiaomiMqttClient_Extend.Write_FaultLog(request, type1, type2, type3, request.fault_cmpnt, deciveCode);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"{stationNameStr}_获取报警数据出错！错误信息：" + ex.Message.ToString() + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }
        }

        public void operateToIot(string action, string stationNameStr)
        {
            OperateLogRequest request = new OperateLogRequest();
            request.software_version = "V" + Application.ProductVersion; // 软件版本号;如：V1.2.4
            request.operate_time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // 操作时间（2022-06-01 14:27:57.283）
            request.operate_action = action; // 操作动作(对应软件开启/关闭/重新加载项⽬;startup、shutdown、reload)
            //request.current_process = Process.GetCurrentProcess()?.Id.ToString();  // 当前进程；进程ID
            request.current_process = Application.ProductName;
            request.operate_desc = stationNameStr; // 操作描述；如：供应商软件开启/关闭/重新加载项⽬
            request.operate_result = "success"; // 操作结果
            request.operator_name = "default"; // 操作账号名；填当前操作⽤⼾，如⽆则填default
            // 上传
            (int, string) iotResult = XiaomiMqttClient_Extend.Write_OperateLog(request);
            if (iotResult.Item1 != 0)
            {
                AddMessage(LogType.Info, "【操作记录】上传失败！错误原因：" + iotResult.Item2 + "操作状态：" + stationNameStr);
            }
        }

        private void 通用节拍接口(int plcNo, string stationNameStr, string tagMesCommName, string CarrierBarcode,
            IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = iot_data.BeatAction.ToString(); // 节拍类型(plc写入)
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode); //产品SN
                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    OnMessage(LogType.Info, $"PLC{plcNo}_{stationNameStr} 节拍[{oEEType}]写入成功！");
                    return;
                }

                short _result = 0;
                (short, string) result = (0, "");
                // 上传开始节拍
                result = SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 1; //OK
                    iotData.fault_codes = iot_data.fault_codes;
                    (int, string) PLCresult = WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    if (PLCresult.Item1 != 0)
                    {
                        OnMessage(LogType.Info, $"PLC{plcNo}_{stationNameStr} 节拍[{deviceOEE}]写入成功！");
                    }

                }
                else
                {
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍[{deviceOEE}]接口出错！错误信息：" + resultStr);
                }
                //上传结束节拍
                switch (oEEType) {
                    case "1":
                        Enum.TryParse("2", out deviceOEE);
                        result = SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                        break;
                    case "3":
                        Enum.TryParse("4", out deviceOEE);
                        result = SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                        break;
                    case "5":
                        Enum.TryParse("6", out deviceOEE);
                        result = SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                        break;
                }

                if (result.Item1 == 1)
                {
                    OnMessage(LogType.Info, $"PLC{plcNo}_{stationNameStr} 节拍[{deviceOEE}]上传成功！");
                }
                else {
                    OnMessage(LogType.Info, $"PLC{plcNo}_{stationNameStr} 节拍[{deviceOEE}]接口出错！错误信息：" + result.Item2);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }
        }

        /// <summary>
        /// 去除常见特殊字符，如 \r, \n, \t 等
        /// </summary>
        /// <param name="format"></param>
        /// <returns></returns>
        private static string FormatStrbyPLC(string format)
        {
            string cleanedString = "";
            if (!string.IsNullOrEmpty(format))
            {
                cleanedString = Regex.Replace(format, @"[\r\n\t]", "");
            }

            return cleanedString;
        }

        #endregion

        #region S1

        /// <summary>
        /// [S1] 壳体清洁上料装备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S1(int plcNo)
        {
            string stationCode = "[OP10]";
            string stationName = "壳体清洁上料";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP10_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";
            string ProductBarcode = "";

            // 触发信号字典
            //s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
            s1PLCSignal_Old.Add("a1OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s1PLCData.Add("a1OEEType", 0); // 节拍类型(plc写入) 

            OP10_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP10_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //richTextBox1.AppendText("\n" + "读取成功");
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);

                            //设备状态
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;

                            // 载具SN
                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode.ToString();
                            // 物料码（物料码还未绑定载具SN时必填）
                            ProductBarcode = stPLC_MesData.BarcodeSet.strProductBarcode;
                            // 节拍
                            s1PLCData["a1OEEType"] = stPLC_MesData.iotData.BeatAction;
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S1进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S1出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0; //清除入站申请
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站


                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a1OEEType = Convert.ToInt32(s1PLCData["a1OEEType"]);
                                int a1OEETypeGOld = Convert.ToInt32(s1PLCSignal_Old["a1OEEType"]);
                                //若设备紧急复原后节拍重置
                                if (a1OEEType == 1)
                                {
                                    a1OEETypeGOld = 0;
                                }

                                if (a1OEEType != a1OEETypeGOld)
                                {
                                    //如果上位机告诉PLC NG，PLC节拍会直接从1跳到4
                                    if (a1OEETypeGOld <= 2 && a1OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a1OEETypeGOld == 1 && a1OEEType != 2) ||
                                            (a1OEETypeGOld == 3 && a1OEEType != 4) ||
                                            (a1OEETypeGOld == 5 && a1OEEType != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                1,
                                                iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a1OEEType}]，未上传节拍[{a1OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                                tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode, stPLC_MesData.iotData));
                                        }
                                    }
                                }
                            }

                            s1PLCSignal_Old["a1OEEType"] = s1PLCData["a1OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S1] 壳体清洁上料 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S1进站(int plcNo, string stationNameStr, OP10_MesData_t stPLC_MesData, string tagMesCommName,
            out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码），现在PLC只有OP10和OP50返回
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S1_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S1_StationId; // 工位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                if (string.IsNullOrEmpty(sn))
                {
                    ProgressState = false;
                    AddMessage(LogType.Error, $"{stationNameStr}_未能查到产品码");
                    Thread.Sleep(10000);
                    return;
                }

                //测试先用9码，正式直接用PLC得到的SN码,截取成9位码
                // sn = sn.Substring(sn.Length - 11, 4) + sn.Substring(sn.Length - 5, 5);
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");
                //绑定载具和产品
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertCarrierBind(CarrierBarcode, sn);
                if (message.result == false)
                {
                    AddMessage(LogType.Error, stationNameStr + "_载具码与产品码绑定失败,错误:" + message.text);
                }

                // 产品SN进站
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();

                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");

                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0;
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        /// <summary>
        /// [S1] 壳体清洁上料 - 出站接口
        /// </summary>
        private void S1出站(int plcNo, string stationNameStr, OP10_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号  现在没用上
                string batch_num = GlobalContext.BatchNumber; // 批次号  现在没用上
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号  现在没用上
                string sn = string.Empty;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S1_MachineId; // 装备id（可配置）  
                string StationId = GlobalContext.S1_StationId; // ⼯位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                //a1Result = 1;
                bool pass = a1Result == 1;

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    ProgressState = false;
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    Thread.Sleep(10000);
                    return;
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                #region 转换过站明细字符串

                //创建字典
                var dic = new Dictionary<string, string>();
                // 获取结构体类型
                FieldInfo[] fields = typeof(OP10_DataSet_t).GetFields();

                // 遍历变量名转换成字典描述
                foreach (FieldInfo field in fields)
                {
                    //获取枚举描述
                    string name = XiaomiMESEnumMethod.GetEnumDescriptionByName(field.Name,
                        typeof(XiaomiMESEnum_ProcessData.Enum_10_ProcessData));
                    //获取过站明细的值
                    object valueObj = field.GetValue(stPLC_MesData.mesData);
                    dic.Add(name, valueObj.ToString());
                }

                string paramJson = JsonConvert.SerializeObject(dic);

                #endregion

                //出站接口
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, "", paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertOp10Data(CarrierBarcode, sn, 1,
                    stPLC_MesData.mesData.nThrowCount, stPLC_MesData.mesData.fCleanAirPress,
                    stPLC_MesData.mesData.fCleanSpeed,
                    stPLC_MesData.mesData.fWindBladeHeight, stPLC_MesData.mesData.fCleanTime,
                    stPLC_MesData.mesData.nCleanCount,
                    stPLC_MesData.mesData.nRemainCount);
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                AddMessage(LogType.Info, stationNameStr + "_保存出站数据结束");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        #endregion

        #region S2

        /// <summary>
        /// [S2] 上盖板上料装备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S2(int plcNo)
        {
            string stationCode = "[OP20]";
            string stationName = "上盖板上料装备";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP20_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";

            // 触发信号字典
            //s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
            s2PLCSignal_Old.Add("a2OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s2PLCData.Add("a2OEEType", 0); // 节拍类型(plc写入) 

            OP20_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs2)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP20_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //richTextBox1.AppendText("\n" + "读取成功");
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);

                            //设备状态
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;

                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具SN
                            s2PLCData["a2OEEType"] = stPLC_MesData.iotData.BeatAction; // 节拍
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S2进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                            out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S2出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0; //清除入站申请
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站

                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a2OEEType = Convert.ToInt32(s2PLCData["a2OEEType"]);
                                int a2OEETypeGOld = Convert.ToInt32(s2PLCSignal_Old["a2OEEType"]);
                                //若设备紧急复原后节拍重置
                                if (a2OEEType == 1)
                                {
                                    a2OEETypeGOld = 0;
                                }

                                if (a2OEEType != a2OEETypeGOld)
                                {
                                    //如果上位机告诉PLC NG，PLC节拍会直接从1跳到4
                                    if (a2OEETypeGOld <= 2 && a2OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a2OEETypeGOld == 1 && a2OEEType != 2) ||
                                            (a2OEETypeGOld == 3 && a2OEEType != 4) ||
                                            (a2OEETypeGOld == 5 && a2OEEType != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a2OEEType}]，未上传节拍[{a2OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                                tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode, stPLC_MesData.iotData));
                                            //Task.Run(() =>
                                            //    S2节拍接口(plcNo, stationNameStr, tagBaseName,
                                            //        stPLC_MesData.iotData)); 
                                        }
                                    }
                                }
                            }

                            s2PLCSignal_Old["a2OEEType"] = s2PLCData["a2OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect();
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());

                    //Funs[plcNo].ReConnect();
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }

        /// <summary>
        /// [S2] 上盖板上料装备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S2进站(int plcNo, string stationNameStr, OP20_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）,现在PLC只有10和50返回
                //sn = sn.Substring(sn.Length - 11, 4) + sn.Substring(sn.Length - 5, 5);
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                string MachineId = GlobalContext.S2_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S2_StationId; // 工位ID（可配置）
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）
                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                //这个地方之后PLC可能会返回SN码，到时用返回的和数据库中的比较下对错，结果faalse怎么办现在不知道
                //if (sn != strProductBarcode)
                //{
                //    AddMessage(LogType.Info, $"进站产品码错误！与载具绑定的产品码不匹配，进站产品码:{sn};载具绑定产品码:{strProductBarcode}");
                //}
                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        /// <summary>
        /// [S2] 上盖板上料装备 - 出站接口
        /// </summary>
        private void S2出站(int plcNo, string stationNameStr, OP20_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string PartBarcode = (string)stPLC_MesData.BarcodeSet.strPartBarcode; //部件码
                string MachineId = GlobalContext.S2_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S2_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    ProgressState = false;
                    Thread.Sleep(10000);
                    return;
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");

                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "部件码",
                    Parameter_value = PartBarcode,
                    Parameter_unit = ""
                });

                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);

                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, PartBarcode, paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertOp20Data(CarrierBarcode, sn, stPLC_MesData.mesData.nThrowCount,
                    stPLC_MesData.mesData.nRemainCount);
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                if (!string.IsNullOrEmpty(PartBarcode))
                {
                    message = SQLHelper.InsertOp20Product(CarrierBarcode, sn, PartBarcode);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Error, message.text);
                    }
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        #endregion

        #region S3

        /// <summary>
        /// [S3] 点散热胶装备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S3(int plcNo)
        {
            string stationCode = "[OP30]";
            string stationName = "点散热胶装备";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP30_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode_Left = "";
            string CarrierBarcode_Right = "";

            s3PLCSignal_Old.Add("a3OEEType_left", 0); // 节拍类型(plc写入) 
            s3PLCSignal_Old.Add("a3OEEType_right", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s3PLCData.Add("a3OEEType_left", 0); // 节拍类型(plc写入) 
            s3PLCData.Add("a3OEEType_right", 0); // 节拍类型(plc写入) 
            s5PLCData.Add("OEETypeFlag_left", 0); // 节拍标识 0 不上传 ,1 上传
            s5PLCData.Add("OEETypeFlag_right", 0); // 节拍标识 0 不上传 ,1 上传

            OP30_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs2)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();
                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP30_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //测试数据
                            //stPLC_MesData.Left.mesCommFrmPLC.cmd = 2;
                            //stPLC_MesData.Left.BarcodeSet.strCarrierBarcode = "A123456";
                            //stPLC_MesData.Left.BarcodeSet.strPCBBarcode = "A1507V000239";
                            //stPLC_MesData.Left.iotData.BeatAction = 1;
                            //stPLC_MesData.Left.iotData.BeatAction = 2;
                            //stPLC_MesData.Left.BarcodeSet.strCarrierBarcode = "A123456";

                            #region 去除扫码产生的特殊字符

                            stPLC_MesData.Left.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strProductBarcode);
                            stPLC_MesData.Left.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strPartBarcode);
                            stPLC_MesData.Left.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.Left.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strPCBBarcode);
                            stPLC_MesData.Right.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strProductBarcode);
                            stPLC_MesData.Right.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strPartBarcode);
                            stPLC_MesData.Right.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.Right.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strPCBBarcode);

                            #endregion

                            //richTextBox1.AppendText("\n" + "读取成功");
                            //设备状态
                            int xmDeviceStateInt_L = stPLC_MesData.Left.iotData.machineState;
                            int xmDeviceStateInt_R = stPLC_MesData.Right.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt_L < 0 || xmDeviceStateInt_L > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt_L;
                            xmDeviceStateData.right = (xmDeviceStateInt_L < 0 || xmDeviceStateInt_L > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt_R;
                            //载具SN
                            CarrierBarcode_Left = stPLC_MesData.Left.BarcodeSet.strCarrierBarcode;
                            CarrierBarcode_Right = stPLC_MesData.Right.BarcodeSet.strCarrierBarcode;
                            // 节拍
                            s3PLCData["a3OEEType_left"] = stPLC_MesData.Left.iotData.BeatAction;
                            s3PLCData["a3OEEType_right"] = stPLC_MesData.Right.iotData.BeatAction;
                            //报警信息
                            _FaultDatas = stPLC_MesData.Left.iotData.fault_codes;
                            _FaultDatas2 = stPLC_MesData.Right.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 左边进站

                        try
                        {
                            if (stPLC_MesData.Left.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP31]";
                                        stationName = "点散热胶装备1";
                                        stationNameStr = stationCode + stationName;
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S3进站(plcNo, stationNameStr, stPLC_MesData.Left,
                                            tagBaseName + ".Left." + tagMesCommName,
                                            tagBaseName + ".Left." + tagBarsetName, "Left", out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 左边进站

                        #region 左边出站

                        try
                        {
                            if (stPLC_MesData.Left.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP31]";
                                        stationName = "点散热胶装备1";
                                        stationNameStr = stationCode + stationName;
                                        ProgressState = true;
                                        Task.Run(() => S3出站(plcNo, stationNameStr, stPLC_MesData.Left,
                                            tagBaseName + ".Left." + tagMesCommName, stationCode, stationName, "Left",
                                            out ProgressState));
                                        stPLC_MesData.Left.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 左边出站

                        #region 右边进站

                        try
                        {
                            if (stPLC_MesData.Right.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        stationCode = "[OP32]";
                                        stationName = "点散热胶装备2";
                                        stationNameStr = stationCode + stationName;

                                        ProgressState = true;
                                        Task.Run(() => S3进站(plcNo, stationNameStr, stPLC_MesData.Right,
                                            tagBaseName + ".Right." + tagMesCommName,
                                            tagBaseName + ".Right." + tagBarsetName, "Right", out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 右边进站

                        #region 右边出站

                        try
                        {
                            if (stPLC_MesData.Right.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP32]";
                                        stationName = "点散热胶装备2";
                                        stationNameStr = stationCode + stationName;

                                        ProgressState = true;
                                        Task.Run(() => S3出站(plcNo, stationNameStr, stPLC_MesData.Right,
                                            tagBaseName + ".Right." + tagMesCommName, stationCode, stationName, "Right",
                                            out ProgressState));
                                        stPLC_MesData.Right.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 右边出站

                        #region 节拍接口

                        try
                        {
                            #region 左工位 节拍

                            if (stPLC_MesData.Left.iotData.BeatAction > 0)
                            {
                                stationCode = "[OP31]";
                                stationName = "点散热胶装备1";
                                stationNameStr = stationCode + stationName;
                                int a3OEEType_left = Convert.ToInt32(s3PLCData["a3OEEType_left"]);
                                int a3OEETypeGOld_left = Convert.ToInt32(s3PLCSignal_Old["a3OEEType_left"]);

                                if (a3OEEType_left != a3OEETypeGOld_left)
                                {
                                    s3PLCData["OEETypeFlag_left"] = "1";
                                }
                                else {
                                    s3PLCData["OEETypeFlag_left"] = "0";
                                }
                                if (s3PLCData["OEETypeFlag_left"].ToString() == "1" && (a3OEEType_left == 1 || a3OEEType_left == 3 || a3OEEType_left == 5))
                                {
                                    Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                                 tagBaseName + ".Left." + tagiotComnName, CarrierBarcode_Left,
                                                 stPLC_MesData.Left.iotData));
                                }
                            }

                            s3PLCSignal_Old["a3OEEType_left"] = s3PLCData["a3OEEType_left"];

                            #endregion 左工位 节拍

                            #region 右工位 节拍
                            if (stPLC_MesData.Right.iotData.BeatAction > 0)
                            {
                                stationCode = "[OP32]";
                                stationName = "点散热胶装备2";
                                stationNameStr = stationCode + stationName;
                                int a3OEEType_right = Convert.ToInt32(s3PLCData["a3OEEType_right"]);
                                int a3OEETypeGOld_right = Convert.ToInt32(s3PLCSignal_Old["a3OEEType_right"]);
                                if (a3OEEType_right != a3OEETypeGOld_right)
                                {
                                    s3PLCData["OEETypeFlag_right"] = "1";
                                }
                                else
                                {
                                    s3PLCData["OEETypeFlag_right"] = "0";
                                }
                                if (s3PLCData["OEETypeFlag_right"].ToString() == "1" && (a3OEEType_right == 1 || a3OEEType_right == 3 || a3OEEType_right == 5))
                                {
                                    Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                                 tagBaseName + ".Right." + tagiotComnName, CarrierBarcode_Right,
                                                 stPLC_MesData.Right.iotData));
                                    s3PLCSignal_Old["a3OEEType_right"] = s3PLCData["a3OEEType_right"];
                                }
                            }

                            #endregion 右工位 节拍
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect();
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());

                    //Funs[plcNo].ReConnect();
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }

        /// <summary>
        /// [S3] 点散热胶装备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S3进站(int plcNo, string stationNameStr, OP30_stnDataSet_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, string direction, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S3_MachineId; // 装备ID（可配置）
                string StationId = string.Empty;
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                string slot = "";
                if (direction == "Left")
                {
                    StationId = GlobalContext.S3_StationId_1; // 工位ID（可配置）
                    slot = "01-SLOT-01";
                }

                if (direction == "Right")
                {
                    StationId = GlobalContext.S3_StationId_2; // 工位ID（可配置）
                    slot = "01-SLOT-02";
                }

                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）

                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strProductBarcode};产品码:{sn}");

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, slot);
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_" + direction + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_" + direction + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        /// <summary>
        /// [S3] 点散热胶装备 - 出站
        /// </summary>
        private void S3出站(int plcNo, string stationNameStr, OP30_stnDataSet_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, string direction, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_出站开始");

                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S3_MachineId; // 装备id（可配置）  
                string StationId = string.Empty;
                if (direction == "Left")
                {
                    StationId = GlobalContext.S3_StationId_1; // 工位ID（可配置）
                }

                if (direction == "Right")
                {
                    StationId = GlobalContext.S3_StationId_2; // 工位ID（可配置）
                }

                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    ProgressState = false;
                    Thread.Sleep(10000);
                    return;
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");

                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                //if (direction == "Right")
                //{ 
                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, "", paramJson, direction);
                //}


                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                if (direction == "Left")
                {
                    string strMesHeightInfos = FloatArrayToString(stPLC_MesData.mesData.fMesHeightInfos);
                    string strIntervalWeights = FloatArrayToString(stPLC_MesData.mesData.fIntervalWeights);
                    string strRemainGlues = FloatArrayToString(stPLC_MesData.mesData.fRemainGlues);
                    message = SQLHelper.InsertOp301Data(CarrierBarcode, sn, stPLC_MesData.mesData.fGlueSupplySpeed,
                        stPLC_MesData.mesData.fAB_AirPress, stPLC_MesData.mesData.fAB_AirPressDiff,
                        strMesHeightInfos, strIntervalWeights, strRemainGlues);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                    }
                }

                if (direction == "Right")
                {
                    string strMesHeightInfos = FloatArrayToString(stPLC_MesData.mesData.fMesHeightInfos);
                    string strIntervalWeights = FloatArrayToString(stPLC_MesData.mesData.fIntervalWeights);
                    string strRemainGlues = FloatArrayToString(stPLC_MesData.mesData.fRemainGlues);
                    message = SQLHelper.InsertOp302Data(CarrierBarcode, sn, stPLC_MesData.mesData.fGlueSupplySpeed,
                        stPLC_MesData.mesData.fAB_AirPress, stPLC_MesData.mesData.fAB_AirPressDiff,
                        strMesHeightInfos, strIntervalWeights, strRemainGlues);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                    }
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        #endregion S3

        #region S4

        /// <summary>
        /// [S4] 点胶检测设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S4(int plcNo)
        {
            string stationCode = "[OP40]";
            string stationName = "胶线检测";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP40_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";

            // 触发信号字典
            //s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
            s4PLCSignal_Old.Add("a4OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s4PLCData.Add("a4OEEType", 0); // 节拍类型(plc写入) 

            OP40_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP40_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //去除扫码产生的特殊字符
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);
                            //richTextBox1.AppendText("\n" + "读取成功");
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;
                            // 载具SN
                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode;
                            // 节拍
                            s4PLCData["a4OEEType"] = stPLC_MesData.iotData.BeatAction;
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S4进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                            out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S4出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站

                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a4OEEType = Convert.ToInt32(s4PLCData["a4OEEType"]);
                                int a4OEETypeGOld = Convert.ToInt32(s4PLCSignal_Old["a4OEEType"]);
                                //若设备紧急复原后节拍重置
                                if (a4OEEType == 1)
                                {
                                    a4OEETypeGOld = 0;
                                }

                                if (a4OEEType != a4OEETypeGOld)
                                {
                                    if (a4OEETypeGOld <= 2 && a4OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a4OEETypeGOld == 1 && a4OEEType != 2) ||
                                            (a4OEETypeGOld == 3 && a4OEEType != 4) ||
                                            (a4OEETypeGOld == 5 && a4OEEType != 6))
                                        {
                                            //写入PLC
                                            stPLC_MesData.iotData.beatReturn = 2; //NG
                                            WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1,
                                                stPLC_MesData.iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a4OEEType}]，未上传节拍[{a4OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                                tagBaseName + "." + tagiotComnName, CarrierBarcode,
                                                stPLC_MesData.iotData));
                                            //Task.Run(() =>
                                            //    S4节拍接口(plcNo, stationNameStr, tagBaseName,
                                            //        stPLC_MesData.iotData)); 
                                        }
                                    }
                                }
                            }

                            s4PLCSignal_Old["a4OEEType"] = s4PLCData["a4OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S4] 点胶检测设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S4进站(int plcNo, string stationNameStr, OP40_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S4_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S4_StationId; // 工位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）
                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    ProgressState = false;
                    Thread.Sleep(10000);
                    return;
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        /// <summary>
        /// [S4] 点胶检测设备 - 出站接口
        /// </summary>
        private void S4出站(int plcNo, string stationNameStr, OP40_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S4_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S4_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    ProgressState = false;
                    Thread.Sleep(10000);
                    return;
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");

                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                #region 上传图片

                if (GlobalContext.MQTTIsSendUpFile)
                {
                    string[] urlarry = GlobalContext.UpFilePath.Split(",");
                    fileUploadData.fileData.Clear();
                    foreach (var item in urlarry)
                    {
                        if (!string.IsNullOrEmpty(item))
                        {
                            //上传图片
                            var result = SaveDBbyFileInfo(stPLC_MesData.BarcodeSet, stationCode, stationName, a1Result,
                                item, uuid).Result;
                            OnMessage(LogType.Error, $"【文件上传】 产品码 [{sn}] " + result.Item2);
                        }
                    }
                }

                #endregion


                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode,
                    "01-SLOT-01", MachineId, StationId, "", paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                string strGluePosX = FloatArrayToString(stPLC_MesData.mesData.fGluePosX);
                string strGluePosY = FloatArrayToString(stPLC_MesData.mesData.fGluePosY);
                string strGlue_Areas = FloatArrayToString(stPLC_MesData.mesData.fGlue_Areas);
                string strGlue_Heights = FloatArrayToString(stPLC_MesData.mesData.fGlue_Heights);
                message = SQLHelper.InsertOp40Data(CarrierBarcode, sn, strGluePosX,
                    strGluePosY, strGlue_Areas, strGlue_Heights, stPLC_MesData.mesData.nResult, "");
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        private void S4节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a4OEEType"]).ToString(); // 节拍类型(plc写入)
                string a40EEPartNo = (string)s1PLCData["a40EEPartNo"]; // 物料码
                a40EEPartNo = a40EEPartNo.Replace("\0", "");
                string a50EEVehicleCode = (string)s1PLCData["a50EEVehicleCode"]; // 载具SN
                a50EEVehicleCode = a50EEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a40EEPartNo) && string.IsNullOrEmpty(a50EEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a50EEVehicleCode}][{a40EEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a40EEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a50EEVehicleCode}][{a40EEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a50EEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a50EEVehicleCode}][{a40EEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a40EEPartNo, a50EEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #region S5

        private static bool isPCBStation = false; //控制PCB是否进出站的标识

        /// <summary>
        /// [S5] 点胶检测设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S5(int plcNo)
        {
            string stationCode = "[OP50]";
            string stationName = "ADD板上料组装装备";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP50_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string pcbBarcode = "";
            string pcbBarcodeOld = "";

            OP50_MesData_t stPLC_MesData; //PLC的MES数据
            string CarrierBarcode = "";

            // 触发信号字典
            s5PLCSignal_Old.Add("a5OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s5PLCData.Add("a5OEEType", 0); // 节拍类型(plc写入) 
            s5PLCData.Add("OEETypeFlag", 0); // 节拍标识 0 不上传 ,1 上传

            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();
                        stopwatch2.Start();



                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP50_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                        }
                        else
                        {
                            //测试数据
                            //stPLC_MesData.mesCommFrmPLC.cmd = 2;
                            //stPLC_MesData.BarcodeSet.strCarrierBarcode = "A123456";
                            //stPLC_MesData.BarcodeSet.strPCBBarcode = "A1507V000239";
                            //stPLC_MesData.iotData.BeatAction = 1;
                            //stPLC_MesData.iotData.BeatAction = 2;
                            //stPLC_MesData.iotData.BeatAction = 3;
                            //stPLC_MesData.iotData.BeatAction = 4;
                            //stPLC_MesData.iotData.BeatAction = 5;
                            //stPLC_MesData.iotData.BeatAction = 6;
                            //stPLC_MesData.BarcodeSet.strCarrierBarcode = "A123456";

                            #region 去除扫码产生的特殊字符

                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);

                            #endregion

                            //richTextBox1.AppendText("\n" + "读取成功");
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;
                            // 节拍
                            s5PLCData["a5OEEType"] = stPLC_MesData.iotData.BeatAction;
                            //载具码
                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode.ToString();
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        string PCBBarcode = stPLC_MesData.BarcodeSet.strPCBBarcode;
                                        if (PCBBarcode != "ERROR" && !string.IsNullOrEmpty(PCBBarcode))
                                        {
                                            ProgressState = true;
                                            Task.Run(() => S5进站(plcNo, stationNameStr, stPLC_MesData,
                                                tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                                out ProgressState));
                                        }
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S5出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站

                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a5OEEType = Convert.ToInt32(s5PLCData["a5OEEType"]);
                                int a5OEETypeGOld = Convert.ToInt32(s5PLCSignal_Old["a5OEEType"]);

                                if (a5OEEType != a5OEETypeGOld)
                                {
                                    s5PLCData["OEETypeFlag"] = "1";
                                }
                                else { 
                                    s5PLCData["OEETypeFlag"] = "0";
                                }
                                if (s5PLCData["OEETypeFlag"] == "1" && (a5OEEType==1 || a5OEEType == 3 || a5OEEType == 5))
                                {
                                    Task.Run(() => 通用节拍接口(plcNo, stationNameStr,
                                               tagBaseName + "." + tagiotComnName, CarrierBarcode,
                                               stPLC_MesData.iotData));
                                    s5PLCSignal_Old["a5OEEType"] = s5PLCData["a5OEEType"];
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S5] 点胶检测设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S5进站(int plcNo, string stationNameStr, OP50_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                //string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode;  // 产品SN（物料码）
                //sn = sn.Substring(sn.Length - 11, 4) + sn.Substring(sn.Length - 5, 5);
                string MachineId = GlobalContext.S5_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S5_StationId; // 工位ID（可配置）
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码
                string pcbBarcode = (string)stPLC_MesData.BarcodeSet.strPCBBarcode;
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                AddMessage(LogType.Info, $"ADD板编码(PCB码):{pcbBarcode}");

                //绑定载具和产品
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.PCBCarrierBind(strCarrierBarcode, pcbBarcode);
                if (message.result == false)
                {
                    AddMessage(LogType.Error, stationNameStr + "_载具码与产品码绑定失败,错误:" + message.text);
                }

                //载具码验证产品码                                                                              //载具码验证产品码 
                //string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);

                //if (string.IsNullOrEmpty(strProductBarcode))
                //{
                //    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                //}

                //sn = strProductBarcode;
                //AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                    pcbBarcode,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 2 : 120);
                if (mesResultFrmWeb == 1)
                {
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        /// <summary>
        /// [S5] 点胶检测设备 - 出站接口
        /// </summary>
        private void S5出站(int plcNo, string stationNameStr, OP50_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string PartBarcode = (string)stPLC_MesData.BarcodeSet.strPartBarcode; // 部件条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string pcbBarcode = (string)stPLC_MesData.BarcodeSet.strPCBBarcode;

                string MachineId = GlobalContext.S5_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S5_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                CommandFromPLC resultToPlC = new CommandFromPLC();

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                    ProgressState = false;
                    //写入PLC
                    resultToPlC.cmd = 0;
                    resultToPlC.cmdParam = 0; //指令参数
                    resultToPlC.cmdResult = 110;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                    return;
                }

                stPLC_MesData.BarcodeSet.strProductBarcode = strProductBarcode;
                sn = strProductBarcode;
                //数据库绑定载具和PCB
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.PCBCarrierBind(CarrierBarcode, pcbBarcode);
                if (message.result == false)
                {
                    AddMessage(LogType.Error, stationNameStr + "_PCB码数据库绑定失败,错误:" + message.text);
                    ProgressState = true; //防止循环报错
                    return;
                }

                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn};PCB码:{pcbBarcode}");

                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "PCB码",
                    Parameter_value = pcbBarcode,
                    Parameter_unit = ""
                });

                #region 上传图片

                if (GlobalContext.MQTTIsSendUpFile)
                {
                    string[] urlarry = GlobalContext.UpFilePath.Split(",");
                    fileUploadData.fileData.Clear();
                    foreach (var item in urlarry)
                    {
                        if (!string.IsNullOrEmpty(item))
                        {
                            //上传图片
                            var result = SaveDBbyFileInfo(stPLC_MesData.BarcodeSet, stationCode, stationName, a1Result,
                                item, uuid).Result;
                            OnMessage(LogType.Error, $"【文件上传】 产品码 [{sn}] " + result.Item2);
                        }
                    }
                }

                #endregion


                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, PartBarcode, paramJson);

                byte mesResultFrmWeb = 0;
                if (stPLC_MesData.mesCommFrmPLC.cmdParam == 2)
                {
                    result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem, workorder_code,
                        batch_num
                        , mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1", MachineId, StationId,
                        PartBarcode, paramJson);
                }
                else if (stPLC_MesData.mesCommFrmPLC.cmdParam == 1)
                {
                    result1 = PCBStationOutData(stPLC_MesData.BarcodeSet, stPLC_MesData.iotData);
                }

                mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);

                //进站结果写入PLC
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                //ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertOp50Data(CarrierBarcode, sn, stPLC_MesData.mesData.nIsAddPCBAsmOK,
                    stPLC_MesData.mesData.nHaveAddPCB, stPLC_MesData.mesData.fForceAddPCB,
                    stPLC_MesData.mesData.nRemainCount, "");
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                //保存部件码信息
                if (!string.IsNullOrEmpty(PartBarcode))
                {
                    message = SQLHelper.InsertOp50Product(CarrierBarcode, sn, PartBarcode);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Info, stationNameStr + "_保存部件码信息失败");
                    }
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        private int S5_PCB进出站(OP50_MesData_t stPLC_MesData, int plcNo, string stationNameStr, string tagBaseName,
            string tagMesCommName)
        {
            string PCBBarcode = stPLC_MesData.BarcodeSet.strPCBBarcode;
            if (PCBBarcode != "ERROR" && !string.IsNullOrEmpty(PCBBarcode))
            {
                string strProductBarcode =
                    SQLHelper.GetProductBarcodeByCarrierCode(stPLC_MesData.BarcodeSet.strCarrierBarcode);

                stPLC_MesData.BarcodeSet.strProductBarcode = strProductBarcode;
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数

                if (GlobalContext.IsSendStationIn)
                {
                    #region 进站

                    //int res1 = PCBStationInData(stPLC_MesData.BarcodeSet, stPLC_MesData.iotData);
                    //if (res1 == 1)
                    //{
                    //    resultToPlC.cmdResult = 2;//OK
                    //    WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagMesCommName, 1, resultToPlC);
                    //}
                    //else
                    //{
                    //    resultToPlC.cmdResult = 120;
                    //    WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagMesCommName, 1, resultToPlC);
                    //    return 2;
                    //}

                    #endregion

                    #region 出站

                    int res2 = PCBStationOutData(stPLC_MesData.BarcodeSet, stPLC_MesData.iotData);
                    if (res2 == 1)
                    {
                        resultToPlC.cmdResult = 2; //OK
                        WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagMesCommName, 1, resultToPlC);
                        return 1;
                    }
                    else
                    {
                        resultToPlC.cmdResult = 120;
                        WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagMesCommName, 1, resultToPlC);
                        return 2;
                    }

                    #endregion
                }
                else
                {
                    return 2;
                }
            }
            else
            {
                return 2;
            }
        }

        private void S5节拍接口(int plcNo, string stationNameStr, string tagMesCommName, string CarrierBarcode,
            IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = iot_data.BeatAction.ToString(); // 节拍类型(plc写入)
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode); //产品SN

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(strProductBarcode) && string.IsNullOrEmpty(CarrierBarcode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{CarrierBarcode}][{strProductBarcode}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(strProductBarcode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{CarrierBarcode}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(CarrierBarcode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;

                // 上传OEE
                (short, string) result =
                    SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 1; //OK
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iotData.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                IoT_DataSet_t iotData = new IoT_DataSet_t();
                iotData.machineState = iot_data.machineState;
                iotData.work_type = iot_data.work_type;
                iotData.testStatus = iot_data.testStatus;
                iotData.BeatAction = iot_data.BeatAction;
                iotData.beatReturn = 2; //NG
                iotData.fault_codes = iot_data.fault_codes;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #region S6

        private Dictionary<string, object> s6PLCData = new Dictionary<string, object>();
        private Dictionary<string, object> s6PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// [S6] 顶盖装配设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S6(int plcNo)
        {
            string stationCode = "[OP70]";
            string stationName = "组上盖板";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP60_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";

            // 触发信号字典
            s6PLCSignal_Old.Add("a6OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s6PLCData.Add("a6OEEType", 0); // 节拍类型(plc写入) 

            OP60_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;


            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    //弹出扫码框则停止循环
                    if (isNoStop)
                    {
                        Task.Delay(1000);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP60_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        //测试
                        //stPLC_MesData.BarcodeSet.strCarrierBarcode = "A123456";
                        //stPLC_MesData.mesCommFrmPLC.cmd = 1;

                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //去除扫码产生的特殊字符
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);
                            //richTextBox1.AppendText("\n" + "读取成功");
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;

                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具SN
                            s6PLCData["a6OEEType"] = stPLC_MesData.iotData.BeatAction; // 节拍
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S6进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                            out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        ;
                                        Task.Run(() => S6出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站

                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a6OEEType = Convert.ToInt32(s6PLCData["a6OEEType"]);
                                int a6OEETypeGOld = Convert.ToInt32(s6PLCSignal_Old["a6OEEType"]);
                                //若设备紧急复原后节拍重置
                                if (a6OEEType == 1)
                                {
                                    a6OEETypeGOld = 0;
                                }

                                if (a6OEEType != a6OEETypeGOld)
                                {
                                    if (a6OEETypeGOld <= 2 && a6OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a6OEETypeGOld == 1 && a6OEEType != 2) ||
                                            (a6OEETypeGOld == 3 && a6OEEType != 4) ||
                                            (a6OEETypeGOld == 5 && a6OEEType != 6))
                                        {
                                            //写入PLC
                                            stPLC_MesData.iotData.beatReturn = 2; //NG
                                            WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1,
                                                stPLC_MesData.iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a6OEEType}]，未上传节拍[{a6OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() =>
                                                通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                    CarrierBarcode,
                                                    stPLC_MesData.iotData));
                                            //Task.Run(() =>
                                            //    S6节拍接口(plcNo, stationNameStr, tagBaseName,
                                            //        stPLC_MesData.iotData)); 
                                        }
                                    }
                                }
                            }

                            s6PLCSignal_Old["a6OEEType"] = s6PLCData["a6OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S6] 顶盖装配设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S6进站(int plcNo, string stationNameStr, OP60_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S6_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S6_StationId; // 工位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）
                //strCarrierBarcode = "N801A-003";
                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                string strPCBBarcode = SQLHelper.GetPCBBarcodeByCarrierCode(strCarrierBarcode);

                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                if (OpenDailogFalg)
                {
                    using (var dialog = new BandBarodeDialog())
                    {
                        dialog._CarrierBarcode = strCarrierBarcode;
                        dialog._ProductBarcode = sn;
                        dialog._PCBBarcode = strPCBBarcode;
                        var rs = dialog.ShowDialog();
                        if (rs == DialogResult.OK)
                        {
                            AddMessage(LogType.Info, $"扫码校验通过，载具码:{strCarrierBarcode};产品码:{sn};产品码:{sn}");
                            OpenDailogFalg = false; //关闭扫码
                            isNoStop = false;
                        }
                        else
                        {
                            ProgressState = false;
                            return;
                        }
                    }
                }

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
            OpenDailogFalg = true; //开启下一个物料的扫码
        }


        /// <summary>
        /// [S6] 顶盖装配设备 - 出站接口
        /// </summary>
        private void S6出站(int plcNo, string stationNameStr, OP60_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S6_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S6_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, "", paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertOp60Data(CarrierBarcode, sn, stPLC_MesData.mesData.nIsTopCoverAsmOK,
                    stPLC_MesData.mesData.nHaveTopCover, stPLC_MesData.mesData.fForceTopCover, "");
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        private void S6节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a6OEEType"]).ToString(); // 节拍类型(plc写入)
                string a60EEPartNo = (string)s1PLCData["a60EEPartNo"]; // 物料码
                a60EEPartNo = a60EEPartNo.Replace("\0", "");
                string a60EEVehicleCode = (string)s1PLCData["a60EEVehicleCode"]; // 载具SN
                a60EEVehicleCode = a60EEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a60EEPartNo) && string.IsNullOrEmpty(a60EEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a60EEVehicleCode}][{a60EEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a60EEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a60EEVehicleCode}][{a60EEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a60EEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a60EEVehicleCode}][{a60EEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a60EEPartNo, a60EEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #region S7

        private Dictionary<string, object> s7PLCSignal_Old = new Dictionary<string, object>();
        private Dictionary<string, object> s7PLCData = new Dictionary<string, object>();

        /// <summary>
        /// [S7] 锁螺丝设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S7(int plcNo)
        {
            string stationCode = "[OP80]";
            string stationName = "上盖板锁螺丝";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP70_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagBarsetName = "BarcodeSet";
            string tagiotComnName = "iotData";
            string tagScrewDataset = "screwDataset";

            string CarrierBarcode_Left = "";
            string CarrierBarcode_Right = "";

            s7PLCSignal_Old.Add("a7OEEType_left", 0); // 节拍类型(plc写入) 
            s7PLCSignal_Old.Add("a7OEEType_right", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s7PLCData.Add("a7OEEType_left", 0); // 节拍类型(plc写入) 
            s7PLCData.Add("a7OEEType_right", 0); // 节拍类型(plc写入) 

            OP70_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            AtlasScrew atlasScrewLeft = new AtlasScrew(GlobalContext.AtlasAddressLeft, GlobalContext.AtlasAddressPort,
                3000, 3000, "Left");
            atlasScrewLeft.Initial();
            AtlasScrew atlasScrewRight = new AtlasScrew(GlobalContext.AtlasAddressRight, GlobalContext.AtlasAddressPort,
                3000, 3000, "Right");
            atlasScrewRight.Initial();


            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP70_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            #region 去除扫码产生的特殊字符

                            stPLC_MesData.Left.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strProductBarcode);
                            stPLC_MesData.Left.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strPartBarcode);
                            stPLC_MesData.Left.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.Left.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.Left.BarcodeSet.strPCBBarcode);
                            stPLC_MesData.Right.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strProductBarcode);
                            stPLC_MesData.Right.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strPartBarcode);
                            stPLC_MesData.Right.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.Right.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.Right.BarcodeSet.strPCBBarcode);

                            #endregion

                            int xmDeviceStateInt_L = stPLC_MesData.Left.iotData.machineState;
                            int xmDeviceStateInt_R = stPLC_MesData.Right.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt_L < 0 || xmDeviceStateInt_L > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt_L;
                            xmDeviceStateData.right = (xmDeviceStateInt_L < 0 || xmDeviceStateInt_L > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt_R;
                            s7PLCData["a7OEEPartNo"] =
                                stPLC_MesData.Left.BarcodeSet.strProductBarcode; // 物料码（物料码还未绑定载具SN时必填）
                            // 载具SN
                            CarrierBarcode_Left = stPLC_MesData.Left.BarcodeSet.strCarrierBarcode;
                            CarrierBarcode_Right = stPLC_MesData.Right.BarcodeSet.strCarrierBarcode;
                            // 节拍
                            s7PLCData["a7OEEType"] = stPLC_MesData.Left.iotData.BeatAction;
                            s7PLCData["a7OEEType_right"] = stPLC_MesData.Right.iotData.BeatAction;

                            //报警信息
                            _FaultDatas = stPLC_MesData.Left.iotData.fault_codes;
                            _FaultDatas2 = stPLC_MesData.Right.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 左边进站

                        try
                        {
                            if (stPLC_MesData.Left.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP81]";
                                        stationName = "上盖板锁螺丝1";
                                        stationNameStr = stationCode + stationName;
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S7进站(plcNo, stationNameStr, stPLC_MesData.Left,
                                            tagBaseName + ".Left." + tagMesCommName,
                                            tagBaseName + ".Left." + tagBarsetName, "Left", out ProgressState,
                                            atlasScrewLeft));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 左边进站

                        #region 左边出站

                        try
                        {
                            if (stPLC_MesData.Left.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP81]";
                                        stationName = "上盖板锁螺丝1";
                                        stationNameStr = stationCode + stationName;
                                        ProgressState = true;
                                        Task.Run(() => S7出站(plcNo, stationNameStr, stPLC_MesData.Left,
                                            tagBaseName + ".Left." + tagMesCommName, stationCode, stationName, "Left",
                                            out ProgressState));
                                        stPLC_MesData.Left.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 左边出站

                        #region 右边进站

                        try
                        {
                            if (stPLC_MesData.Right.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        stationCode = "[OP82]";
                                        stationName = "上盖板锁螺丝2";
                                        stationNameStr = stationCode + stationName;
                                        ProgressState = true;
                                        Task.Run(() => S7进站(plcNo, stationNameStr, stPLC_MesData.Right,
                                            tagBaseName + ".Right." + tagMesCommName,
                                            tagBaseName + ".Right" + tagBarsetName, "Right", out ProgressState,
                                            atlasScrewRight));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 右边进站

                        #region 右边出站

                        try
                        {
                            if (stPLC_MesData.Right.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        stationCode = "[OP82]";
                                        stationName = "上盖板锁螺丝2";
                                        stationNameStr = stationCode + stationName;
                                        ProgressState = true;
                                        Task.Run(() => S7出站(plcNo, stationNameStr, stPLC_MesData.Right,
                                            tagBaseName + ".Right." + tagMesCommName, stationCode, stationName, "Right",
                                            out ProgressState));
                                        stPLC_MesData.Right.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 右边出站

                        #region 节拍接口

                        try
                        {
                            #region 左工位 节拍

                            if (stPLC_MesData.Left.iotData.BeatAction > 0)
                            {
                                stationCode = "[OP81]";
                                stationName = "上盖板锁螺丝1";
                                stationNameStr = stationCode + stationName;

                                int a7OEEType_left = Convert.ToInt32(s7PLCData["a7OEEType_left"]);
                                int a7OEETypeGOld_left = Convert.ToInt32(s7PLCSignal_Old["a7OEEType_left"]);
                                //若设备紧急复原后节拍重置
                                if (a7OEEType_left == 1)
                                {
                                    a7OEETypeGOld_left = 0;
                                }

                                if (a7OEEType_left != a7OEETypeGOld_left)
                                {
                                    //如果上位机告诉PLC NG，PLC节拍会直接从1跳到4
                                    if (a7OEETypeGOld_left <= 2 && a7OEEType_left == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + ".Left." + tagMesCommName,
                                                CarrierBarcode_Left,
                                                stPLC_MesData.Left.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a7OEETypeGOld_left == 1 && a7OEEType_left != 2) ||
                                            (a7OEETypeGOld_left == 3 && a7OEEType_left != 4) ||
                                            (a7OEETypeGOld_left == 5 && a7OEEType_left != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.Left.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.Left.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.Left.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.Left.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.Left.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr,
                                                tagBaseName + ".Left." + tagiotComnName, 1, iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a7OEEType_left}]，未上传节拍[{a7OEETypeGOld_left}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() =>
                                                通用节拍接口(plcNo, stationNameStr, tagBaseName + ".Left." + tagMesCommName,
                                                    CarrierBarcode_Left,
                                                    stPLC_MesData.Left.iotData));
                                            //Task.Run(() =>
                                            //    S7节拍接口(plcNo, stationNameStr, tagBaseName + ".Left." + tagMesCommName,
                                            //        stPLC_MesData.Left.iotData)); 
                                        }
                                    }
                                }
                            }

                            s7PLCSignal_Old["a7OEEType_left"] = s7PLCData["a7OEEType_left"];

                            #endregion 左工位 节拍

                            #region 右工位 节拍

                            if (stPLC_MesData.Right.iotData.BeatAction > 0)
                            {
                                stationCode = "[OP82]";
                                stationName = "上盖板锁螺丝2";
                                stationNameStr = stationCode + stationName;

                                int a7OEEType_right = Convert.ToInt32(s7PLCData["a7OEEType_right"]);
                                int a7OEETypeGOld_right = Convert.ToInt32(s7PLCSignal_Old["a7OEEType_right"]);
                                //若设备紧急复原后节拍重置
                                if (a7OEEType_right == 1)
                                {
                                    a7OEETypeGOld_right = 0;
                                }

                                if (a7OEEType_right != a7OEETypeGOld_right)
                                {
                                    if (a7OEETypeGOld_right <= 2 && a7OEEType_right == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + ".Right." + tagMesCommName,
                                                CarrierBarcode_Right,
                                                stPLC_MesData.Right.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a7OEETypeGOld_right == 1 && a7OEEType_right != 2) ||
                                            (a7OEETypeGOld_right == 3 && a7OEEType_right != 4) ||
                                            (a7OEETypeGOld_right == 5 && a7OEEType_right != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.Left.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.Left.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.Left.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.Left.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.Left.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr,
                                                tagBaseName + ".Right." + tagiotComnName, 1, iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a7OEEType_right}]，未上传节拍[{a7OEETypeGOld_right}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() =>
                                                通用节拍接口(plcNo, stationNameStr, tagBaseName + ".Right." + tagMesCommName,
                                                    CarrierBarcode_Right,
                                                    stPLC_MesData.Right.iotData));
                                            //Task.Run(() =>
                                            //    S7节拍接口(plcNo, stationNameStr, tagBaseName + ".Right." + tagMesCommName,
                                            //        stPLC_MesData.Left.iotData)); 
                                        }
                                    }
                                }
                            }

                            s7PLCSignal_Old["a7OEEType_right"] = s7PLCData["a7OEEType_right"];

                            #endregion 右工位 节拍
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S7] 锁螺丝设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S7进站(int plcNo, string stationNameStr, OP70_stnDataSet_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, string direction, out bool ProgressState, AtlasScrew atlasScrew)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            string atlasSn = string.Empty;
            try
            {
                stopwatch1.Start();

                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S7_MachineId; // 装备ID（可配置）
                string StationId = string.Empty; // 工位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                if (direction == "Left")
                {
                    StationId = GlobalContext.S7_StationId_1;
                }

                if (direction == "Right")
                {
                    StationId = GlobalContext.S7_StationId_2;
                }

                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）

                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                atlasSn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                string slot = "";
                if (direction == "Left")
                {
                    isCollectingFlagLeft = false; //采集螺丝数据结束
                    slot = "01-SLOT-01";
                }

                if (direction == "Right")
                {
                    isCollectingFlagRight = false; //采集螺丝数据结束
                    slot = "01-SLOT-02";
                }

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, slot);
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_" + direction + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_" + direction + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;

            //开始采集螺丝数据
            if (direction == "Left")
            {
                isCollectingFlagLeft = true;
                CollectAndProcessDataLeft(atlasScrew, atlasSn, direction);
            }

            if (direction == "Right")
            {
                isCollectingFlagRight = true;
                CollectAndProcessDataRight(atlasScrew, atlasSn, direction);
            }
        }


        /// <summary>
        /// [S7] 锁螺丝设备 - 出站
        /// </summary>
        private void S7出站(int plcNo, string stationNameStr, OP70_stnDataSet_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, string direction, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_出站开始");

                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S7_MachineId; // 装备id（可配置）  
                string StationId = string.Empty; // 工位ID（可配置）
                if (direction == "Left")
                {
                    StationId = GlobalContext.S7_StationId_1;
                }

                if (direction == "Right")
                {
                    StationId = GlobalContext.S7_StationId_2;
                }

                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                //a1Result = 1;
                bool pass = a1Result == 1;
                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                //if (direction == "Right")
                //{ 
                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem, workorder_code,
                    batch_num, mtltmrk, plcDate_YMD, supplierCode
                    , sn, pass, CarrierBarcode, "1", MachineId, StationId, "", paramJson);

                //}

                //if (direction == "Left")
                //{
                //    isCollectingFlagLeft = false;//采集螺丝数据结束
                //}
                //if (direction == "Right")
                //{
                //    isCollectingFlagRight = false;//采集螺丝数据结束
                //}

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                if (direction == "Left")
                {
                    string strMesHeightInfos = FloatArrayToString(stPLC_MesData.mesData.fScrewTimes);
                    string strScrewOrders = ShortArrayToString(stPLC_MesData.mesData.nScrewOrders);
                    string strScrewResults = ShortArrayToString(stPLC_MesData.mesData.nScrewResults);
                    message = SQLHelper.InsertOp701Data(CarrierBarcode, sn, strMesHeightInfos,
                        strScrewOrders, strScrewResults, stPLC_MesData.mesData.nRemainCount);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Info, stationNameStr + "_Left_保存加工数据失败");
                    }
                }

                if (direction == "Right")
                {
                    string strMesHeightInfos = FloatArrayToString(stPLC_MesData.mesData.fScrewTimes);
                    string strScrewOrders = ShortArrayToString(stPLC_MesData.mesData.nScrewOrders);
                    string strScrewResults = ShortArrayToString(stPLC_MesData.mesData.nScrewResults);
                    message = SQLHelper.InsertOp702Data(CarrierBarcode, sn, strMesHeightInfos,
                        strScrewOrders, strScrewResults, stPLC_MesData.mesData.nRemainCount);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Info, stationNameStr + "__Right_保存加工数据失败");
                    }
                }

                //保存螺丝数据到txt
                (int, string) result = SaveScrewDataToTxt(direction, sn, stPLC_MesData.mesData.fScrewTimes,
                    stPLC_MesData.mesData.nScrewOrders, stPLC_MesData.mesData.nScrewResults);
                if (result.Item1 != 0)
                {
                    AddMessage(LogType.Error, $"{stationNameStr}螺丝数据保存失败 " + message.text);
                }

                AddMessage(LogType.Info, stationNameStr + "_" + direction + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }


            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        private void S7节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a7OEEType"]).ToString(); // 节拍类型(plc写入)
                string a7OEEPartNo = (string)s1PLCData["a7OEEPartNo"]; // 物料码
                a7OEEPartNo = a7OEEPartNo.Replace("\0", "");
                string a7OEEVehicleCode = (string)s1PLCData["a7OEEVehicleCode"]; // 载具SN
                a7OEEVehicleCode = a7OEEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a7OEEPartNo) && string.IsNullOrEmpty(a7OEEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a7OEEVehicleCode}][{a7OEEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a7OEEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a7OEEVehicleCode}][{a7OEEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a7OEEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a7OEEVehicleCode}][{a7OEEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a7OEEPartNo, a7OEEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #region S8

        private Dictionary<string, object> s8PLCData = new Dictionary<string, object>();
        private Dictionary<string, object> s8PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// [S8] 3D螺丝高度检测设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S8(int plcNo)
        {
            string stationCode = "[OP90]";
            string stationName = "NG下料";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP80_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";

            // 触发信号字典
            //s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
            s8PLCSignal_Old.Add("a8OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s8PLCData.Add("a8OEEType", 0); // 节拍类型(plc写入) 

            OP80_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP80_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //去除扫码产生的特殊字符
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();
                        //richTextBox1.AppendText("\n" + "读取成功");
                        int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                        xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                            ? XiaomiDeviceState.Unknown
                            : (XiaomiDeviceState)xmDeviceStateInt;

                        CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具SN
                        s8PLCData["a8OEEType"] = stPLC_MesData.iotData.BeatAction; // 节拍
                        //报警信息
                        _FaultDatas = stPLC_MesData.iotData.fault_codes;

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S8进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                            out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S8出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站

                        #region 节拍接口

                        try
                        {
                            int a8OEEType = Convert.ToInt32(s9PLCData["a8OEEType"]);
                            int a8OEETypeGOld = Convert.ToInt32(s9PLCSignal_Old["a8OEEType"]);
                            //若设备紧急复原后节拍重置
                            if (a8OEEType == 1)
                            {
                                a8OEETypeGOld = 0;
                            }

                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                if (a8OEEType != a8OEETypeGOld)
                                {
                                    //如果上位机告诉PLC NG，PLC节拍会直接从1跳到4
                                    if (a8OEETypeGOld <= 2 && a8OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a8OEETypeGOld == 1 && a8OEEType != 2) ||
                                            (a8OEETypeGOld == 3 && a8OEEType != 4) ||
                                            (a8OEETypeGOld == 5 && a8OEEType != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                1, iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a8OEEType}]，未上传节拍[{a8OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() =>
                                                通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                    CarrierBarcode,
                                                    stPLC_MesData.iotData));
                                            //Task.Run(() =>
                                            //    S8节拍接口(plcNo, stationNameStr, tagBaseName,
                                            //        stPLC_MesData.iotData)); 
                                        }
                                    }
                                }
                            }

                            s8PLCSignal_Old["a8OEEType"] = s8PLCData["a8OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S8] 3D螺丝高度检测设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S8进站(int plcNo, string stationNameStr, OP80_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
            bool pass = a1Result == 1;
            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S8_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S8_StationId; // 工位ID（可配置）
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）
                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_未能查到已绑定的载具信息，无法进行载具绑定产品验证");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");
                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                    sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(
                        str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        /// <summary>
        /// [S8] 3D螺丝高度检测设备 - 出站接口
        /// </summary>
        private void S8出站(int plcNo, string stationNameStr, OP80_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S8_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S8_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });

                #region 上传图片

                if (GlobalContext.MQTTIsSendUpFile)
                {
                    string[] urlarry = GlobalContext.UpFilePath.Split(",");
                    fileUploadData.fileData.Clear();
                    foreach (var item in urlarry)
                    {
                        if (!string.IsNullOrEmpty(item))
                        {
                            //上传图片
                            var result = SaveDBbyFileInfo(stPLC_MesData.BarcodeSet, stationCode, stationName,
                                a1Result, item, uuid).Result;
                            OnMessage(LogType.Error, $"【文件上传】 产品码 [{sn}] " + result.Item2);
                        }
                    }
                }

                #endregion


                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, "", paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                string strScrewHeights = FloatArrayToString(stPLC_MesData.mesData.fScrewHeights);
                string strScrewResults = ShortArrayToString(stPLC_MesData.mesData.nScrewResults);
                message = SQLHelper.InsertOp80Data(CarrierBarcode, sn, strScrewHeights, strScrewResults);
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        private void S8节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a8OEEType"]).ToString(); // 节拍类型(plc写入)
                string a80EEPartNo = (string)s1PLCData["a80EEPartNo"]; // 物料码
                a80EEPartNo = a80EEPartNo.Replace("\0", "");
                string a80EEVehicleCode = (string)s1PLCData["a80EEVehicleCode"]; // 载具SN
                a80EEVehicleCode = a80EEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" +
                        stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a80EEPartNo) && string.IsNullOrEmpty(a80EEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a80EEVehicleCode}][{a80EEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a80EEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a80EEVehicleCode}][{a80EEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a80EEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a80EEVehicleCode}][{a80EEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result =
                    SaveOEEData(plcNo, stationNameStr, deviceOEE, a80EEPartNo, a80EEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #region S9

        private Dictionary<string, object> s9PLCData = new Dictionary<string, object>();
        private Dictionary<string, object> s9PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// [S9] 下料设备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void ReadStation_S9(int plcNo)
        {
            string stationCode = "[OP100]";
            string stationName = "半成品下料";
            string stationNameStr = stationCode + stationName;
            string tagBaseName = "g_OP90_MES"; //标签变量名称
            string tagMesCommName = "mesCommToPC"; //标签变量名称
            string tagAgvCommName = "agvCommFrmPC";
            string tagiotComnName = "iotData";
            string tagBarsetName = "BarcodeSet";

            string CarrierBarcode = "";

            // 触发信号字典
            //s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
            s9PLCSignal_Old.Add("a9OEEType", 0); // 节拍类型(plc写入) 

            // PLC数据字典 赋值 
            s9PLCData.Add("a9OEEType", 0); // 节拍类型(plc写入) 

            OP90_MesData_t stPLC_MesData; //PLC的MES数据
            (int, string) result;

            while (true)
            {
                try
                {
                    if (!GlobalContext._IsCon_Funs1)
                    {
                        UpdatePLCMonitor(1, plcNo, 0);
                        continue;
                    }

                    if (FunsEip[plcNo].IsConnected) // 检查PLC是否已连接上
                    {
                        Stopwatch stopwatch1 = new Stopwatch();
                        Stopwatch stopwatch2 = new Stopwatch();
                        stopwatch1.Start();

                        stopwatch2.Start();

                        #region 一次性读取所有数据

                        // 一次性读取所有数据
                        result = FunsEip[plcNo]
                            .Read_SingleTag<OP90_MesData_t>(tagBaseName, 1, out stPLC_MesData, this); //读取单个结构体数据
                        if (result.Item1 != 0)
                        {
                            //richTextBox1.AppendText("\n" + strRet);
                        }
                        else
                        {
                            //去除扫码产生的特殊字符
                            stPLC_MesData.BarcodeSet.strProductBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strProductBarcode);
                            stPLC_MesData.BarcodeSet.strPartBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPartBarcode);
                            stPLC_MesData.BarcodeSet.strCarrierBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strCarrierBarcode);
                            stPLC_MesData.BarcodeSet.strPCBBarcode =
                                FormatStrbyPLC(stPLC_MesData.BarcodeSet.strPCBBarcode);
                            //richTextBox1.AppendText("\n" + "读取成功");
                            int xmDeviceStateInt = stPLC_MesData.iotData.machineState;
                            xmDeviceStateData.left = (xmDeviceStateInt < 0 || xmDeviceStateInt > 7)
                                ? XiaomiDeviceState.Unknown
                                : (XiaomiDeviceState)xmDeviceStateInt;

                            CarrierBarcode = stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具SN
                            s9PLCData["a9OEEType"] = stPLC_MesData.iotData.BeatAction; // 节拍
                            //报警信息
                            _FaultDatas = stPLC_MesData.iotData.fault_codes;
                        }

                        #endregion 一次性读取所有数据

                        stopwatch2.Stop();

                        #region 进站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.InStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        uuid = Guid.NewGuid().ToString(); //创建贯穿进出站的uuid
                                        ProgressState = true;
                                        Task.Run(() => S9进站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, tagBaseName + "." + tagBarsetName,
                                            out ProgressState));
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 进站

                        #region 出站

                        try
                        {
                            if (stPLC_MesData.mesCommFrmPLC.cmd == (byte)eMesCmd.OutStation)
                            {
                                lock (lockObj)
                                {
                                    if (!ProgressState)
                                    {
                                        ProgressState = true;
                                        Task.Run(() => S9出站(plcNo, stationNameStr, stPLC_MesData,
                                            tagBaseName + "." + tagMesCommName, stationCode, stationName,
                                            out ProgressState));
                                        stPLC_MesData.mesCommFrmPLC.cmd = 0;
                                        uuid = "";
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ProgressState = false;
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上料进站出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion 出站


                        #region 节拍接口

                        try
                        {
                            if (stPLC_MesData.iotData.BeatAction > 0)
                            {
                                int a9OEEType = Convert.ToInt32(s9PLCData["a9OEEType"]);
                                int a9OEETypeGOld = Convert.ToInt32(s9PLCSignal_Old["a9OEEType"]);
                                //若设备紧急复原后节拍重置
                                if (a9OEEType == 1)
                                {
                                    a9OEETypeGOld = 0;
                                }

                                if (a9OEEType != a9OEETypeGOld)
                                {
                                    //如果上位机告诉PLC NG，PLC节拍会直接从1跳到4
                                    if (a9OEETypeGOld <= 2 && a9OEEType == 4)
                                    {
                                        Task.Run(() =>
                                            通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                CarrierBarcode,
                                                stPLC_MesData.iotData));
                                    }
                                    else
                                    {
                                        //节拍需要成双成对，有开始就要有结束，例如有1上料开始就必须有2上料结束
                                        if ((a9OEETypeGOld == 1 && a9OEEType != 2) ||
                                            (a9OEETypeGOld == 3 && a9OEEType != 4) ||
                                            (a9OEETypeGOld == 5 && a9OEEType != 6))
                                        {
                                            //写入PLC
                                            IoT_DataSet_t iotData = new IoT_DataSet_t();
                                            iotData.machineState = stPLC_MesData.iotData.machineState;
                                            iotData.work_type = stPLC_MesData.iotData.work_type;
                                            iotData.testStatus = stPLC_MesData.iotData.testStatus;
                                            iotData.BeatAction = stPLC_MesData.iotData.BeatAction;
                                            iotData.beatReturn = 2; //NG
                                            iotData.fault_codes = stPLC_MesData.iotData.fault_codes;
                                            WriteResultToPlc(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                1, iotData);
                                            AddMessage(LogType.Info,
                                                stationNameStr +
                                                $"_节拍接口-- 设备本次上传节拍[{a9OEEType}]，未上传节拍[{a9OEETypeGOld}]的结束信号，请检查;总用时" +
                                                stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                                                stopwatch2.ElapsedMilliseconds +
                                                "ms");
                                            return;
                                        }
                                        else
                                        {
                                            Task.Run(() =>
                                                通用节拍接口(plcNo, stationNameStr, tagBaseName + "." + tagiotComnName,
                                                    CarrierBarcode,
                                                    stPLC_MesData.iotData));
                                            //Task.Run(() =>
                                            //    S9节拍接口(plcNo, stationNameStr, tagBaseName,
                                            //        stPLC_MesData.iotData)); 
                                        }
                                    }
                                }
                            }

                            s9PLCSignal_Old["a9OEEType"] = s9PLCData["a9OEEType"];
                        }
                        catch (Exception ex)
                        {
                            string str = ex.StackTrace;
                            AddMessage_Station(stationNameStr, LogType.Error,
                                $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" +
                                str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                        }

                        #endregion

                        UpdatePLCMonitor(1, plcNo, 1); // 更新PLC状态的UI  // 更新PLC状态的UI

                        stopwatch1.Stop();
                        //OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
                    }
                    else
                    {
                        UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                        AddMessage_Station(stationNameStr, LogType.Info,
                            "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

                        FunsEip[plcNo].Connect(); // 重连
                    }
                }
                catch (Exception ex)
                {
                    UpdatePLCMonitor(1, plcNo, 0); // 更新PLC状态的UI
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
                }

                Thread.Sleep(IntervalReadPLC);
            }
        }


        /// <summary>
        /// [S9] 下料设备 - 进站
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        /// <param name="stPLC_MesData"></param>
        /// <param name="tagMesCommName"></param>
        private void S9进站(int plcNo, string stationNameStr, OP90_MesData_t stPLC_MesData, string tagMesCommName,
            string tagBarsetName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_进站开始");
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品SN（物料码）
                string MachineId = GlobalContext.S9_MachineId; // 装备ID（可配置）
                string StationId = GlobalContext.S9_StationId; // 工位ID（可配置）
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;
                string strCarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 产品SN（物料码）
                //载具码验证产品码 
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{strCarrierBarcode};产品码:{sn}");

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, MachineId, StationId, pass, "01-SLOT-01");
                stopwatch2.Stop();

                //指令执行结果 1:OK   110:失败
                byte mesResultFrmWeb = (byte)(result == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_进站检测结果:FAIL");
                }

                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1,
                        str.Length - str.LastIndexOf("\\") - 1));

                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info, stationNameStr + "_进站结束");
            AddMessage(LogType.Info,
                stationNameStr + "_进站;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }


        /// <summary>
        /// [S9] 下料设备 - 出站接口
        /// </summary>
        private void S9出站(int plcNo, string stationNameStr, OP90_MesData_t stPLC_MesData, string tagMesCommName,
            string stationCode, string stationName, out bool ProgressState)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            test_item_num = 0; //iot 过站明细序号

            try
            {
                stopwatch1.Start();
                AddMessage(LogType.Info, stationNameStr + "_出站开始");
                string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
                string processItem = stationName; // 测试项目
                string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");
                string supplierCode = ""; // 供应商代码
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                string batch_num = GlobalContext.BatchNumber; // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                string sn = (string)stPLC_MesData.BarcodeSet.strProductBarcode; // 产品条码;
                string CarrierBarcode = (string)stPLC_MesData.BarcodeSet.strCarrierBarcode; // 载具条码;
                string MachineId = GlobalContext.S9_MachineId; // 装备id（可配置）  // ZS
                string StationId = GlobalContext.S9_StationId; // ⼯位ID（可配置）  // ZS
                int a1Result = (int)stPLC_MesData.iotData.testStatus; // 产品结果
                bool pass = a1Result == 1;

                //根据载具码获取产品码
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode);
                if (string.IsNullOrEmpty(strProductBarcode))
                {
                    AddMessage(LogType.Error, $"{stationNameStr}_数据库未查询到该载具绑定信息！");
                }

                sn = strProductBarcode;
                AddMessage(LogType.Info, $"载具码:{CarrierBarcode};产品码:{sn}");

                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = CarrierBarcode,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                string paramJson = JsonConvert.SerializeObject(stPLC_MesData.mesData);
                int result1 = SwitctProcessData(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, batch_num, mtltmrk, plcDate_YMD, supplierCode, sn, pass, CarrierBarcode, "1",
                    MachineId, StationId, "", paramJson);

                byte mesResultFrmWeb = (byte)(result1 == 1 ? 1 : 110);
                if (mesResultFrmWeb == 1)
                {
                    mesResultFrmWeb = (byte)(a1Result == 1 ? 1 : 110); //检测NG
                    AddMessage(LogType.Info, stationNameStr + "_出站PLC检测结果:FAIL");
                }

                stopwatch2.Start();
                //进站结果写入PLC
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = mesResultFrmWeb;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();
                AddMessage(LogType.Info, stationNameStr + "_出站结束");

                //保存PLC返回MES数据到本地
                ResponseMessage message = new ResponseMessage();
                message = SQLHelper.InsertOp90Data(CarrierBarcode, sn, stPLC_MesData.mesData.nThrowCount,
                    stPLC_MesData.mesData.nRemainCount);
                if (message.result == false)
                {
                    AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地失败");
                }

                AddMessage(LogType.Info, stationNameStr + "_保存加工数据到本地成功");

                if (result1 == 1)
                {
                    //载具码解除绑定
                    message = SQLHelper.DelCarrierBind(CarrierBarcode);
                    if (message.result == false)
                    {
                        AddMessage(LogType.Error, message.text);
                    }
                }
            }
            catch (Exception ex)
            {
                stopwatch2.Start();
                CommandFromPLC resultToPlC = new CommandFromPLC();
                resultToPlC.cmd = 0;
                resultToPlC.cmdParam = 0; //指令参数
                resultToPlC.cmdResult = 110;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, resultToPlC);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage(LogType.Error,
                    $"{stationNameStr}_上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
            ProgressState = false;
        }

        private void S9节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a9OEEType"]).ToString(); // 节拍类型(plc写入)
                string a90EEPartNo = (string)s1PLCData["a90EEPartNo"]; // 物料码
                a90EEPartNo = a90EEPartNo.Replace("\0", "");
                string a90EEVehicleCode = (string)s1PLCData["a90EEVehicleCode"]; // 载具SN
                a90EEVehicleCode = a90EEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a90EEPartNo) && string.IsNullOrEmpty(a90EEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a90EEVehicleCode}][{a90EEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a90EEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a90EEVehicleCode}][{a90EEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a90EEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a90EEVehicleCode}][{a90EEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a90EEPartNo, a90EEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion

        #endregion Xiaomi

        #region PLC1 张超凡

        #region [S1] Tray盘上料装备（板测）

        /// <summary>
        /// S1工位的数据- 触发信号上次的值
        /// </summary>
        private Dictionary<string, object> s1PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// S1工位的数据（含触发信号）
        /// </summary>
        private Dictionary<string, object> s1PLCData = new Dictionary<string, object>();

        /// <summary>
        /// S1工位的数据- 回写点位
        /// </summary>
        private Dictionary<string, WriteToPLC_Flag> s1PLCWriteData = new Dictionary<string, WriteToPLC_Flag>();

        ///// <summary>
        ///// 触发信号
        ///// </summary>
        //private ManualResetEvent[] MreTasks;

        /// <summary>
        /// [S1] Tray盘上料装备（板测）
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        //private void ReadStation_S1(int plcNo)
        //{
        //    // [S1] Tray盘上料装备
        //    // [S2] FCT
        //    // [S3] 值板机
        //    // [S4_1] 载具下线装备 [S4_5] 载具上线装备
        //    // [S5] Tray盘下料装备
        //    string stationCode = "[S1]";
        //    string stationName = "Tray盘上料装备";
        //    string stationNameStr = stationCode + stationName;

        //    #region 创建字典 - 赛米可以放在while中，add前查询下存不存在，存在就赋值不存在就add
        //    // 触发信号字典 赋值 - 赛米可以放在while中，add前查询下存不存在，存在就赋值不存在就add
        //    s1PLCSignal_Old.Add("a1PLC_FLAG_VehicleStates", 0);  // PLC_FLAG 载具进站查询状态
        //    s1PLCSignal_Old.Add("a1PLC_FLAG_Check", 0);          // PLC_FLAG 上料进站校验
        //    s1PLCSignal_Old.Add("a1PLC_FLAG", 0);                // PLC_FLAG 出站接口
        //    s1PLCSignal_Old.Add("a1PLC_FLAG_ICT", 0);            // PLC_FLAG 将SN发给ICT标机（串口）
        //    s1PLCSignal_Old.Add("a1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
        //    s1PLCSignal_Old.Add("a1AGVUpCall", 0);               // AGV上料叫agv信号 AGV上料
        //    s1PLCSignal_Old.Add("a1AGVUpEnd", 0);                // AGV上料完成信号 AGV上料
        //    s1PLCSignal_Old.Add("a1AGVDownCall", 0);             // AGV下料叫agv信号 AGV下料
        //    s1PLCSignal_Old.Add("a1AGVDownEnd", 0);              // AGV下料完成信号 AGV下料

        //    // PLC数据字典 赋值 - 赛米可以放在while中，add前查询下存不存在，存在就赋值不存在就add
        //    s1PLCData.Add("a1PLC_FLAG_VehicleStates", 0);    // PLC_FLAG 载具进站查询状态
        //    s1PLCData.Add("a1MES_FLAG_VehicleStates", 0);    // MES_FLAG
        //    s1PLCData.Add("a1ProductSN_VehicleStates", "");  // 产品SN（载具码）
        //    s1PLCData.Add("a1PLC_FLAG_Check", 0);    // PLC_FLAG 上料进站校验
        //    s1PLCData.Add("a1MES_FLAG_Check", 0);    // MES_FLAG
        //    s1PLCData.Add("a1ProductSN_Check", "");  // 产品SN（物料码）
        //    s1PLCData.Add("a1PLC_FLAG", 0);      // PLC_FLAG 出站接口
        //    s1PLCData.Add("a1MES_FLAG", 0);      // MES_FLAG
        //    s1PLCData.Add("a1ProductSN", "");    // 产品SN（载具SN）
        //    s1PLCData.Add("a1PartNo1", "");      // 物料码1（穴位1）
        //    s1PLCData.Add("a1PartNo2", "");      // 物料码2（穴位2）
        //    s1PLCData.Add("a1Result", 0);        // 产品结果
        //    s1PLCData.Add("a1PLC_FLAG_ICT", 0);    // PLC_FLAG 将SN发给ICT标机（串口）
        //    s1PLCData.Add("a1MES_FLAG_ICT", 0);    // MES_FLAG
        //    s1PLCData.Add("a1ProductSN_ICT", "");  // 产品SN（载具SN）
        //    s1PLCData.Add("a1PartNo1_ICT", "");    // 物料码1（穴位1）
        //    s1PLCData.Add("a1PartNo2_ICT", "");    // 物料码2（穴位2）
        //    s1PLCData.Add("a1OEEPLC_FLAG", 0);      // PLC_FLAG 节拍接口
        //    s1PLCData.Add("a1OEEMES_FLAG", 0);      // MES_FLAG
        //    s1PLCData.Add("a1OEEPartNo", "");       // 物料码（物料码还未绑定载具SN时必填）
        //    s1PLCData.Add("a1OEEVehicleCode", "");  // 载具SN
        //    s1PLCData.Add("a1OEEPartNum", 0);       // 穴位号
        //    s1PLCData.Add("a1OEEType", 0);          // 节拍类型(plc写入) 
        //    s1PLCData.Add("a1AGVUpCall", 0);   // AGV上料叫agv信号 AGV上料
        //    s1PLCData.Add("a1AGVUpStart", 0);  // AGV上料开始信号
        //    s1PLCData.Add("a1AGVUpEnd", 0);    // AGV上料完成信号
        //    s1PLCData.Add("a1AGVDownCall", 0);   // AGV下料叫agv信号 AGV下料
        //    s1PLCData.Add("a1AGVDownStart", 0);  // AGV下料开始信号
        //    s1PLCData.Add("a1AGVDownEnd", 0);    // AGV下料完成信号
        //    #endregion 创建字典 - 赛米可以放在while中，add前查询下存不存在，存在就赋值不存在就add

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs1)
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);
        //                continue;
        //            }
        //            if (Funs[plcNo].IsConnected)  // 检查PLC是否已连接上
        //            {
        //                Stopwatch stopwatch1 = new Stopwatch();
        //                Stopwatch stopwatch2 = new Stopwatch();
        //                stopwatch1.Start();

        //                stopwatch2.Start();

        //                #region 一次性读取所有数据
        //                // 一次性读取所有数据
        //                int[] data1 = Funs[plcNo].ReadHoldingRegisters(2000, 100);
        //                int[] data2 = Funs[plcNo].ReadHoldingRegisters(2100, 100);
        //                int[] data3 = Funs[plcNo].ReadHoldingRegisters(2200, 100);
        //                int[] data4 = Funs[plcNo].ReadHoldingRegisters(2300, 33);
        //                int[] datas = data1.Concat(data2).ToArray();
        //                datas = datas.Concat(data3).ToArray();
        //                datas = datas.Concat(data4).ToArray();

        //                s1PLCData["a1PLC_FLAG_VehicleStates"] = datas[2];  // 载具进站查询状态
        //                s1PLCData["a1MES_FLAG_VehicleStates"] = datas[3];
        //                int[] a1ProductSN_VehicleStatesData = datas.Skip(4).Take(20).ToArray();
        //                s1PLCData["a1ProductSN_VehicleStates"] = ModbusClient.ConvertRegistersToString(a1ProductSN_VehicleStatesData, 0, 40);
        //                s1PLCData["a1PLC_FLAG_Check"] = datas[76];  // 上料进站校验
        //                s1PLCData["a1MES_FLAG_Check"] = datas[77];
        //                int[] a1ProductSN_CheckData = datas.Skip(78).Take(20).ToArray();
        //                s1PLCData["a1ProductSN_Check"] = ModbusClient.ConvertRegistersToString(a1ProductSN_CheckData, 0, 40);

        //                s1PLCData["a1PLC_FLAG"] = datas[108];  // 出站接口
        //                s1PLCData["a1MES_FLAG"] = datas[109];
        //                int[] a1ProductSNData = datas.Skip(110).Take(20).ToArray();
        //                s1PLCData["a1ProductSN"] = ModbusClient.ConvertRegistersToString(a1ProductSNData, 0, 40);
        //                int[] a1PartNo1Data = datas.Skip(130).Take(20).ToArray();
        //                s1PLCData["a1PartNo1"] = ModbusClient.ConvertRegistersToString(a1PartNo1Data, 0, 40);
        //                int[] a1PartNo2Data = datas.Skip(150).Take(20).ToArray();
        //                s1PLCData["a1PartNo2"] = ModbusClient.ConvertRegistersToString(a1PartNo2Data, 0, 40);
        //                s1PLCData["a1Result"] = datas[170];

        //                s1PLCData["a1PLC_FLAG_ICT"] = datas[181];  // 将SN发给ICT标机（串口）
        //                s1PLCData["a1MES_FLAG_ICT"] = datas[182];
        //                int[] a1ProductSN_ICTData = datas.Skip(183).Take(20).ToArray();
        //                s1PLCData["a1ProductSN_ICT"] = ModbusClient.ConvertRegistersToString(a1ProductSN_ICTData, 0, 40);
        //                int[] a1PartNo1_ICTData = datas.Skip(203).Take(20).ToArray();
        //                s1PLCData["a1PartNo1_ICT"] = ModbusClient.ConvertRegistersToString(a1PartNo1_ICTData, 0, 40);
        //                int[] a1PartNo2_ICTData = datas.Skip(223).Take(20).ToArray();
        //                s1PLCData["a1PartNo2_ICT"] = ModbusClient.ConvertRegistersToString(a1PartNo2_ICTData, 0, 40);

        //                s1PLCData["a1OEEPLC_FLAG"] = datas[253];  // 节拍接口
        //                s1PLCData["a1OEEMES_FLAG"] = datas[254];
        //                int[] a1OEEPartNoData = datas.Skip(255).Take(20).ToArray();
        //                s1PLCData["a1OEEPartNo"] = ModbusClient.ConvertRegistersToString(a1OEEPartNoData, 0, 40);  // 物料码（物料码还未绑定载具SN时必填）
        //                int[] a1OEEVehicleCodeData = datas.Skip(275).Take(20).ToArray();
        //                s1PLCData["a1OEEVehicleCode"] = ModbusClient.ConvertRegistersToString(a1OEEVehicleCodeData, 0, 40);  // 载具SN
        //                s1PLCData["a1OEEPartNum"] = datas[295];      // 穴位号
        //                s1PLCData["a1OEEType"] = datas[296];         // 节拍类型(plc写入) 

        //                s1PLCData["a1AGVUpCall"] = datas[307];     // AGV上料
        //                s1PLCData["a1AGVUpStart"] = datas[308];
        //                s1PLCData["a1AGVUpEnd"] = datas[309];

        //                s1PLCData["a1AGVDownCall"] = datas[320];  // AGV下料
        //                s1PLCData["a1AGVDownStart"] = datas[321];
        //                s1PLCData["a1AGVDownEnd"] = datas[322];
        //                #endregion 一次性读取所有数据
        //                stopwatch2.Stop();

        //                #region 回写操作，写后清空flag
        //                PLCWriteData(Funs[plcNo], ref s1PLCData, ref s1PLCWriteData);
        //                #endregion 回写操作，写后清空flag

        //                #region 载具进站查询状态（有假产品的拿下来，有产品的穴位不放产品）
        //                try
        //                {
        //                    int a1PLC_FLAG_VehicleStates = (int)s1PLCData["a1PLC_FLAG_VehicleStates"];
        //                    int a1MES_FLAG_VehicleStates = (int)s1PLCData["a1MES_FLAG_VehicleStates"];
        //                    int a1PLC_FLAG_VehicleStatesOld = (int)s1PLCSignal_Old["a1PLC_FLAG_VehicleStates"];
        //                    if (a1PLC_FLAG_VehicleStates != a1PLC_FLAG_VehicleStatesOld)
        //                    {
        //                        if (a1PLC_FLAG_VehicleStates == 1 && a1MES_FLAG_VehicleStates == 0)  // 0->1
        //                            Task.Run(() => S1载具进站查询状态(plcNo, stationNameStr));  // MreTasks[1].Set();
        //                        else if (a1PLC_FLAG_VehicleStates == 0 && a1MES_FLAG_VehicleStates != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)0);

        //                        s1PLCSignal_Old["a1PLC_FLAG_VehicleStates"] = s1PLCData["a1PLC_FLAG_VehicleStates"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    // 6代表上位机报警
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 载具进站查询状态出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 载具进站查询状态（有假产品的拿下来，有产品的穴位不放产品）

        //                #region 上料进站校验
        //                try
        //                {
        //                    int a1PLC_FLAG_Check = (int)s1PLCData["a1PLC_FLAG_Check"];
        //                    int a1MES_FLAG_Check = (int)s1PLCData["a1MES_FLAG_Check"];
        //                    int a1PLC_FLAG_CheckOld = (int)s1PLCSignal_Old["a1PLC_FLAG_Check"];
        //                    if (a1PLC_FLAG_Check != a1PLC_FLAG_CheckOld)
        //                    {
        //                        if (a1PLC_FLAG_Check == 1 && a1MES_FLAG_Check == 0)  // 0->1
        //                            Task.Run(() => S1上料进站校验(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (a1PLC_FLAG_Check == 0 && a1MES_FLAG_Check != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)0);

        //                        s1PLCSignal_Old["a1PLC_FLAG_Check"] = s1PLCData["a1PLC_FLAG_Check"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 上料进站校验

        //                #region Tray盘上料装备-出站接口
        //                try
        //                {
        //                    int a1PLC_FLAG = (int)s1PLCData["a1PLC_FLAG"];
        //                    int a1MES_FLAG = (int)s1PLCData["a1MES_FLAG"];
        //                    int a1PLC_FLAGOld = (int)s1PLCSignal_Old["a1PLC_FLAG"];
        //                    if (a1PLC_FLAG != a1PLC_FLAGOld)
        //                    {
        //                        if (a1PLC_FLAG == 1 && a1MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S1出站接口(plcNo, stationCode, stationName));  // MreTasks[3].Set();
        //                        else if (a1PLC_FLAG == 0 && a1MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2109, (short)0);

        //                        s1PLCSignal_Old["a1PLC_FLAG"] = s1PLCData["a1PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2109, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传出站数据出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion Tray盘上料装备-出站接口

        //                #region Tray盘上料装备-将SN发给ICT标机
        //                try
        //                {
        //                    int a1PLC_FLAG_ICT = (int)s1PLCData["a1PLC_FLAG_ICT"];
        //                    int a1MES_FLAG_ICT = (int)s1PLCData["a1MES_FLAG_ICT"];
        //                    int a1PLC_FLAG_ICTOld = (int)s1PLCSignal_Old["a1PLC_FLAG_ICT"];
        //                    if (a1PLC_FLAG_ICT != a1PLC_FLAG_ICTOld)
        //                    {
        //                        if (a1PLC_FLAG_ICT == 1 && a1MES_FLAG_ICT == 0)  // 0->1
        //                            Task.Run(() => S1将SN发给ICT标机(plcNo, stationNameStr));  // MreTasks[3].Set();
        //                        else if (a1PLC_FLAG_ICT == 0 && a1MES_FLAG_ICT != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2182, (short)0);

        //                        s1PLCSignal_Old["a1PLC_FLAG_ICT"] = s1PLCData["a1PLC_FLAG_ICT"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2182, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 将SN发给ICT标机出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion Tray盘上料装备-将SN发给ICT标机

        //                #region Tray盘上料装备-点检数据
        //                //try
        //                //{
        //                //    Funs[plcNo].Read_Int_Tag("828", 1, out short[] iPLC_Flag);  // PLC_Flag
        //                //    Funs[plcNo].Read_Int_Tag("829", 1, out short[] iMES_Flag);  // MES_Flag
        //                //    bool pLC_Flag = iPLC_Flag[0] == 1 ? true : false;  // PLC_Flag
        //                //    bool mES_Flag = iMES_Flag[0] == 1 ? true : false;  // MES_Flag

        //                //    if (pLC_Flag && !mES_Flag)  // 1 0
        //                //    {
        //                //        AddMessage_Station(stationNameStr, LogType.Info, Head + stationNameStr + BodyCheck);
        //                //        await Task.Run(() => { DoOneCheckData_Tray盘上料装备(plcNo, stationCode, stationName); });
        //                //        AddMessage_Station(stationNameStr, LogType.Info, stationNameStr + BodyCheck + Tail);
        //                //    }
        //                //    else if (!pLC_Flag && mES_Flag)  // 0 1
        //                //    {
        //                //        // 清空写给PLC的数据
        //                //        // MES_Flag重置为0
        //                //        Funs[plcNo].Write_DInt_Tag("829", 1, new Int32[1] { 0 });
        //                //    }
        //                //}
        //                //catch (Exception ex)
        //                //{
        //                //    // MES_Flag 为2上位机报错
        //                //    Funs[plcNo].Write_DInt_Tag("829", 1, new Int32[1] { 2 });

        //                //    string str = ex.StackTrace;
        //                //    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}点检运行出错！错误信息：" + ex.Message + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                //}
        //                #endregion Tray盘上料装备-点检数据

        //                #region 节拍接口
        //                try
        //                {
        //                    int a1OEEPLC_FLAG = (int)s1PLCData["a1OEEPLC_FLAG"];
        //                    int a1OEEMES_FLAG = (int)s1PLCData["a1OEEMES_FLAG"];
        //                    int a1OEEPLC_FLAGOld = (int)s1PLCSignal_Old["a1OEEPLC_FLAG"];
        //                    if (a1OEEPLC_FLAG != a1OEEPLC_FLAGOld)
        //                    {
        //                        if (a1OEEPLC_FLAG == 1 && a1OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S1节拍接口(plcNo, stationNameStr));  // MreTasks[4].Set();
        //                        else if (a1OEEPLC_FLAG == 0 && a1OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2254, (short)0);  // 

        //                        s1PLCSignal_Old["a1OEEPLC_FLAG"] = s1PLCData["a1OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2254, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 节拍接口

        //                #region AGV上料
        //                // AGV上料叫AGV信号
        //                try
        //                {
        //                    int a1AGVUpCall = (int)s1PLCData["a1AGVUpCall"];
        //                    int a1AGVUpCallOld = (int)s1PLCSignal_Old["a1AGVUpCall"];
        //                    if (a1AGVUpCall != a1AGVUpCallOld)
        //                    {
        //                        if (a1AGVUpCall == 1)  // 0->1
        //                            Task.Run(() => S1AGV上料叫agv(plcNo, stationNameStr));  // MreTasks[5].Set();

        //                        s1PLCSignal_Old["a1AGVUpCall"] = s1PLCData["a1AGVUpCall"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2307, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV上料叫agv出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                // AGV上料完成信号
        //                try
        //                {
        //                    int a1AGVUpEnd = (int)s1PLCData["a1AGVUpEnd"];
        //                    int a1AGVUpEndOld = (int)s1PLCSignal_Old["a1AGVUpEnd"];
        //                    if (a1AGVUpEnd != a1AGVUpEndOld)
        //                    {
        //                        if (a1AGVUpEnd == 1)  // 0->1
        //                            Task.Run(() => S1AGV上料完成(plcNo, stationNameStr));  // MreTasks[6].Set();

        //                        s1PLCSignal_Old["a1AGVUpEnd"] = s1PLCData["a1AGVUpEnd"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2309, (short)4);  // 4代表上位机报警
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV上料完成信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion AGV上料

        //                #region AGV下料
        //                // AGV下料叫agv信号
        //                try
        //                {
        //                    int a1AGVDownCall = (int)s1PLCData["a1AGVDownCall"];
        //                    int a1AGVDownCallOld = (int)s1PLCSignal_Old["a1AGVDownCall"];
        //                    if (a1AGVDownCall != a1AGVDownCallOld)
        //                    {
        //                        if (a1AGVDownCall == 1)  // 0->1
        //                            Task.Run(() => S1AGV下料叫agv(plcNo, stationNameStr));  // MreTasks[7].Set();

        //                        s1PLCSignal_Old["a1AGVDownCall"] = s1PLCData["a1AGVDownCall"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2320, (short)4);  // 4代表上位机报警
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV下料叫agv信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                // AGV下料完成信号
        //                try
        //                {
        //                    int a1AGVDownEnd = (int)s1PLCData["a1AGVDownEnd"];
        //                    int a1AGVDownEndOld = (int)s1PLCSignal_Old["a1AGVDownEnd"];
        //                    if (a1AGVDownEnd != a1AGVDownEndOld)
        //                    {
        //                        if (a1AGVDownEnd == 1)  // 0->1
        //                            Task.Run(() => S1AGV下料完成(plcNo, stationNameStr));  // MreTasks[8].Set();

        //                        s1PLCSignal_Old["a1AGVDownEnd"] = s1PLCData["a1AGVDownEnd"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2322, (short)4);  // 4代表上位机报警
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV下料完成信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion AGV下料

        //                #region 心跳
        //                try
        //                {
        //                    short states = 0;
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2000, states);
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上位机心跳写入出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 心跳

        //                UpdatePLCMonitor(1, plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI

        //                stopwatch1.Stop();
        //                //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
        //                OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

        //                Funs[plcNo].Connect();  // 重连
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());

        //            Funs[plcNo].ReConnect();
        //        }

        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- 载具进站查询状态
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1载具进站查询状态(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                string sn = (string)s1PLCData["a1ProductSN_VehicleStates"]; // 产品SN（载具码）
                sn = sn.Replace("\0", "");

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "a1MES_FLAG_VehicleStates";
                    writeToPLC_Flag1.Adress = 2003;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_VehicleStates", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_载具进站查询状态失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms");
                    return;
                }

                #endregion 查询载具上的产品信息

                string[] cavitySNs = cavityData.Split('.');
                string a1CavitySN1_VehicleStates = ""; // 穴位1物料SN(上位机写入)
                string a1CavitySN2_VehicleStates = ""; // 穴位2物料SN(上位机写入)
                short a1CavityResult1_VehicleStates = 1; // 1空；2ng；3假产品；
                short a1CavityResult2_VehicleStates = 1; // 1空；2ng；3假产品；
                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    a1CavitySN1_VehicleStates = cavitySNs[0];
                    a1CavitySN2_VehicleStates = cavitySNs[1];
                    a1CavityResult1_VehicleStates = 2;
                    a1CavityResult2_VehicleStates = 2;
                }

                if (a1CavitySN1_VehicleStates == "假产品")
                    a1CavityResult1_VehicleStates = 3;
                if (a1CavitySN2_VehicleStates == "假产品")
                    a1CavityResult2_VehicleStates = 3;

                short mES_Flag = 1; // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警

                // 回写
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2024, a1CavitySN1_VehicleStates, 20);
                //Funs[plcNo].WriteMultipleRegisters<string>(2044, a1CavitySN2_VehicleStates, 20);
                //Funs[plcNo].WriteMultipleRegisters<short>(2064, a1CavityResult1_VehicleStates);
                //Funs[plcNo].WriteMultipleRegisters<short>(2065, a1CavityResult2_VehicleStates);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, mES_Flag);

                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_VehicleStates";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = mES_Flag;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 穴位1物料SN(上位机写入)
                {
                    Name = "a1CavitySN1_VehicleStates",
                    Adress = 2024,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = a1CavitySN1_VehicleStates
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 穴位2物料SN(上位机写入)
                {
                    Name = "a1CavitySN2_VehicleStates",
                    Adress = 2044,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = a1CavitySN2_VehicleStates
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "a1CavityResult1_VehicleStates",
                    Adress = 2064,
                    ValueType = PLCValueType.Short,
                    Value = a1CavityResult1_VehicleStates
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "a1CavityResult2_VehicleStates",
                    Adress = 2065,
                    ValueType = PLCValueType.Short,
                    Value = a1CavityResult2_VehicleStates
                });
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_VehicleStates", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 载具进站查询状态出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_VehicleStates";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_VehicleStates", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_载具进站查询状态;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- 上料进站校验
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1上料进站校验(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                string sn = (string)s1PLCData["a1ProductSN_Check"]; // 产品SN（物料码）
                sn = sn.Replace("\0", "");

                // 保存进站数据+调用进站MES接口
                List<TestItem> item = new List<TestItem>();
                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk, sn,
                    item, out string errorMsg);
                stopwatch2.Stop();
                short a1MES_FLAG_Check = (short)result;

                //Funs[plcNo].WriteMultipleRegisters<short>(2077, a1MES_FLAG_Check);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2077;
                writeToPLC_Flag.Value = a1MES_FLAG_Check;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_Check", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 上料进站校验出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2077;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_Check", writeToPLC_Flag);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_上料进站校验;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- 出站接口
        /// </summary>
        /// <param name="plcNo"></param>
        /// <param name="stationCode"></param>
        /// <param name="stationName"></param>
        private void S1出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s1PLCData["a1ProductSN"]; // 产品SN（载具SN码）
                sn = sn.Replace("\0", "");
                string partNo1 = (string)s1PLCData["a1PartNo1"]; // 物料码1（穴位1）
                partNo1 = partNo1.Replace("\0", "");
                string partNo2 = (string)s1PLCData["a1PartNo2"]; // 物料码2（穴位2）
                partNo2 = partNo2.Replace("\0", "");
                int a1Result = (int)s1PLCData["a1Result"]; // 产品结果
                bool pass = a1Result == 1;

                stopwatch2.Start();
                // 产品1
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "载具穴号",
                    Parameter_value = "1",
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品结果",
                    Parameter_value = a1Result == 1 ? "OK" : "NG",
                    Parameter_unit = ""
                });
                int result1 = SwitctProcessData_old(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, mtltmrk, partNo1, pass, sn, "1");

                // 产品2
                items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "载具穴号",
                    Parameter_value = "2",
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品结果",
                    Parameter_value = a1Result == 1 ? "OK" : "NG",
                    Parameter_unit = ""
                });
                int result2 = SwitctProcessData_old(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, mtltmrk, partNo2, pass, sn, "2");

                short result = 0;
                List<int> results = new List<int>() { result1, result2 };
                if (result1 == 1 && result2 == 1)
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                #region 存储绑定数据到 边线MES系统中

                if (result == 1)
                {
                    string data = string.Concat(partNo1, ".", partNo2);
                    int resultMesR = XiaomiMES_RouteCommunication.SNBindData(sn, data);
                    if (resultMesR != 0)
                    {
                        result = 4;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_[{equipmentCode}]{processItem}过站失败！MES边线程序返回：{resultMesR}");
                    }
                }

                #endregion 存储绑定数据到 边线MES系统中

                // MES_Flag 为MES报错
                // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                //Funs[plcNo].WriteMultipleRegisters<short>(2109, result);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG";
                writeToPLC_Flag.Adress = 2109;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2109, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG";
                writeToPLC_Flag.Adress = 2109;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}上传加工报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }
        //// 上传点检数据_ [S1] Tray盘上料装备（板测）
        //private void DoOneCheckData_Tray盘上料装备(int plcNo, string stationCode, string stationName)
        //{
        //    string equipmentCode = GlobalContext.LineCode + "-" + stationCode;  // 设备编号
        //    string stationNameStr = stationCode + stationName;
        //    string processItem = stationName;  // 测试项目
        //    try
        //    {
        //        string workorder_code = GlobalContext.WorkOrderCode;  // 工单号
        //        string accno = "1";           // 工序编号
        //        Funs[plcNo].Read_Real_Tag("896", 1, out float[] float0);
        //        float travelLimitUp = float0[0];     // 胶圈装配行程设定上限

        //        List<OneCheckItem> items = new List<OneCheckItem>()
        //        {
        //            new OneCheckItem()
        //            {
        //                Onecheck_name="胶圈装配行程设定上限",
        //                Onecheck_content="上限值",
        //                Onecheck_result=$"正常|胶圈装配行程设定上限{travelLimitUp} mm"
        //            },
        //        };
        //        OneCheckData oneCheckData = new OneCheckData()
        //        {
        //            Line_code = GlobalContext.LineCode,
        //            Line_name = GlobalContext.LineName,
        //            Equipment_code = equipmentCode,
        //            Equipment_name = equipmentCode,
        //            Workorder_code = workorder_code,
        //            Procedure_code = accno,
        //            Procedure_name = processItem,
        //            Oneckeck_values = items,
        //            Onecheck_empcode = "",
        //            Onecheck_empname = "",
        //            Onecheck_time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
        //        };
        //        int result1 = SaveOneCheckDataByDBAndSubmit(oneCheckData, equipmentCode, processItem);
        //        //int result = result1 == 1 ? 1 : (GlobalContext.IsSendCheckOneData ? 4 : 1);
        //        short result = result1 == 1 ? (short)1 : (short)2;

        //        // MES_Flag 为4MES报错
        //        Funs[plcNo].Write_DInt_Tag("829", 1, new Int32[1] { result });

        //        WritePLCLog(LogType.Debug, $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
        //    }
        //    catch (Exception ex)
        //    {
        //        // MES_Flag 为2上位机报错
        //        Funs[plcNo].Write_DInt_Tag("829", 1, new Int32[1] { 2 });
        //        string str = ex.StackTrace;
        //        AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_[{equipmentCode}]{processItem}点检报错！错误信息：" + ex.Message.ToString() + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //    }
        //}

        // ReadStation_S1_2 节拍接口+AGV 

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- 将SN发给ICT标机（串口）
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1将SN发给ICT标机(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            try
            {
                stopwatch1.Start();
                string a1ProductSN_ICT = (string)s1PLCData["a1ProductSN_ICT"]; // 产品SN（载具SN）
                a1ProductSN_ICT = a1ProductSN_ICT.Replace("\0", "");
                string a1PartNo1_ICT = (string)s1PLCData["a1PartNo1_ICT"]; // 物料码1（穴位1）
                a1PartNo1_ICT = a1PartNo1_ICT.Replace("\0", "");
                string a1PartNo2_ICT = (string)s1PLCData["a1PartNo2_ICT"]; // 物料码2（穴位2）
                a1PartNo2_ICT = a1PartNo2_ICT.Replace("\0", "");

                // ZS 将SN发给ICT标机（串口）
                short a1MES_FLAG_ICT = 1;

                stopwatch2.Start();
                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2182, a1MES_FLAG_ICT);  // 上位机发送1代表OK；2代表失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_ICT";
                writeToPLC_Flag.Adress = 2182;
                writeToPLC_Flag.Value = a1MES_FLAG_ICT;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_ICT", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 将SN发给ICT标机出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2182, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1MES_FLAG_ICT";
                writeToPLC_Flag.Adress = 2182;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1MES_FLAG_ICT", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_将SN发给ICT标机;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- 节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a1OEEType"]).ToString(); // 节拍类型(plc写入)
                string a1OEEPartNo = (string)s1PLCData["a1OEEPartNo"]; // 物料码
                a1OEEPartNo = a1OEEPartNo.Replace("\0", "");
                string a1OEEVehicleCode = (string)s1PLCData["a1OEEVehicleCode"]; // 载具SN
                a1OEEVehicleCode = a1OEEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a1OEEPartNo) && string.IsNullOrEmpty(a1OEEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a1OEEVehicleCode}][{a1OEEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a1OEEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a1OEEVehicleCode}][{a1OEEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a1OEEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a1OEEVehicleCode}][{a1OEEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a1OEEPartNo, a1OEEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- AGV上料叫agv
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1AGV上料叫agv(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS 呼叫AGV
                short a1AGVUpCall = 2;

                stopwatch2.Start();
                // a1AGVUpCall
                //Funs[plcNo].WriteMultipleRegisters<short>(2307, a1AGVUpCall);  // 1：plc请求上料（plc请求）；10秒响应清证明上位机掉线；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVUpCall";
                writeToPLC_Flag.Adress = 2307;
                writeToPLC_Flag.Value = a1AGVUpCall;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVUpCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV上料叫agv出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // a1AGVUpCall
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2307, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVUpCall";
                writeToPLC_Flag.Adress = 2307;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVUpCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV上料叫agv;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- AGV上料完成
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1AGV上料完成(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS AGV上料完成,让小车离开
                short a1AGVUpEnd = 2;

                stopwatch2.Start();
                // a1AGVUpEnd
                //Funs[plcNo].WriteMultipleRegisters<short>(2309, a1AGVUpEnd);  // 1：plc通知完成结果（plc请求）；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVUpEnd";
                writeToPLC_Flag.Adress = 2309;
                writeToPLC_Flag.Value = a1AGVUpEnd;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVUpEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV上料完成出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // a1AGVUpEnd
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2309, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVUpEnd";
                writeToPLC_Flag.Adress = 2309;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVUpEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV上料完成;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- AGV下料叫agv
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1AGV下料叫agv(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS 呼叫AGV
                short a1AGVDownCall = 2;

                stopwatch2.Start();
                // a1AGVDownCall
                //Funs[plcNo].WriteMultipleRegisters<short>(2320, a1AGVDownCall);  // 1：plc请求下料（plc请求）；10秒响应清证明上位机掉线；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVDownCall";
                writeToPLC_Flag.Adress = 2320;
                writeToPLC_Flag.Value = a1AGVDownCall;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVDownCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV下料叫agv出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // a1AGVDownCall
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2320, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVDownCall";
                writeToPLC_Flag.Adress = 2320;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVDownCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV下料叫agv;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S1] Tray盘上料装备（板测）- AGV下料完成
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S1AGV下料完成(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS AGV上料完成,让小车离开
                short a1AGVDownEnd = 2;

                stopwatch2.Start();
                // a1AGVDownEnd
                //Funs[plcNo].WriteMultipleRegisters<short>(2322, a1AGVDownEnd);  // 1：plc通知完成结果（plc请求）；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVDownEnd";
                writeToPLC_Flag.Adress = 2322;
                writeToPLC_Flag.Value = a1AGVDownEnd;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVDownEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV下料完成出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // a1AGVDownEnd
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2322, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "a1AGVDownEnd";
                writeToPLC_Flag.Adress = 2322;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s1PLCWriteData, "a1AGVDownEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV下料完成;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion [S1] Tray盘上料装备（板测）

        #endregion PLC1 张超凡

        #region PLC2 李晓奇

        #region [S2] FCT（板测）

        /// <summary>
        /// S2工位的数据- 触发信号上次的值
        /// </summary>
        private Dictionary<string, object> s2PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// S2工位的数据（含触发信号）
        /// </summary>
        private Dictionary<string, object> s2PLCData = new Dictionary<string, object>();

        /// <summary>
        /// S2工位的数据- 回写点位
        /// </summary>
        private Dictionary<string, WriteToPLC_Flag> s2PLCWriteData = new Dictionary<string, WriteToPLC_Flag>();

        /// <summary>
        /// [S2] FCT（板测）
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        //private void ReadStation_S2(int plcNo)
        //{
        //    // [S1] Tray盘上料装备
        //    // [S2] FCT
        //    // [S3] 值板机
        //    // [S4_1] 载具下线装备 [S4_5] 载具上线装备
        //    // [S5] Tray盘下料装备
        //    /// 上位机心跳
        //    /// 获取设备报警数据与状态信息
        //    string stationCode = "[S2]";
        //    string stationName = "FCT";
        //    string stationNameStr = stationCode + stationName;

        //    #region 创建字典
        //    // 触发信号字典 赋值
        //    s2PLCSignal_Old.Add("b1PLC_FLAG_Check", 0);   // PLC_FLAG 进站校验
        //    s2PLCSignal_Old.Add("b1PLC_FLAG_Unbind", 0);  // PLC_FLAG 二穴载具解绑/绑定(产品换载具)
        //    s2PLCSignal_Old.Add("b1PLC_FLAG", 0);         // PLC_FLAG 出站接口
        //    s2PLCSignal_Old.Add("b1OEEPLC_FLAG", 0);      // PLC_FLAG 节拍接口

        //    // PLC数据字典 赋值
        //    s2PLCData.Add("b1PLC_FLAG_Check", 0);  // 进站校验   
        //    s2PLCData.Add("b1MES_FLAG_Check", 0);
        //    s2PLCData.Add("b1ProductSN_Check", 0);
        //    s2PLCData.Add("b1PLC_FLAG_Unbind", 0);  // 二穴载具解绑/绑定(产品换载具)
        //    s2PLCData.Add("b1MES_FLAG_Unbind", 0);
        //    s2PLCData.Add("b1ProductSN_Unbind", "");
        //    s2PLCData.Add("b1ProductSN_Bind", "");
        //    s2PLCData.Add("b1Part1SN_Bind", "");
        //    s2PLCData.Add("b1Part2SN_Bind", "");
        //    s2PLCData.Add("b1PLC_FLAG", 0);  // 出站接口
        //    s2PLCData.Add("b1MES_FLAG", 0);
        //    s2PLCData.Add("b1ProductSN", 0);
        //    s2PLCData.Add("b1Part1Result", 0);
        //    s2PLCData.Add("b1Part2Result", 0);
        //    s2PLCData.Add("b1OEEPLC_FLAG", 0);  // 节拍接口
        //    s2PLCData.Add("b1OEEMES_FLAG", 0);
        //    s2PLCData.Add("b1OEEProductSN", "");
        //    s2PLCData.Add("b1OEEType", 0);
        //    #endregion 创建字典

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs2)
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);
        //                continue;
        //            }
        //            if (Funs[plcNo].IsConnected)  // 检查PLC是否已连接上
        //            {
        //                Stopwatch stopwatch1 = new Stopwatch();
        //                Stopwatch stopwatch2 = new Stopwatch();
        //                stopwatch1.Start();

        //                stopwatch2.Start();
        //                #region 一次性读取所有数据
        //                // 一次性读取所有数据
        //                int[] data1 = Funs[plcNo].ReadHoldingRegisters(2000, 100);  // 
        //                int[] data2 = Funs[plcNo].ReadHoldingRegisters(2100, 100);  // 
        //                int[] data3 = Funs[plcNo].ReadHoldingRegisters(2200, 35);   // 
        //                int[] datas = data1.Concat(data2).ToArray();
        //                datas = datas.Concat(data3).ToArray();

        //                s2PLCData["b1PLC_FLAG_Check"] = datas[2];  // 进站校验
        //                s2PLCData["b1MES_FLAG_Check"] = datas[3];
        //                int[] b1ProductSN_CheckData = datas.Skip(4).Take(20).ToArray();
        //                s2PLCData["b1ProductSN_Check"] = ModbusClient.ConvertRegistersToString(b1ProductSN_CheckData, 0, 40);
        //                s2PLCData["b1PLC_FLAG_Unbind"] = datas[76];  // 二穴载具解绑/绑定(产品换载具)
        //                s2PLCData["b1MES_FLAG_Unbind"] = datas[77];
        //                int[] b1ProductSN_UnbindData = datas.Skip(78).Take(20).ToArray();
        //                s2PLCData["b1ProductSN_Unbind"] = ModbusClient.ConvertRegistersToString(b1ProductSN_UnbindData, 0, 40);
        //                int[] b1ProductSN_BindData = datas.Skip(98).Take(20).ToArray();
        //                s2PLCData["b1ProductSN_Bind"] = ModbusClient.ConvertRegistersToString(b1ProductSN_BindData, 0, 40);
        //                int[] b1Part1SN_BindData = datas.Skip(118).Take(20).ToArray();
        //                s2PLCData["b1Part1SN_Bind"] = ModbusClient.ConvertRegistersToString(b1Part1SN_BindData, 0, 40);
        //                int[] b1Part2SN_BindData = datas.Skip(138).Take(20).ToArray();
        //                s2PLCData["b1Part2SN_Bind"] = ModbusClient.ConvertRegistersToString(b1Part2SN_BindData, 0, 40);
        //                s2PLCData["b1PLC_FLAG"] = datas[168];  // 出站接口
        //                s2PLCData["b1MES_FLAG"] = datas[169];
        //                int[] b1ProductSNData = datas.Skip(170).Take(20).ToArray();
        //                s2PLCData["b1ProductSN"] = ModbusClient.ConvertRegistersToString(b1ProductSNData, 0, 40);
        //                s2PLCData["b1Part1Result"] = datas[190];
        //                s2PLCData["b1Part2Result"] = datas[191];
        //                s2PLCData["b1OEEPLC_FLAG"] = datas[202];  // 节拍接口
        //                s2PLCData["b1OEEMES_FLAG"] = datas[203];
        //                int[] b1OEEProductSNData = datas.Skip(204).Take(20).ToArray();
        //                s2PLCData["b1OEEProductSN"] = ModbusClient.ConvertRegistersToString(b1OEEProductSNData, 0, 40);
        //                s2PLCData["b1OEEType"] = datas[224];
        //                #endregion 一次性读取所有数据
        //                stopwatch2.Stop();

        //                #region 回写操作，写后清空flag
        //                PLCWriteData(Funs[plcNo], ref s2PLCData, ref s2PLCWriteData);
        //                #endregion 回写操作，写后清空flag

        //                #region 进站校验
        //                try
        //                {
        //                    int b1PLC_FLAG_Check = (int)s2PLCData["b1PLC_FLAG_Check"];
        //                    int b1MES_FLAG_Check = (int)s2PLCData["b1MES_FLAG_Check"];
        //                    int b1PLC_FLAG_CheckOld = (int)s2PLCSignal_Old["b1PLC_FLAG_Check"];
        //                    if (b1PLC_FLAG_Check != b1PLC_FLAG_CheckOld)
        //                    {
        //                        if (b1PLC_FLAG_Check == 1 && b1MES_FLAG_Check == 0)  // 0->1
        //                            Task.Run(() => S2进站校验(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (b1PLC_FLAG_Check == 0 && b1MES_FLAG_Check != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)0);

        //                        s2PLCSignal_Old["b1PLC_FLAG_Check"] = s2PLCData["b1PLC_FLAG_Check"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 进站校验

        //                #region 二穴载具解绑/绑定(产品换载具)
        //                try
        //                {
        //                    int b1PLC_FLAG_Unbind = (int)s2PLCData["b1PLC_FLAG_Unbind"];
        //                    int b1MES_FLAG_Check = (int)s2PLCData["b1MES_FLAG_Check"];
        //                    int b1PLC_FLAG_UnbindOld = (int)s2PLCSignal_Old["b1PLC_FLAG_Unbind"];
        //                    if (b1PLC_FLAG_Unbind != b1PLC_FLAG_UnbindOld)
        //                    {
        //                        if (b1PLC_FLAG_Unbind == 1 && b1MES_FLAG_Check == 0)  // 0->1
        //                            Task.Run(() => S2二穴载具解绑绑定(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (b1PLC_FLAG_Unbind == 0 && b1MES_FLAG_Check != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)0);

        //                        s2PLCSignal_Old["b1PLC_FLAG_Unbind"] = s2PLCData["b1PLC_FLAG_Unbind"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 二穴载具解绑/绑定出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 二穴载具解绑/绑定(产品换载具)

        //                #region FCT-出站接口
        //                try
        //                {
        //                    int b1PLC_FLAG = (int)s2PLCData["b1PLC_FLAG"];
        //                    int b1MES_FLAG = (int)s2PLCData["b1MES_FLAG"];
        //                    int b1PLC_FLAGOld = (int)s2PLCSignal_Old["b1PLC_FLAG"];
        //                    if (b1PLC_FLAG != b1PLC_FLAGOld)
        //                    {
        //                        if (b1PLC_FLAG == 1 && b1MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S2出站接口(plcNo, stationCode, stationName));  // MreTasks[3].Set();
        //                        else if (b1PLC_FLAG == 0 && b1MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2169, (short)0);
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    // MES_Flag 为6上位机报错
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2169, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}上传出站数据出错！错误信息：" + ex.Message.ToString() + ";异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion FCT-出站接口

        //                #region 节拍接口
        //                try
        //                {
        //                    int b1OEEPLC_FLAG = (int)s2PLCData["b1OEEPLC_FLAG"];
        //                    int b1OEEMES_FLAG = (int)s2PLCData["b1OEEMES_FLAG"];
        //                    int b1OEEPLC_FLAGOld = (int)s2PLCSignal_Old["b1OEEPLC_FLAG"];
        //                    if (b1OEEPLC_FLAG != b1OEEPLC_FLAGOld)
        //                    {
        //                        if (b1OEEPLC_FLAG == 1 && b1OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S2节拍接口(plcNo, stationNameStr));  // MreTasks[4].Set();
        //                        else if (b1OEEPLC_FLAG == 0 && b1OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2203, (short)0);

        //                        s2PLCSignal_Old["b1OEEPLC_FLAG"] = s2PLCData["b1OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2203, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 节拍接口

        //                #region 心跳
        //                try
        //                {
        //                    short states = 0;
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2000, states);
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上位机心跳写入出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 心跳

        //                UpdatePLCMonitor(1, plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI

        //                stopwatch1.Stop();
        //                //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
        //                OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

        //                Funs[plcNo].Connect();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());

        //            Funs[plcNo].ReConnect();
        //        }

        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        /// <summary>
        /// [S2] FCT（板测）- 进站校验
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S2进站校验(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                string sn = (string)s2PLCData["b1ProductSN_Check"]; // 产品SN（载具码）
                sn = sn.Replace("\0", "");

                #region 查询载具上的产品信息(查询物料码By载具码,并判断是不是假产品)

                // 查询物料码By载具码 并判断是不是假产品
                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "b1MES_FLAG_Check";
                    writeToPLC_Flag1.Adress = 2003;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Check", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_进站校验失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                #endregion 查询载具上的产品信息(查询物料码By载具码,并判断是不是假产品)

                string[] cavitySNs = cavityData.Split('.');
                string b1Part1SN_Check = ""; // 穴位1物料SN(上位机写入)
                string b1Part2SN_Check = ""; // 穴位2物料SN(上位机写入)
                short b1Part1Result_Check = 1; // 穴位1产品结果(上位机写入)；1ok;2ng;3假产品
                short b1Part2Result_Check = 1; // 穴位2产品结果(上位机写入)；1ok;2ng;3假产品
                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    b1Part1SN_Check = cavitySNs[0];
                    b1Part2SN_Check = cavitySNs[1];
                    b1Part1Result_Check = 2;
                    b1Part2Result_Check = 2;
                }

                if (b1Part1SN_Check == "假产品")
                    b1Part1Result_Check = 3;
                if (b1Part2SN_Check == "假产品")
                    b1Part2Result_Check = 3;

                // 调用MES进站
                stopwatch2.Start();
                // 调用MES进站 - 产品1
                List<TestItem> item;
                int result1 = b1Part1Result_Check;
                if (result1 != 3)
                {
                    item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = sn,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "1",
                    });
                    result1 = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        b1Part1SN_Check, item, out string errorMsg);
                }

                // 调用MES进站 - 产品2
                int result2 = b1Part2Result_Check;
                if (result2 != 3)
                {
                    item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = sn,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "2",
                    });
                    result2 = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        b1Part2SN_Check, item, out string errorMsg);
                }

                stopwatch2.Stop();

                b1Part1Result_Check = result1 == 1 ? (short)1 : (short)2; // 穴位1产品结果(上位机写入)；1ok;2ng;3假产品
                b1Part2Result_Check = result2 == 1 ? (short)1 : (short)2; // 穴位2产品结果(上位机写入)；1ok;2ng;3假产品
                int result = result1;
                if (result == 1)
                    result = result2;

                short b1MES_FLAG_Check = (short)result;
                //Funs[plcNo].WriteMultipleRegisters<string>(2024, b1Part1SN_Check, 20);
                //Funs[plcNo].WriteMultipleRegisters<string>(2044, b1Part2SN_Check, 20);
                //Funs[plcNo].WriteMultipleRegisters<short>(2064, b1Part1Result_Check);
                //Funs[plcNo].WriteMultipleRegisters<short>(2065, b1Part2Result_Check);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, b1MES_FLAG_Check);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警

                WriteToPLC_Flag
                    writeToPLC_Flag = new WriteToPLC_Flag(); // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                writeToPLC_Flag.Name = "b1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = b1MES_FLAG_Check;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "b1Part1SN_Check",
                    Adress = 2024,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = b1Part1SN_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "b1Part2SN_Check",
                    Adress = 2044,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = b1Part2SN_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "b1Part1Result_Check",
                    Adress = 2064,
                    ValueType = PLCValueType.Short,
                    Value = b1Part1Result_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "b1Part2Result_Check",
                    Adress = 2065,
                    ValueType = PLCValueType.Short,
                    Value = b1Part2Result_Check
                });

                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Check", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 上料进站校验出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "b1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Check", writeToPLC_Flag);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_上料进站校验;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S2] FCT（板测）- 二穴载具解绑绑定
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S2二穴载具解绑绑定(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // 产品换载具
                string b1ProductSN_Unbind = (string)s2PLCData["b1ProductSN_Unbind"]; // 原二穴载具SN（需要解绑的）
                b1ProductSN_Unbind = b1ProductSN_Unbind.Replace("\0", "");
                string b1ProductSN_Bind = (string)s2PLCData["b1ProductSN_Bind"]; // 新二穴载具SN（需要绑定的）
                b1ProductSN_Bind = b1ProductSN_Bind.Replace("\0", "");
                string b1Part1SN_Bind = (string)s2PLCData["b1Part1SN_Bind"]; // 穴位1物料SN(plc写入)
                b1Part1SN_Bind = b1Part1SN_Bind.Replace("\0", "");
                string b1Part2SN_Bind = (string)s2PLCData["b1Part2SN_Bind"]; // 穴位2物料SN(plc写入)
                b1Part2SN_Bind = b1Part2SN_Bind.Replace("\0", "");

                stopwatch2.Start();

                #region 查询载具上的产品信息

                //string cavityData = string.Empty;
                //int snResult = XiaomiMES_RouteCommunication.SNQueryData(b1ProductSN_Unbind, ref cavityData);
                //if (string.IsNullOrEmpty(cavityData))
                //    cavityData = "";
                //if (snResult != 0)
                //{
                //    WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                //    writeToPLC_Flag.Name = "b1MES_FLAG_Unbind";
                //    writeToPLC_Flag.Adress = 2077;
                //    writeToPLC_Flag.Value = (short)6;
                //    SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Unbind", writeToPLC_Flag);
                //    stopwatch1.Stop();
                //    AddMessage(LogType.Info, stationNameStr + $"_二穴载具解绑绑定失败！MES边线软件_二穴载具查询返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                //    return;
                //}

                #endregion 查询载具上的产品信息

                #region 解绑（边线MES系统）

                int snResult = XiaomiMES_RouteCommunication.SNDeleteData(b1ProductSN_Unbind);
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "b1MES_FLAG_Unbind";
                    writeToPLC_Flag1.Adress = 2077;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Unbind", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_二穴载具解绑失败！MES边线软件_二穴载具[{b1ProductSN_Unbind}]解绑返回结果{snResult};总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                #endregion 解绑（边线MES系统）

                #region 存储绑定数据到 边线MES系统中

                string data = string.Concat(b1Part1SN_Bind, ".", b1Part2SN_Bind);
                snResult = XiaomiMES_RouteCommunication.SNBindData(b1ProductSN_Bind, data);
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "b1MES_FLAG_Unbind";
                    writeToPLC_Flag1.Adress = 2077;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Unbind", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_二穴载具绑定失败！MES边线软件_二穴载具[{b1ProductSN_Bind}]绑定[{data}]返回结果{snResult};总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                #endregion 存储绑定数据到 边线MES系统中

                stopwatch2.Stop();

                short b1MES_FLAG_Unbind = 1;

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2077, b1MES_FLAG_Unbind);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "b1MES_FLAG_Unbind";
                writeToPLC_Flag.Adress = 2077;
                writeToPLC_Flag.Value = b1MES_FLAG_Unbind;
                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Unbind", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 二穴载具解绑绑定出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2077, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "b1MES_FLAG_Unbind";
                writeToPLC_Flag.Adress = 2077;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG_Unbind", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_二穴载具解绑绑定;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        //// 上次采集到的SN
        //private string sn_FCT = string.Empty;
        /// <summary>
        /// [S2] FCT（板测）- 出站数据
        /// </summary>
        private void S2出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string b1ProductSN = (string)s2PLCData["b1ProductSN"]; // 产品SN（载具SN）
                int b1Part1Result = (int)s2PLCData["b1Part1Result"]; // 产品1结果
                int b1Part2Result = (int)s2PLCData["b1Part2Result"]; // 产品2结果
                bool pass1 = b1Part1Result == 1;
                bool pass2 = b1Part2Result == 1;

                #region 根据 载具SN 查 物料SN

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(b1ProductSN, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "b1MES_FLAG";
                    writeToPLC_Flag1.Adress = 2169;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_上传出站数据失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms");
                    return;
                }

                #endregion 根据 载具SN 查 物料SN

                string[] cavitySNs = cavityData.Split('.');
                string b1ProductSN1 = string.Empty;
                string b1ProductSN2 = string.Empty;
                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    b1ProductSN1 = cavitySNs[0];
                    b1ProductSN2 = cavitySNs[1];
                }

                stopwatch2.Start();
                // 产品1
                int result1 = 0;
                if (b1ProductSN1 == "假产品")
                    result1 = 1;
                else
                {
                    List<TestItem> items1 = new List<TestItem>();
                    items1.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = b1ProductSN.ToString(),
                        Parameter_unit = ""
                    });
                    items1.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "1",
                        Parameter_unit = ""
                    });
                    items1.Add(new TestItem()
                    {
                        Parameter_name = "产品结果",
                        Parameter_value = b1Part1Result == 1 ? "OK" : "NG",
                        Parameter_unit = ""
                    });
                    result1 = SwitctProcessData_old(stationNameStr, items1, equipmentCode, processItem
                        , workorder_code, mtltmrk, b1ProductSN1, pass1, b1ProductSN, "1");
                }

                // 产品2
                int result2 = 0;
                if (b1ProductSN1 == "假产品")
                    result2 = 1;
                else
                {
                    List<TestItem> items2 = new List<TestItem>();
                    items2.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = b1ProductSN.ToString(),
                        Parameter_unit = ""
                    });
                    items2.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "2",
                        Parameter_unit = ""
                    });
                    items2.Add(new TestItem()
                    {
                        Parameter_name = "产品结果",
                        Parameter_value = b1Part2Result == 1 ? "OK" : "NG",
                        Parameter_unit = ""
                    });
                    result2 = SwitctProcessData_old(stationNameStr, items2, equipmentCode, processItem
                        , workorder_code, mtltmrk, b1ProductSN2, pass2, b1ProductSN, "2");
                }

                short result = 0;
                List<int> results = new List<int>() { result1, result2 };
                if (result1 == 1 && result2 == 1)
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                //Funs[plcNo].WriteMultipleRegisters<short>(2169, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "b1MES_FLAG";
                writeToPLC_Flag.Adress = 2169;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2169, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "b1MES_FLAG";
                writeToPLC_Flag.Adress = 2169;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s2PLCWriteData, "b1MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}出站数据报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站数据;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S2] FCT（板测）- 节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S2节拍接口(int plcNo, string stationNameStr, string tagMesCommName, IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s1PLCData["a2OEEType"]).ToString(); // 节拍类型(plc写入)
                string a2OEEPartNo = (string)s1PLCData["a2OEEPartNo"]; // 物料码
                a2OEEPartNo = a2OEEPartNo.Replace("\0", "");
                string a20EEVehicleCode = (string)s1PLCData["a20EEVehicleCode"]; // 载具SN
                a20EEVehicleCode = a20EEVehicleCode.Replace("\0", "");

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(a2OEEPartNo) && string.IsNullOrEmpty(a20EEVehicleCode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a20EEVehicleCode}][{a2OEEPartNo}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a2OEEPartNo))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a20EEVehicleCode}][{a2OEEPartNo}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(a20EEVehicleCode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{a20EEVehicleCode}][{a2OEEPartNo}]上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, a2OEEPartNo, a20EEVehicleCode);

                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 1; //OK
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iot_data.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    iot_data.beatReturn = 2; //NG
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                iot_data.beatReturn = 2; //NG
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion [S2] FCT（板测）

        #endregion PLC2 李晓奇

        #region PLC3 刘永村

        #region [S3] 值板机

        /// <summary>
        /// S3工位的数据- 触发信号上次的值
        /// </summary>
        private Dictionary<string, object> s3PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// S3工位的数据（含触发信号）
        /// </summary>
        private Dictionary<string, object> s3PLCData = new Dictionary<string, object>();

        /// <summary>
        /// S3工位的数据- 回写点位
        /// </summary>
        private Dictionary<string, WriteToPLC_Flag> s3PLCWriteData = new Dictionary<string, WriteToPLC_Flag>();

        /// <summary>
        /// [S3] 值板机
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        //private void ReadStation_S3(int plcNo)
        //{
        //    // [S1] Tray盘上料装备
        //    // [S2] FCT
        //    // [S3] 值板机
        //    // [S4_1] 载具下线装备 [S4_5] 载具上线装备
        //    // [S5] Tray盘下料装备
        //    /// 上位机心跳
        //    /// 获取设备报警数据与状态信息
        //    string stationCode = "[S3]";
        //    string stationName = "值板机";
        //    string stationNameStr = stationCode + stationName;

        //    #region 创建字典
        //    // 触发信号字典 赋值
        //    s3PLCSignal_Old.Add("c1PLC_FLAG_Check", 0);   // PLC_FLAG 进站校验
        //    s3PLCSignal_Old.Add("c1PLC_FLAG_Unbind", 0);  // PLC_FLAG 二穴载具解绑
        //    s3PLCSignal_Old.Add("c1PLC_FLAG_Bind", 0);    // PLC_FLAG 二穴载具绑定
        //    s3PLCSignal_Old.Add("c1PLC_FLAG", 0);         // PLC_FLAG 出站接口
        //    s3PLCSignal_Old.Add("c1OEEPLC_FLAG", 0);      // PLC_FLAG 节拍接口

        //    // PLC数据字典 赋值
        //    s3PLCData.Add("c1PLC_FLAG_Check", 0);    // PLC_FLAG 进站校验
        //    s3PLCData.Add("c1MES_FLAG_Check", 0);    // MES_FLAG
        //    s3PLCData.Add("c1ProductSN_Check", "");  // 产品SN（二穴载具SN）
        //    s3PLCData.Add("c1PLC_FLAG_Unbind", 0);       // PLC_FLAG 二穴载具解绑
        //    s3PLCData.Add("c1MES_FLAG_Unbind", 0);       // MES_FLAG
        //    //s3PLCData.Add("c1ProductSN_Check", "");      // 产品SN（二穴载具SN）
        //    s3PLCData.Add("c1VehicleCavity_Unbind", 0);  // 二穴载具穴位号（产品取自二穴载具哪个穴位）
        //    s3PLCData.Add("c1PLC_FLAG_Bind", 0);           // PLC_FLAG 二穴载具绑定
        //    s3PLCData.Add("c1MES_FLAG_Bind", 0);           // MES_FLAG
        //    //s3PLCData.Add("c1ProductSN_Check", "");        // 产品SN（二穴载具SN）
        //    s3PLCData.Add("c1CavityReverse_Bind", 0);      // 是否是两个穴位交换
        //    s3PLCData.Add("c1VehicleCavityFr_Bind", 0);    // 来源穴位号（产品取自二穴载具哪个穴位）
        //    s3PLCData.Add("c1VehicleCavityTo_Bind", 0);    // 目标载具穴位号（产品放到二穴载具哪个穴位）
        //    s3PLCData.Add("c1PLC_FLAG", 0);         // PLC_FLAG 出站接口
        //    s3PLCData.Add("c1MES_FLAG", 0);         // MES_FLAG
        //    s3PLCData.Add("c1ProductSN", "");       // 产品SN（一穴载具SN）
        //    //s3PLCData.Add("c1ProductSN_Check", ""); // 二穴载具SN（产品取自哪个二穴载具）
        //    s3PLCData.Add("c1VehicleCavity", 0);   // 二穴载具穴位号（产品取自二穴载具哪个穴位）
        //    s3PLCData.Add("c1Result", 0);          // 产品结果
        //    s3PLCData.Add("c1OEEPLC_FLAG", 0);  // PLC_FLAG 节拍接口
        //    s3PLCData.Add("c1OEEMES_FLAG", 0);  // MES_FLAG
        //    s3PLCData.Add("c1OEEProductSN", "");// 产品SN（载具SN）
        //    s3PLCData.Add("c1OEEType", 0);      // 节拍类型(plc写入)
        //    #endregion 创建字典

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs3)
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);
        //                continue;
        //            }
        //            if (Funs[plcNo].IsConnected)  // 检查PLC是否已连接上
        //            {
        //                Stopwatch stopwatch1 = new Stopwatch();
        //                Stopwatch stopwatch2 = new Stopwatch();
        //                stopwatch1.Start();

        //                stopwatch2.Start();
        //                #region 一次性读取所有数据
        //                // 一次性读取所有数据
        //                ModbusClientHelper modbusClientHelper = Funs[plcNo];
        //                int[] data1 = Funs[plcNo].ReadHoldingRegisters(2000, 100);
        //                int[] data2 = Funs[plcNo].ReadHoldingRegisters(2100, 100);
        //                int[] data3 = Funs[plcNo].ReadHoldingRegisters(2200, 36);

        //                int[] datas = data1.Concat(data2).ToArray();
        //                datas = datas.Concat(data3).ToArray();

        //                s3PLCData["c1PLC_FLAG_Check"] = datas[2];    // PLC_FLAG 进站校验
        //                s3PLCData["c1MES_FLAG_Check"] = datas[3];    // MES_FLAG
        //                int[] c1ProductSN_CheckData = datas.Skip(4).Take(20).ToArray();
        //                s3PLCData["c1ProductSN_Check"] = ModbusClient.ConvertRegistersToString(c1ProductSN_CheckData, 0, 40);  // 产品SN（二穴载具SN）
        //                s3PLCData["c1PLC_FLAG_Unbind"] = datas[81];  // PLC_FLAG 二穴载具解绑
        //                s3PLCData["c1MES_FLAG_Unbind"] = datas[82];  // MES_FLAG
        //                s3PLCData["c1VehicleCavity_Unbind"] = datas[103];  // 二穴载具穴位号（产品取自二穴载具哪个穴位）
        //                s3PLCData["c1PLC_FLAG_Bind"] = datas[114];   // PLC_FLAG 二穴载具绑定
        //                s3PLCData["c1MES_FLAG_Bind"] = datas[115];   // MES_FLAG
        //                s3PLCData["c1CavityReverse_Bind"] = datas[136];   // 是否是两个穴位交换
        //                s3PLCData["c1VehicleCavityFr_Bind"] = datas[137]; // 来源穴位号（产品取自二穴载具哪个穴位）
        //                s3PLCData["c1VehicleCavityTo_Bind"] = datas[138]; // 目标载具穴位号（产品放到二穴载具哪个穴位）
        //                s3PLCData["c1PLC_FLAG"] = datas[149];            // PLC_FLAG 出站接口
        //                s3PLCData["c1MES_FLAG"] = datas[150];            // MES_FLAG
        //                int[] c1ProductSNData = datas.Skip(151).Take(20).ToArray();
        //                s3PLCData["c1ProductSN"] = ModbusClient.ConvertRegistersToString(c1ProductSNData, 0, 40);  // 产品SN（一穴载具SN）                              
        //                s3PLCData["c1VehicleCavity"] = datas[191];       // 二穴载具穴位号（产品取自二穴载具哪个穴位）
        //                s3PLCData["c1Result"] = datas[192];              // 产品结果
        //                s3PLCData["c1OEEPLC_FLAG"] = datas[203];  // PLC_FLAG 节拍接口
        //                s3PLCData["c1OEEMES_FLAG"] = datas[204];  // MES_FLAG
        //                int[] c1OEEProductSNData = datas.Skip(205).Take(20).ToArray();
        //                s3PLCData["c1OEEProductSN"] = ModbusClient.ConvertRegistersToString(c1OEEProductSNData, 0, 40); // 产品SN（载具SN）
        //                s3PLCData["c1OEEType"] = datas[225];      // 节拍类型(plc写入)
        //                #endregion 一次性读取所有数据
        //                stopwatch2.Stop();

        //                #region 回写操作，写后清空flag
        //                PLCWriteData(Funs[plcNo], ref s3PLCData, ref s3PLCWriteData);
        //                #endregion 回写操作，写后清空flag

        //                #region S3进站校验
        //                try
        //                {
        //                    int c1PLC_FLAG_Check = (int)s3PLCData["c1PLC_FLAG_Check"];
        //                    int c1MES_FLAG_Check = (int)s3PLCData["c1MES_FLAG_Check"];
        //                    int c1PLC_FLAG_CheckOld = (int)s3PLCSignal_Old["c1PLC_FLAG_Check"];
        //                    if (c1PLC_FLAG_Check != c1PLC_FLAG_CheckOld)
        //                    {
        //                        if (c1PLC_FLAG_Check == 1 && c1MES_FLAG_Check == 0)  // 0->1
        //                            Task.Run(() => S3进站校验(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (c1PLC_FLAG_Check == 0 && c1MES_FLAG_Check != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)0);

        //                        s3PLCSignal_Old["c1PLC_FLAG_Check"] = s3PLCData["c1PLC_FLAG_Check"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上料进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion S3进站校验

        //                #region S3二穴载具解绑
        //                try
        //                {
        //                    int c1PLC_FLAG_Unbind = (int)s3PLCData["c1PLC_FLAG_Unbind"];
        //                    int c1MES_FLAG_Bind = (int)s3PLCData["c1MES_FLAG_Unbind"];
        //                    int c1PLC_FLAG_UnbindOld = (int)s3PLCSignal_Old["c1PLC_FLAG_Unbind"];
        //                    if (c1PLC_FLAG_Unbind != c1PLC_FLAG_UnbindOld)
        //                    {
        //                        if (c1PLC_FLAG_Unbind == 1 && c1MES_FLAG_Bind == 0)  // 0->1
        //                            Task.Run(() => S3二穴载具解绑(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (c1PLC_FLAG_Unbind == 0 && c1MES_FLAG_Bind != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2082, (short)0);

        //                        s3PLCSignal_Old["c1PLC_FLAG_Unbind"] = s3PLCData["c1PLC_FLAG_Unbind"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2083, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 二穴载具解绑/绑定出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion S3二穴载具解绑

        //                #region S3二穴载具绑定
        //                try
        //                {
        //                    int c1PLC_FLAG_Bind = (int)s3PLCData["c1PLC_FLAG_Bind"];
        //                    int c1MES_FLAG_Bind = (int)s3PLCData["c1MES_FLAG_Bind"];
        //                    int c1PLC_FLAG_BindOld = (int)s3PLCSignal_Old["c1PLC_FLAG_Bind"];
        //                    if (c1PLC_FLAG_Bind != c1PLC_FLAG_BindOld)
        //                    {
        //                        if (c1PLC_FLAG_Bind == 1 && c1MES_FLAG_Bind == 0)  // 0->1
        //                            Task.Run(() => S3二穴载具绑定(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (c1PLC_FLAG_Bind == 0 && c1MES_FLAG_Bind != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2115, (short)0);

        //                        s3PLCSignal_Old["c1PLC_FLAG_Bind"] = s3PLCData["c1PLC_FLAG_Bind"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2115, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 二穴载具绑定出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion S3二穴载具绑定

        //                #region S3出站接口（+一穴载具绑定）
        //                try
        //                {
        //                    int c1PLC_FLAG = (int)s3PLCData["c1PLC_FLAG"];
        //                    int c1MES_FLAG = (int)s3PLCData["c1MES_FLAG"];
        //                    int c1PLC_FLAGOld = (int)s3PLCSignal_Old["c1PLC_FLAG"];
        //                    if (c1PLC_FLAG != c1PLC_FLAGOld)
        //                    {
        //                        if (c1PLC_FLAG == 1 && c1MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S3出站接口(plcNo, stationCode, stationName));  // MreTasks[3].Set();
        //                        else if (c1PLC_FLAG == 0 && c1MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2150, (short)0);

        //                        s3PLCSignal_Old["c1PLC_FLAG"] = s3PLCData["c1PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2150, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion S3出站接口（+一穴载具绑定）

        //                #region S3节拍接口
        //                try
        //                {
        //                    int c1OEEPLC_FLAG = (int)s3PLCData["c1OEEPLC_FLAG"];
        //                    int c1OEEMES_FLAG = (int)s3PLCData["c1OEEMES_FLAG"];
        //                    int c1OEEPLC_FLAGOld = (int)s3PLCSignal_Old["c1OEEPLC_FLAG"];
        //                    if (c1OEEPLC_FLAG != c1OEEPLC_FLAGOld)
        //                    {
        //                        if (c1OEEPLC_FLAG == 1 && c1OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S3节拍接口(plcNo, stationNameStr));  // MreTasks[4].Set();
        //                        else if (c1OEEPLC_FLAG == 0 && c1OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2204, (short)0);

        //                        s3PLCSignal_Old["c1OEEPLC_FLAG"] = s3PLCData["c1OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2204, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion S3节拍接口

        //                #region 心跳
        //                try
        //                {
        //                    short states = 0;
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2000, states);
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上位机心跳写入出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 心跳

        //                UpdatePLCMonitor(1, plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI

        //                stopwatch1.Stop();
        //                //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
        //                OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

        //                Funs[plcNo].Connect();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());
        //            Funs[plcNo].ReConnect();
        //        }

        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        /// <summary>
        /// [S3] 值板机- 进站校验
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S3进站校验(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                string sn = (string)s3PLCData["c1ProductSN_Check"]; // 产品SN（载具码）
                sn = sn.Replace("\0", "");

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "c1MES_FLAG_Check";
                    writeToPLC_Flag1.Adress = 2003;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Check", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_进站校验失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                #endregion 查询载具上的产品信息

                string[] cavitySNs = cavityData.Split('.');
                string part1Str = ""; // 产品1的SN码
                string part2Str = ""; // 产品2的SN码
                short c1Part1Result_Check = 1; // 穴位1产品结果(上位机写入)；1ok;2ng;3假产品
                short c1Part2Result_Check = 1; // 穴位2产品结果(上位机写入)；1ok;2ng;3假产品
                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    part1Str = cavitySNs[0];
                    part2Str = cavitySNs[1];
                    c1Part1Result_Check = 2;
                    c1Part2Result_Check = 2;
                }

                if (part1Str == "假产品")
                    c1Part1Result_Check = 3;
                if (part2Str == "假产品")
                    c1Part2Result_Check = 3;

                // 调用MES进站
                stopwatch2.Start();
                // 调用MES进站 - 产品1
                List<TestItem> item;
                int result1 = c1Part1Result_Check;
                if (result1 != 3)
                {
                    item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = sn,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "1",
                    });
                    result1 = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        part1Str, item, out string errorMsg);
                }

                // 调用MES进站 - 产品2
                int result2 = c1Part2Result_Check;
                if (result2 != 3)
                {
                    item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = sn,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "2",
                    });
                    result2 = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        part2Str, item, out string errorMsg);
                }

                stopwatch2.Stop();

                if (result1 == 2)
                    c1Part1Result_Check = 2;
                if (result2 == 2)
                    c1Part2Result_Check = 2;
                int result = result1;
                if (result == 1)
                    result = result2;

                short c1Part1Num_Check = 0; // 穴位1产品返修次数(上位机写入)
                short c1Part2Num_Check = 0; // 穴位2产品返修次数(上位机写入)
                short c1MES_FLAG_Check = (short)result;

                //Funs[plcNo].WriteMultipleRegisters<short>(2024, c1Part1Result_Check);
                //Funs[plcNo].WriteMultipleRegisters<short>(2025, c1Part2Result_Check);
                //Funs[plcNo].WriteMultipleRegisters<short>(2026, c1Part1Num_Check);
                //Funs[plcNo].WriteMultipleRegisters<short>(2027, c1Part2Num_Check);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, c1MES_FLAG_Check);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = c1MES_FLAG_Check;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "c1Part1Result_Check",
                    Adress = 2024,
                    ValueType = PLCValueType.Short,
                    Value = c1Part1Result_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "c1Part2Result_Check",
                    Adress = 2025,
                    ValueType = PLCValueType.Short,
                    Value = c1Part2Result_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "c1Part1Num_Check",
                    Adress = 2026,
                    ValueType = PLCValueType.Short,
                    Value = c1Part1Num_Check
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "c1Part2Num_Check",
                    Adress = 2027,
                    ValueType = PLCValueType.Short,
                    Value = c1Part2Num_Check
                });
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Check", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 进站校验出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Check", writeToPLC_Flag);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_进站校验;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S3] 值板机 - 二穴载具解绑
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S3二穴载具解绑(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                string c1ProductSN_Check = (string)s3PLCData["c1ProductSN_Check"]; // 产品SN（二穴载具SN）
                c1ProductSN_Check = c1ProductSN_Check.Replace("\0", "");
                int c1VehicleCavity_Unbind = (int)s3PLCData["c1VehicleCavity_Unbind"]; // 二穴载具穴位号（产品取自二穴载具哪个穴位）

                // 解绑

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(c1ProductSN_Check, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "c1MES_FLAG_Unbind";
                    writeToPLC_Flag1.Adress = 2082;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Unbind", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_二穴载具解绑失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms");
                    return;
                }

                #endregion 查询载具上的产品信息

                string[] cavitySNs = cavityData.Split('.'); // 产品信息【产品1.产品2】

                #region 解绑

                if (cavitySNs.All(a => string.IsNullOrEmpty(a)))
                {
                    // 删除
                    int res1 = XiaomiMES_RouteCommunication.SNDeleteData(c1ProductSN_Check);
                    OnMessage(LogType.Debug, $"PLC{plcNo}_[{stationNameStr}]-二穴载具解绑SN{c1ProductSN_Check}---{res1}");
                }
                else
                {
                    string data_new = string.Join(".", cavitySNs);

                    // 删除再插入
                    int res2 = XiaomiMES_RouteCommunication.SNDeleteData(c1ProductSN_Check);
                    int res3 = XiaomiMES_RouteCommunication.SNBindData(c1ProductSN_Check, data_new);
                    OnMessage(LogType.Debug,
                        $"PLC{plcNo}_[{stationNameStr}]-二穴载具解绑SN{c1ProductSN_Check}---{res2},{res3}");
                }

                #endregion 解绑

                short c1MES_FLAG_Unbind = 1;
                stopwatch2.Start();
                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2082, c1MES_FLAG_Unbind);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Unbind";
                writeToPLC_Flag.Adress = 2082;
                writeToPLC_Flag.Value = c1MES_FLAG_Unbind;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Unbind", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 二穴载具解绑出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2082, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Unbind";
                writeToPLC_Flag.Adress = 2082;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Unbind", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_二穴载具解绑;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S3] 值板机 - 二穴载具绑定
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S3二穴载具绑定(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                string c1ProductSN_Check = (string)s3PLCData["c1ProductSN_Check"]; // 产品SN（二穴载具SN）
                c1ProductSN_Check = c1ProductSN_Check.Replace("\0", "");
                int c1CavityReverse_Bind = (int)s3PLCData["c1CavityReverse_Bind"]; // 是否是两个穴位交换
                int c1VehicleCavityFr_Bind = (int)s3PLCData["c1VehicleCavityFr_Bind"]; // 来源穴位号（产品取自二穴载具哪个穴位）
                int c1VehicleCavityTo_Bind = (int)s3PLCData["c1VehicleCavityTo_Bind"]; // 目标载具穴位号（产品放到二穴载具哪个穴位）

                stopwatch2.Start();

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(c1ProductSN_Check, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "c1MES_FLAG_Bind";
                    writeToPLC_Flag1.Adress = 2115;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Bind", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_二穴载具绑定失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms");
                    return;
                }

                #endregion 查询载具上的产品信息

                // 产品换载具
                string[] cavitySNs = cavityData.Split('.'); // 产品信息【产品1.产品2】
                string partSn1 = "";
                string partSn2 = "";

                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    partSn1 = cavitySNs[0];
                    partSn2 = cavitySNs[1];
                }

                string data_new = string.Empty;
                // 是否是两个穴位交换
                if (c1CavityReverse_Bind == 1)
                {
                    // 交换
                    data_new = string.Concat(partSn2, ".", partSn1);
                }
                else
                {
                    // 不交换
                    string sn = string.Copy(cavitySNs[c1VehicleCavityFr_Bind]);
                    cavitySNs[c1VehicleCavityTo_Bind] = sn;
                    cavitySNs[c1VehicleCavityFr_Bind] = "";
                    data_new = string.Join(".", cavitySNs);
                }

                // 删除再插入
                int res1 = XiaomiMES_RouteCommunication.SNDeleteData(c1ProductSN_Check);
                int res2 = XiaomiMES_RouteCommunication.SNBindData(c1ProductSN_Check, data_new);
                OnMessage(LogType.Debug, $"PLC{plcNo}_[{stationNameStr}]-_二穴载具绑定SN{c1ProductSN_Check}---{res1},{res2}");
                stopwatch2.Stop();

                short c1MES_FLAG_Bind = 1;

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2115, c1MES_FLAG_Bind);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Bind";
                writeToPLC_Flag.Adress = 2115;
                writeToPLC_Flag.Value = c1MES_FLAG_Bind;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Bind", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 二穴载具绑定出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2115, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG_Bind";
                writeToPLC_Flag.Adress = 2115;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG_Bind", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_二穴载具绑定;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        //// 上次采集到的SN
        //private string sn_值板机 = string.Empty;
        /// <summary>
        /// [S3] 值板机 - 出站接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        private void S3出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s3PLCData["c1ProductSN"]; // 产品SN（一穴载具SN）
                sn = sn.Replace("\0", "");
                string c1ProductSN_Check = (string)s3PLCData["c1ProductSN_Check"]; // 二穴载具SN（产品取自哪个二穴载具）
                c1ProductSN_Check = c1ProductSN_Check.Replace("\0", "");
                int c1VehicleCavity = (int)s3PLCData["c1VehicleCavity"]; // 二穴载具穴位号（产品取自二穴载具哪个穴位）
                int c1Result = (int)s3PLCData["c1Result"]; // 产品结果
                bool pass = c1Result == 1;

                // 查sn

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(c1ProductSN_Check, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "c1MES_FLAG";
                    writeToPLC_Flag1.Adress = 2150;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                #endregion 查询载具上的产品信息

                string[] cavitySNs = cavityData.Split('.');
                string productSN = "";
                if (cavitySNs != null && cavitySNs.Length >= 2)
                {
                    productSN = cavitySNs[c1VehicleCavity];
                    cavitySNs[c1VehicleCavity] = "";
                }

                stopwatch2.Start();
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "二穴载具码",
                    Parameter_value = c1ProductSN_Check,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "二穴载具穴号",
                    Parameter_value = c1VehicleCavity.ToString(),
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "一穴载具码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "一穴载具穴号",
                    Parameter_value = "1",
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品结果",
                    Parameter_value = c1Result == 1 ? "OK" : "NG",
                    Parameter_unit = ""
                });

                int result1 = SwitctProcessData_old(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, mtltmrk, productSN, pass, sn, "1");
                short result = (short)result1;
                stopwatch2.Stop();

                #region 存储绑定数据到 边线MES系统中

                if (result == 1)
                {
                    string data = string.Concat(productSN);
                    int resultMesR = XiaomiMES_RouteCommunication.SNBindData(sn, data);
                    if (resultMesR != 0)
                    {
                        result = 4;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_[{equipmentCode}]{processItem}过站失败！MES边线程序返回：{resultMesR}");
                    }
                }

                #endregion 存储绑定数据到 边线MES系统中

                #region 产品从 来源载具（二穴载具）中删除

                if (cavitySNs.All(a => string.IsNullOrEmpty(a)))
                {
                    // 删除
                    int res1 = XiaomiMES_RouteCommunication.SNDeleteData(c1ProductSN_Check);
                    OnMessage(LogType.Debug,
                        $"PLC{plcNo}_[{equipmentCode}]{processItem}-出站解绑SN{c1ProductSN_Check}---{res1}");
                }
                else
                {
                    string data_new = string.Join(".", cavitySNs);

                    // 删除再插入
                    int res2 = XiaomiMES_RouteCommunication.SNDeleteData(c1ProductSN_Check);
                    int res3 = XiaomiMES_RouteCommunication.SNBindData(c1ProductSN_Check, data_new);
                    OnMessage(LogType.Debug,
                        $"PLC{plcNo}_[{equipmentCode}]{processItem}-出站解绑SN{c1ProductSN_Check}---{res2},{res3}");
                }

                #endregion 产品从 来源载具（二穴载具）中删除

                // MES_Flag 为MES报错
                // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                //Funs[plcNo].WriteMultipleRegisters<short>(2150, result);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG";
                writeToPLC_Flag.Adress = 2150;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2150, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "c1MES_FLAG";
                writeToPLC_Flag.Adress = 2150;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s3PLCWriteData, "c1MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}上传出站接口报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S3] 值板机- 节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S3节拍接口(int plcNo, string stationNameStr, string tagMesCommName, string CarrierBarcode,
            IoT_DataSet_t iot_data)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = iot_data.BeatAction.ToString(); // 节拍类型(plc写入)
                string strProductBarcode = SQLHelper.GetProductBarcodeByCarrierCode(CarrierBarcode); //产品SN

                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                //作业开始后要有物料和载具信息
                if (string.IsNullOrEmpty(strProductBarcode) && string.IsNullOrEmpty(CarrierBarcode) &&
                    Convert.ToInt32(oEEType) > 2)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{CarrierBarcode}][{strProductBarcode}]上传节拍失败!物料码与载具SN不可都为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(strProductBarcode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_[{CarrierBarcode}]上传节拍失败!物料码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else if (Convert.ToInt32(oEEType) > 2 && string.IsNullOrEmpty(CarrierBarcode))
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Info,
                        stationNameStr + $"_上传节拍失败!载具码不可为空;总用时" +
                        stopwatch1.ElapsedMilliseconds + "ms;调用Iot用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                short _result = 0;

                // 上传OEE
                (short, string) result =
                    SaveOEEData(plcNo, stationNameStr, deviceOEE, strProductBarcode, CarrierBarcode);
                _result = result.Item1;
                resultStr = result.Item2;

                if (_result == 1)
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 1; //OK
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    OnMessage(LogType.Info,
                        $"PLC{plcNo}_{stationNameStr} 节拍{iotData.BeatAction}上传IOT成功！上传结果：" + resultStr);
                    stopwatch2.Stop();
                }
                else
                {
                    stopwatch2.Start();
                    //写入PLC
                    IoT_DataSet_t iotData = new IoT_DataSet_t();
                    iotData.machineState = iot_data.machineState;
                    iotData.work_type = iot_data.work_type;
                    iotData.testStatus = iot_data.testStatus;
                    iotData.BeatAction = iot_data.BeatAction;
                    iotData.beatReturn = 2; //NG
                    iotData.fault_codes = iot_data.fault_codes;
                    WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iotData);
                    stopwatch2.Stop();
                    AddMessage_Station(stationNameStr, LogType.Error,
                        $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + resultStr);
                }
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //写入PLC
                IoT_DataSet_t iotData = new IoT_DataSet_t();
                iotData.machineState = iot_data.machineState;
                iotData.work_type = iot_data.work_type;
                iotData.testStatus = iot_data.testStatus;
                iotData.BeatAction = iot_data.BeatAction;
                iotData.beatReturn = 2; //NG
                iotData.fault_codes = iot_data.fault_codes;
                WriteResultToPlc(plcNo, stationNameStr, tagMesCommName, 1, iot_data);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion [S3] 值板机

        #endregion PLC3 刘永村

        #region PLC4 刘果段

        #region [S4] 取放桁架

        /// <summary>
        /// S4工位的数据- 触发信号上次的值
        /// </summary>
        private Dictionary<string, object> s4PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// S4工位的数据（含触发信号）
        /// </summary>
        private Dictionary<string, object> s4PLCData = new Dictionary<string, object>();

        /// <summary>
        /// S4工位的数据- 回写点位
        /// </summary>
        private Dictionary<string, WriteToPLC_Flag> s4PLCWriteData = new Dictionary<string, WriteToPLC_Flag>();

        /// <summary>
        /// [S4] 取放桁架
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        //private void ReadStation_S4(int plcNo)
        //{
        //    // [S1] Tray盘上料装备
        //    // [S2] FCT
        //    // [S3] 值板机
        //    // [S4_1] 载具下线装备 [S4_5] 载具上线装备
        //    // [S5] Tray盘下料装备
        //    /// 上位机心跳
        //    /// 获取设备报警数据与状态信息
        //    string stationCode = "[S4_1]";
        //    string stationName = "载具下线装备";
        //    string stationNameStr = stationCode + stationName;
        //    string stationCode2 = "[S4_2]";
        //    string stationName2 = "桁架";
        //    string stationNameStr2 = stationCode2 + stationName2;
        //    string stationCode3 = "[S4_3]";
        //    string stationName3 = "提升机1";
        //    string stationNameStr3 = stationCode3 + stationName3;
        //    string stationCode4 = "[S4_4]";
        //    string stationName4 = "提升机2";
        //    string stationNameStr4 = stationCode4 + stationName4;
        //    string stationCode5 = "[S4_5]";
        //    string stationName5 = "载具上线装备";
        //    string stationNameStr5 = stationCode5 + stationName5;

        //    #region 创建字典
        //    // 触发信号字典 赋值
        //    s4PLCSignal_Old.Add("d1BulletclipScanCode", 0);  // 扫码信号 弹夹扫码
        //    s4PLCSignal_Old.Add("d1VehicleScanCode", 0);     // 扫码信号 载具扫码
        //    s4PLCSignal_Old.Add("d1PLC_FLAG", 0);            // PLC_FLAG 出站接口
        //    s4PLCSignal_Old.Add("d1OEEPLC_FLAG", 0);         // PLC_FLAG 节拍接口
        //    s4PLCSignal_Old.Add("d2BulletclipScanCode", 0);  // 扫码信号 查询标机中弹夹的状态
        //    s4PLCSignal_Old.Add("d3PLC_FLAG", 0);            // PLC_FLAG 真空标机1出站接口
        //    s4PLCSignal_Old.Add("d4PLC_FLAG", 0);            // PLC_FLAG 真空标机2出站接口
        //    s4PLCSignal_Old.Add("d5BulletclipScanCode", 0);  // 扫码信号 弹夹扫码
        //    s4PLCSignal_Old.Add("d5VehicleScanCode", 0);     // 扫码信号 载具扫码
        //    s4PLCSignal_Old.Add("d5PLC_FLAG", 0);            // PLC_FLAG 出站接口
        //    s4PLCSignal_Old.Add("d5OEEPLC_FLAG", 0);         // PLC_FLAG 节拍接口

        //    // PLC数据字典 赋值
        //    // 载具下线装备（弹夹上线）
        //    s4PLCData.Add("d1BulletclipScanCode", 0);  // 扫码信号 弹夹扫码
        //    s4PLCData.Add("d1BulletclipCode", "");     // 扫到的码
        //    s4PLCData.Add("d1VehicleScanCode", 0);  // 扫码信号 载具扫码
        //    s4PLCData.Add("d1VehicleCode", "");     // 扫到的码

        //    s4PLCData.Add("d1PLC_FLAG", 0);       // PLC_FLAG 出站接口
        //    s4PLCData.Add("d1MES_FLAG", 0);       // MES_FLAG
        //    s4PLCData.Add("d1ProductSN", "");     // 产品SN（弹夹码）
        //    s4PLCData.Add("d1VehicleCode1", "");  // 载具1码（弹夹穴位1）
        //    s4PLCData.Add("d1VehicleCode2", "");  // 载具2码（弹夹穴位2）
        //    s4PLCData.Add("d1VehicleCode3", "");  // 载具3码（弹夹穴位3）
        //    s4PLCData.Add("d1VehicleCode4", "");  // 载具4码（弹夹穴位4）
        //    s4PLCData.Add("d1VehicleCode5", "");  // 载具5码（弹夹穴位5）
        //    s4PLCData.Add("d1VehicleCode6", "");  // 载具6码（弹夹穴位6）
        //    s4PLCData.Add("d1VehicleCode7", "");  // 载具7码（弹夹穴位7）
        //    s4PLCData.Add("d1VehicleCode8", "");  // 载具8码（弹夹穴位8）
        //    s4PLCData.Add("d1VehicleCode9", "");  // 载具9码（弹夹穴位9）
        //    s4PLCData.Add("d1VehicleCode10", ""); // 载具10码（弹夹穴位10）
        //    s4PLCData.Add("d1Result", 0);         // 产品结果

        //    s4PLCData.Add("d1OEEPLC_FLAG", 0);  // PLC_FLAG 节拍接口
        //    s4PLCData.Add("d1OEEMES_FLAG", 0);  // MES_FLAG
        //    s4PLCData.Add("d1OEEProductSN", "");// 产品SN（载具SN）
        //    s4PLCData.Add("d1OEEType", 0);      // 节拍类型(plc写入) 

        //    s4PLCData.Add("d2BulletclipScanCode", 0);  // 扫码信号 查询标机中弹夹的状态
        //    s4PLCData.Add("d2BulletclipStates", 0);    // 弹夹状态
        //    s4PLCData.Add("d2BulletclipCode", "");     // 扫到的码
        //    // 真空标机（提升机）
        //    s4PLCData.Add("d3PLC_FLAG", 0);   // PLC_FLAG 真空标机1出站接口
        //    s4PLCData.Add("d3MES_FLAG", 0);   // MES_FLAG
        //    s4PLCData.Add("d3Type", 0);       // 进站还是出站
        //    s4PLCData.Add("d3ProductSN", ""); // 产品SN（弹夹码）
        //    s4PLCData.Add("d3Result", 0);     // 产品结果
        //    s4PLCData.Add("d4PLC_FLAG", 0);   // PLC_FLAG 真空标机2出站接口
        //    s4PLCData.Add("d4MES_FLAG", 0);   // MES_FLAG
        //    s4PLCData.Add("d4Type", 0);       // 进站还是出站
        //    s4PLCData.Add("d4ProductSN", ""); // 产品SN（弹夹码）
        //    s4PLCData.Add("d4Result", 0);     // 产品结果

        //    // 载具上线装备（弹夹下线）
        //    s4PLCData.Add("d5BulletclipScanCode", 0);  // 扫码信号 弹夹扫码
        //    s4PLCData.Add("d5BulletclipCode", "");     // 扫到的码
        //    s4PLCData.Add("d5VehicleScanCode", 0);     // 扫码信号 载具扫码
        //    s4PLCData.Add("d5VehicleCode", "");        // 扫到的码

        //    s4PLCData.Add("d5PLC_FLAG", 0);       // PLC_FLAG 出站接口
        //    s4PLCData.Add("d5MES_FLAG", 0);       // MES_FLAG
        //    s4PLCData.Add("d5ProductSN", "");     // 产品SN（弹夹码）
        //    s4PLCData.Add("d5VehicleCode1", "");  // 载具1码（弹夹穴位1）
        //    s4PLCData.Add("d5VehicleCode2", "");  // 载具2码（弹夹穴位2）
        //    s4PLCData.Add("d5VehicleCode3", "");  // 载具3码（弹夹穴位3）
        //    s4PLCData.Add("d5VehicleCode4", "");  // 载具4码（弹夹穴位4）
        //    s4PLCData.Add("d5VehicleCode5", "");  // 载具5码（弹夹穴位5）
        //    s4PLCData.Add("d5VehicleCode6", "");  // 载具6码（弹夹穴位6）
        //    s4PLCData.Add("d5VehicleCode7", "");  // 载具7码（弹夹穴位7）
        //    s4PLCData.Add("d5VehicleCode8", "");  // 载具8码（弹夹穴位8）
        //    s4PLCData.Add("d5VehicleCode9", "");  // 载具9码（弹夹穴位9）
        //    s4PLCData.Add("d5VehicleCode10", ""); // 载具10码（弹夹穴位10）
        //    s4PLCData.Add("d5Result", 0);         // 产品结果

        //    s4PLCData.Add("d5OEEPLC_FLAG", 0);  // PLC_FLAG 节拍接口
        //    s4PLCData.Add("d5OEEMES_FLAG", 0);  // MES_FLAG
        //    s4PLCData.Add("d5OEEProductSN", "");// 产品SN（载具SN）
        //    s4PLCData.Add("d5OEEType", 0);      // 节拍类型(plc写入) 
        //    #endregion 创建字典

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs4)
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);
        //                continue;
        //            }
        //            if (Funs[plcNo].IsConnected)  // 检查PLC是否已连接上
        //            {
        //                Stopwatch stopwatch1 = new Stopwatch();
        //                Stopwatch stopwatch2 = new Stopwatch();
        //                stopwatch1.Start();

        //                stopwatch2.Start();
        //                #region 一次性读取所有数据
        //                // 载具下线装备（弹夹上线）
        //                int[] data1 = Funs[plcNo].ReadHoldingRegisters(2000, 100);
        //                int[] data2 = Funs[plcNo].ReadHoldingRegisters(2100, 100);
        //                int[] data3 = Funs[plcNo].ReadHoldingRegisters(2200, 100);
        //                int[] data4 = Funs[plcNo].ReadHoldingRegisters(2300, 100);
        //                int[] data5 = Funs[plcNo].ReadHoldingRegisters(2400, 100);
        //                int[] data6 = Funs[plcNo].ReadHoldingRegisters(2500, 100);
        //                int[] data7 = Funs[plcNo].ReadHoldingRegisters(2600, 100);
        //                int[] data8 = Funs[plcNo].ReadHoldingRegisters(2700, 100);
        //                int[] data9 = Funs[plcNo].ReadHoldingRegisters(2800, 100);
        //                int[] data10 = Funs[plcNo].ReadHoldingRegisters(2900, 56);
        //                int[] datas = data1.Concat(data2).ToArray();
        //                datas = datas.Concat(data3).ToArray();
        //                datas = datas.Concat(data4).ToArray();
        //                datas = datas.Concat(data5).ToArray();
        //                datas = datas.Concat(data6).ToArray();
        //                datas = datas.Concat(data7).ToArray();
        //                datas = datas.Concat(data8).ToArray();
        //                datas = datas.Concat(data9).ToArray();
        //                datas = datas.Concat(data10).ToArray();

        //                // 载具下线装备（弹夹上线）
        //                s4PLCData["d1BulletclipScanCode"] = datas[2];  // 扫码信号 弹夹扫码
        //                int[] d1BulletclipCodeData = datas.Skip(3).Take(20).ToArray();
        //                s4PLCData["d1BulletclipCode"] = ModbusClient.ConvertRegistersToString(d1BulletclipCodeData, 0, 40);
        //                s4PLCData["d1VehicleScanCode"] = datas[33];  // 扫码信号 载具扫码
        //                int[] d1VehicleCodeData = datas.Skip(34).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode"] = ModbusClient.ConvertRegistersToString(d1VehicleCodeData, 0, 40);
        //                s4PLCData["d1PLC_FLAG"] = datas[64];  // PLC_FLAG 出站接口
        //                s4PLCData["d1MES_FLAG"] = datas[65];
        //                int[] d1ProductSNData = datas.Skip(66).Take(20).ToArray();
        //                s4PLCData["d1ProductSN"] = ModbusClient.ConvertRegistersToString(d1ProductSNData, 0, 40);    // 产品SN（物料码）
        //                int[] d1VehicleCode1Data = datas.Skip(86).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode1"] = ModbusClient.ConvertRegistersToString(d1VehicleCode1Data, 0, 40);
        //                int[] d1VehicleCode2Data = datas.Skip(106).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode2"] = ModbusClient.ConvertRegistersToString(d1VehicleCode2Data, 0, 40);
        //                int[] d1VehicleCode3Data = datas.Skip(126).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode3"] = ModbusClient.ConvertRegistersToString(d1VehicleCode3Data, 0, 40);
        //                int[] d1VehicleCode4Data = datas.Skip(146).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode4"] = ModbusClient.ConvertRegistersToString(d1VehicleCode4Data, 0, 40);
        //                int[] d1VehicleCode5Data = datas.Skip(166).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode5"] = ModbusClient.ConvertRegistersToString(d1VehicleCode5Data, 0, 40);
        //                int[] d1VehicleCode6Data = datas.Skip(186).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode6"] = ModbusClient.ConvertRegistersToString(d1VehicleCode6Data, 0, 40);
        //                int[] d1VehicleCode7Data = datas.Skip(206).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode7"] = ModbusClient.ConvertRegistersToString(d1VehicleCode7Data, 0, 40);
        //                int[] d1VehicleCode8Data = datas.Skip(226).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode8"] = ModbusClient.ConvertRegistersToString(d1VehicleCode8Data, 0, 40);
        //                int[] d1VehicleCode9Data = datas.Skip(246).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode9"] = ModbusClient.ConvertRegistersToString(d1VehicleCode9Data, 0, 40);
        //                int[] d1VehicleCode10Data = datas.Skip(266).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode10"] = ModbusClient.ConvertRegistersToString(d1VehicleCode10Data, 0, 40);
        //                int[] d1VehicleCode11Data = datas.Skip(286).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode11"] = ModbusClient.ConvertRegistersToString(d1VehicleCode11Data, 0, 40);
        //                int[] d1VehicleCode12Data = datas.Skip(306).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode12"] = ModbusClient.ConvertRegistersToString(d1VehicleCode12Data, 0, 40);
        //                int[] d1VehicleCode13Data = datas.Skip(326).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode13"] = ModbusClient.ConvertRegistersToString(d1VehicleCode13Data, 0, 40);
        //                int[] d1VehicleCode14Data = datas.Skip(346).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode14"] = ModbusClient.ConvertRegistersToString(d1VehicleCode14Data, 0, 40);
        //                int[] d1VehicleCode15Data = datas.Skip(366).Take(20).ToArray();
        //                s4PLCData["d1VehicleCode15"] = ModbusClient.ConvertRegistersToString(d1VehicleCode15Data, 0, 40);
        //                s4PLCData["d1Result"] = datas[386];
        //                s4PLCData["d1OEEPLC_FLAG"] = datas[397];  // PLC_FLAG 节拍接口
        //                s4PLCData["d1OEEMES_FLAG"] = datas[398];
        //                int[] d1OEEProductSNData = datas.Skip(399).Take(20).ToArray();
        //                s4PLCData["d1OEEProductSN"] = ModbusClient.ConvertRegistersToString(d1OEEProductSNData, 0, 40);
        //                s4PLCData["d1OEEType"] = datas[419];
        //                // 桁架（查询标机中弹夹的状态）
        //                s4PLCData["d2BulletclipScanCode"] = datas[430];
        //                s4PLCData["d2BulletclipStates"] = datas[431];
        //                int[] d2BulletclipCodeData = datas.Skip(432).Take(20).ToArray();
        //                s4PLCData["d2BulletclipCode"] = ModbusClient.ConvertRegistersToString(d2BulletclipCodeData, 0, 40);
        //                // 真空标机
        //                s4PLCData["d3PLC_FLAG"] = datas[462];  // 真空标机1 出站接口
        //                s4PLCData["d3MES_FLAG"] = datas[463];
        //                int[] d3ProductSNData = datas.Skip(464).Take(20).ToArray();
        //                s4PLCData["d3ProductSN"] = ModbusClient.ConvertRegistersToString(d3ProductSNData, 0, 40);
        //                s4PLCData["d3Result"] = datas[484];
        //                s4PLCData["d3Type"] = datas[485];
        //                s4PLCData["d4PLC_FLAG"] = datas[495];  // 真空标机2 出站接口
        //                s4PLCData["d4MES_FLAG"] = datas[496];
        //                int[] d4ProductSNData = datas.Skip(497).Take(20).ToArray();
        //                s4PLCData["d4ProductSN"] = ModbusClient.ConvertRegistersToString(d4ProductSNData, 0, 40);
        //                s4PLCData["d4Result"] = datas[517];
        //                s4PLCData["d4Type"] = datas[518];
        //                // 载具上线装备（弹夹下线）
        //                s4PLCData["d5BulletclipScanCode"] = datas[528];  // 扫码信号 弹夹扫码
        //                int[] d5BulletclipCodeData = datas.Skip(529).Take(20).ToArray();
        //                s4PLCData["d5BulletclipCode"] = ModbusClient.ConvertRegistersToString(d5BulletclipCodeData, 0, 40);
        //                s4PLCData["d5VehicleScanCode"] = datas[559];        // 扫码信号 载具扫码
        //                int[] d5VehicleCodeData = datas.Skip(560).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode"] = ModbusClient.ConvertRegistersToString(d5VehicleCodeData, 0, 40);
        //                s4PLCData["d5PLC_FLAG"] = datas[590];  // PLC_FLAG 出站接口
        //                s4PLCData["d5MES_FLAG"] = datas[591];
        //                int[] d5ProductSNData = datas.Skip(592).Take(20).ToArray();
        //                s4PLCData["d5ProductSN"] = ModbusClient.ConvertRegistersToString(d5ProductSNData, 0, 40);    // 产品SN（物料码）
        //                int[] d5VehicleCode1Data = datas.Skip(612).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode1"] = ModbusClient.ConvertRegistersToString(d5VehicleCode1Data, 0, 40);
        //                int[] d5VehicleCode2Data = datas.Skip(632).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode2"] = ModbusClient.ConvertRegistersToString(d5VehicleCode2Data, 0, 40);
        //                int[] d5VehicleCode3Data = datas.Skip(652).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode3"] = ModbusClient.ConvertRegistersToString(d5VehicleCode3Data, 0, 40);
        //                int[] d5VehicleCode4Data = datas.Skip(672).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode4"] = ModbusClient.ConvertRegistersToString(d5VehicleCode4Data, 0, 40);
        //                int[] d5VehicleCode5Data = datas.Skip(692).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode5"] = ModbusClient.ConvertRegistersToString(d5VehicleCode5Data, 0, 40);
        //                int[] d5VehicleCode6Data = datas.Skip(712).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode6"] = ModbusClient.ConvertRegistersToString(d5VehicleCode6Data, 0, 40);
        //                int[] d5VehicleCode7Data = datas.Skip(732).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode7"] = ModbusClient.ConvertRegistersToString(d5VehicleCode7Data, 0, 40);
        //                int[] d5VehicleCode8Data = datas.Skip(752).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode8"] = ModbusClient.ConvertRegistersToString(d5VehicleCode8Data, 0, 40);
        //                int[] d5VehicleCode9Data = datas.Skip(772).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode9"] = ModbusClient.ConvertRegistersToString(d5VehicleCode9Data, 0, 40);
        //                int[] d5VehicleCode10Data = datas.Skip(792).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode10"] = ModbusClient.ConvertRegistersToString(d5VehicleCode10Data, 0, 40);
        //                int[] d5VehicleCode11Data = datas.Skip(812).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode11"] = ModbusClient.ConvertRegistersToString(d5VehicleCode11Data, 0, 40);
        //                int[] d5VehicleCode12Data = datas.Skip(832).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode12"] = ModbusClient.ConvertRegistersToString(d5VehicleCode12Data, 0, 40);
        //                int[] d5VehicleCode13Data = datas.Skip(852).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode13"] = ModbusClient.ConvertRegistersToString(d5VehicleCode13Data, 0, 40);
        //                int[] d5VehicleCode14Data = datas.Skip(872).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode14"] = ModbusClient.ConvertRegistersToString(d5VehicleCode14Data, 0, 40);
        //                int[] d5VehicleCode15Data = datas.Skip(892).Take(20).ToArray();
        //                s4PLCData["d5VehicleCode15"] = ModbusClient.ConvertRegistersToString(d5VehicleCode15Data, 0, 40);
        //                s4PLCData["d5Result"] = datas[912];
        //                s4PLCData["d5OEEPLC_FLAG"] = datas[923];  // PLC_FLAG 节拍接口
        //                s4PLCData["d5OEEMES_FLAG"] = datas[924];
        //                int[] d5OEEProductSNData = datas.Skip(925).Take(20).ToArray();
        //                s4PLCData["d5OEEProductSN"] = ModbusClient.ConvertRegistersToString(d5OEEProductSNData, 0, 40);
        //                s4PLCData["d5OEEType"] = datas[945];
        //                #endregion 一次性读取所有数据
        //                stopwatch2.Stop();

        //                #region 回写操作，写后清空flag
        //                PLCWriteData(Funs[plcNo], ref s4PLCData, ref s4PLCWriteData);
        //                #endregion 回写操作，写后清空flag

        //                // N801A-S4_1 弹夹扫码
        //                #region N801A-S4_1 弹夹扫码
        //                try
        //                {
        //                    int d1BulletclipScanCode = (int)s4PLCData["d1BulletclipScanCode"];
        //                    int d1BulletclipScanCodeOld = (int)s4PLCSignal_Old["d1BulletclipScanCode"];
        //                    if (d1BulletclipScanCode != d1BulletclipScanCodeOld)
        //                    {
        //                        if (d1BulletclipScanCode == 1)  // 0->1
        //                            Task.Run(() => S4_1弹夹扫码(plcNo, stationNameStr));  // MreTasks[1].Set();

        //                        s4PLCSignal_Old["d1BulletclipScanCode"] = s4PLCData["d1BulletclipScanCode"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2002, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 弹夹扫码出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_1 弹夹扫码

        //                // N801A-S4_1 载具扫码
        //                #region N801A-S4_1 载具扫码
        //                try
        //                {
        //                    int d1VehicleScanCode = (int)s4PLCData["d1VehicleScanCode"];
        //                    int d1VehicleScanCodeOld = (int)s4PLCSignal_Old["d1VehicleScanCode"];
        //                    if (d1VehicleScanCode != d1VehicleScanCodeOld)
        //                    {
        //                        if (d1VehicleScanCode == 1)  // 0->1
        //                            Task.Run(() => S4_1载具扫码(plcNo, stationNameStr));  // MreTasks[1].Set();

        //                        s4PLCSignal_Old["d1VehicleScanCode"] = s4PLCData["d1VehicleScanCode"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2033, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 载具扫码出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_1 载具扫码

        //                // N801A-S4_1 出站接口
        //                #region N801A-S4_1 出站接口
        //                try
        //                {
        //                    int d1PLC_FLAG = (int)s4PLCData["d1PLC_FLAG"];
        //                    int d1MES_FLAG = (int)s4PLCData["d1MES_FLAG"];
        //                    int d1PLC_FLAGOld = (int)s4PLCSignal_Old["d1PLC_FLAG"];
        //                    if (d1PLC_FLAG != d1PLC_FLAGOld)
        //                    {
        //                        if (d1PLC_FLAG == 1 && d1MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S4_1出站接口(plcNo, stationCode, stationName));  // MreTasks[3].Set();
        //                        else if (d1PLC_FLAG == 0 && d1MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2065, (short)0);

        //                        s4PLCSignal_Old["d1PLC_FLAG"] = s4PLCData["d1PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2065, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_1 出站接口
        //                // N801A-S4_1 节拍接口
        //                #region N801A-S4_1 节拍接口
        //                try
        //                {
        //                    int d1OEEPLC_FLAG = (int)s4PLCData["d1OEEPLC_FLAG"];
        //                    int d1OEEMES_FLAG = (int)s4PLCData["d1OEEMES_FLAG"];
        //                    int d1OEEPLC_FLAGOld = (int)s4PLCSignal_Old["d1OEEPLC_FLAG"];
        //                    if (d1OEEPLC_FLAG != d1OEEPLC_FLAGOld)
        //                    {
        //                        if (d1OEEPLC_FLAG == 1 && d1OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S4_1节拍接口(plcNo, stationNameStr));  // MreTasks[4].Set();
        //                        else if (d1OEEPLC_FLAG == 0 && d1OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2398, (short)0);

        //                        s4PLCSignal_Old["d1OEEPLC_FLAG"] = s4PLCData["d1OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2398, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_1 节拍接口

        //                // N801A-S4_2 桁架（查询标机中弹夹的状态） 数据
        //                #region N801A-S4_2 桁架（查询标机中弹夹的状态）
        //                try
        //                {
        //                    int d2BulletclipScanCode = (int)s4PLCData["d2BulletclipScanCode"];
        //                    int d2BulletclipScanCodeOld = (int)s4PLCSignal_Old["d2BulletclipScanCode"];
        //                    if (d2BulletclipScanCode != d2BulletclipScanCodeOld)
        //                    {
        //                        if (d2BulletclipScanCode == 1)  // 0->1
        //                            Task.Run(() => S4_2桁架(plcNo, stationNameStr2));  // MreTasks[1].Set();

        //                        s4PLCSignal_Old["d2BulletclipScanCode"] = s4PLCData["d2BulletclipScanCode"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2430, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr2, LogType.Error, $"PLC{plcNo}_{stationNameStr2} 桁架出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_2 桁架（查询标机中弹夹的状态）

        //                // N801A-S4_3 真空标机1 数据
        //                #region N801A-S4_3 真空标机1
        //                try
        //                {
        //                    int d3PLC_FLAG = (int)s4PLCData["d3PLC_FLAG"];
        //                    int d3MES_FLAG = (int)s4PLCData["d3MES_FLAG"];
        //                    int d3PLC_FLAGOld = (int)s4PLCSignal_Old["d3PLC_FLAG"];
        //                    if (d3PLC_FLAG != d3PLC_FLAGOld)
        //                    {
        //                        if (d3PLC_FLAG == 1 && d3MES_FLAG == 0)  // 0->1
        //                        {
        //                            int stationType = (int)s4PLCData["d3Type"];
        //                            if (stationType == 1)
        //                            {
        //                                // S4_3进站接口
        //                                Task.Run(() => S4_3进站接口(plcNo, stationNameStr3));  // MreTasks[3].Set();
        //                            }
        //                            else if (stationType == 2)
        //                            {
        //                                // S4_3出站接口
        //                                Task.Run(() => S4_3出站接口(plcNo, stationCode3, stationName3));  // MreTasks[3].Set();
        //                            }
        //                        }
        //                        else if (d3PLC_FLAG == 0 && d3MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2463, (short)0);

        //                        s4PLCSignal_Old["d3PLC_FLAG"] = s4PLCData["d3PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2463, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr3, LogType.Error, $"PLC{plcNo}_{stationNameStr3} 上传标机出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_3 真空标机1
        //                // N801A-S4_4 真空标机2 数据
        //                #region N801A-S4_4 真空标机2
        //                try
        //                {
        //                    int d4PLC_FLAG = (int)s4PLCData["d4PLC_FLAG"];
        //                    int d4MES_FLAG = (int)s4PLCData["d4MES_FLAG"];
        //                    int d4PLC_FLAGOld = (int)s4PLCSignal_Old["d4PLC_FLAG"];
        //                    if (d4PLC_FLAG != d4PLC_FLAGOld)
        //                    {
        //                        if (d4PLC_FLAG == 1 && d4MES_FLAG == 0)  // 0->1
        //                        {
        //                            int stationType = (int)s4PLCData["d4Type"];
        //                            if (stationType == 1)
        //                            {
        //                                // S4_4进站接口
        //                                Task.Run(() => S4_4进站接口(plcNo, stationNameStr4));  // MreTasks[3].Set();
        //                            }
        //                            else if (stationType == 2)
        //                            {
        //                                // S4_4出站接口
        //                                Task.Run(() => S4_4出站接口(plcNo, stationCode4, stationName4));  // MreTasks[3].Set();
        //                            }
        //                        }
        //                        else if (d4PLC_FLAG == 0 && d4MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2496, (short)0);

        //                        s4PLCSignal_Old["d4PLC_FLAG"] = s4PLCData["d4PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2496, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr4, LogType.Error, $"PLC{plcNo}_{stationNameStr4} 上传标机出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_4 真空标机2

        //                // N801A-S4_5 弹夹扫码 数据
        //                #region N801A-S4_5 弹夹扫码
        //                try
        //                {
        //                    int d5BulletclipScanCode = (int)s4PLCData["d5BulletclipScanCode"];
        //                    int d5BulletclipScanCodeOld = (int)s4PLCSignal_Old["d5BulletclipScanCode"];
        //                    if (d5BulletclipScanCode != d5BulletclipScanCodeOld)
        //                    {
        //                        if (d5BulletclipScanCode == 1)  // 0->1
        //                            Task.Run(() => S4_5弹夹扫码(plcNo, stationNameStr5));  // MreTasks[1].Set();

        //                        s4PLCSignal_Old["d5BulletclipScanCode"] = s4PLCData["d5BulletclipScanCode"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2528, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr5, LogType.Error, $"PLC{plcNo}_{stationNameStr5} 弹夹扫码出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_5 弹夹扫码
        //                // N801A-S4_5 载具扫码 数据
        //                #region N801A-S4_5 载具扫码
        //                try
        //                {
        //                    int d5VehicleScanCode = (int)s4PLCData["d5VehicleScanCode"];
        //                    int d5VehicleScanCodeOld = (int)s4PLCSignal_Old["d5VehicleScanCode"];
        //                    if (d5VehicleScanCode != d5VehicleScanCodeOld)
        //                    {
        //                        if (d5VehicleScanCode == 1)  // 0->1
        //                            Task.Run(() => S4_5载具扫码(plcNo, stationNameStr5));  // MreTasks[1].Set();

        //                        s4PLCSignal_Old["d5VehicleScanCode"] = s4PLCData["d5VehicleScanCode"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2559, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr5, LogType.Error, $"PLC{plcNo}_{stationNameStr5} 载具扫码出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_5 载具扫码
        //                // N801A-S4_5 出站接口（扫完所有码后立即上传） 数据
        //                #region N801A-S4_5 出站接口
        //                try
        //                {
        //                    int d5PLC_FLAG = (int)s4PLCData["d5PLC_FLAG"];
        //                    int d5MES_FLAG = (int)s4PLCData["d5MES_FLAG"];
        //                    int d5PLC_FLAGOld = (int)s4PLCSignal_Old["d5PLC_FLAG"];
        //                    if (d5PLC_FLAG != d5PLC_FLAGOld)
        //                    {
        //                        if (d5PLC_FLAG == 1 && d5MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S4_5出站接口(plcNo, stationCode5, stationName5));  // MreTasks[3].Set();
        //                        else if (d5PLC_FLAG == 0 && d5MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2591, (short)0);

        //                        s4PLCSignal_Old["d5PLC_FLAG"] = s4PLCData["d5PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2591, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr5, LogType.Error, $"PLC{plcNo}_{stationNameStr5} 上传出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_5 出站接口
        //                // N801A-S4_5 节拍接口 数据
        //                #region N801A-S4_5 节拍接口
        //                try
        //                {
        //                    int d5OEEPLC_FLAG = (int)s4PLCData["d5OEEPLC_FLAG"];
        //                    int d5OEEMES_FLAG = (int)s4PLCData["d5OEEMES_FLAG"];
        //                    int d5OEEPLC_FLAGOld = (int)s4PLCSignal_Old["d5OEEPLC_FLAG"];
        //                    if (d5OEEPLC_FLAG != d5OEEPLC_FLAGOld)
        //                    {
        //                        if (d5OEEPLC_FLAG == 1 && d5OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S4_5节拍接口(plcNo, stationNameStr5));  // MreTasks[4].Set();
        //                        else if (d5OEEPLC_FLAG == 0 && d5OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2924, (short)0);

        //                        s4PLCSignal_Old["d5OEEPLC_FLAG"] = s4PLCData["d5OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2924, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr5, LogType.Error, $"PLC{plcNo}_{stationNameStr5} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion N801A-S4_5 节拍接口

        //                #region 心跳
        //                try
        //                {
        //                    short states = 0;
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2000, states);
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上位机心跳写入出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 心跳

        //                UpdatePLCMonitor(1, plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI

        //                stopwatch1.Stop();
        //                //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
        //                OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr5, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr5 + "连接失败！");

        //                Funs[plcNo].Connect();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr5, LogType.Error, $"PLC{plcNo}_{stationNameStr5}运行出错！错误信息：" + ex.Message.ToString());

        //            Funs[plcNo].ReConnect();
        //        }

        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        /// <summary>
        /// [S4] 取放桁架 - S4_1弹夹扫码
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_1弹夹扫码(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // ZS 弹夹扫码
                string d1BulletclipCode = " "; // 扫到的码

                short d1BulletclipScanCode = 2;
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2003, d1BulletclipCode, 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2002, d1BulletclipScanCode);  // plc发送1代表请求扫码，上位机发送2代表扫码OK，3代表扫码NG，6代表上位机报警；7s未给结果代表扫码超时（扫不到码）；请求前200ms确保 扫码信号 为0；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1BulletclipScanCode";
                writeToPLC_Flag.Adress = 2002;
                writeToPLC_Flag.Value = d1BulletclipScanCode;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 穴位1物料SN(上位机写入)
                {
                    Name = "d1BulletclipCode",
                    Adress = 2003,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = d1BulletclipCode
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1BulletclipScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 弹夹扫码出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2003, " ", 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2002, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1BulletclipScanCode";
                writeToPLC_Flag.Adress = 2002;
                writeToPLC_Flag.Value = (short)6;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 穴位1物料SN(上位机写入)
                {
                    Name = "d1BulletclipCode",
                    Adress = 2003,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = " "
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1BulletclipScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_弹夹扫码;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_1载具扫码
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_1载具扫码(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // ZS 载具扫码
                string d1VehicleCode = ""; // 扫到的码
                short d1VehicleScanCode = 2;

                #region 进站

                if (d1VehicleScanCode == 2 && !string.IsNullOrEmpty(d1VehicleCode))
                {
                    #region 查询载具上的产品信息

                    string cavityData = string.Empty;
                    int snResult = XiaomiMES_RouteCommunication.SNQueryData(d1VehicleCode, ref cavityData);
                    if (string.IsNullOrEmpty(cavityData))
                        cavityData = "";
                    if (snResult != 0)
                    {
                        WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                        writeToPLC_Flag1.Name = "d1VehicleScanCode";
                        writeToPLC_Flag1.Adress = 2033;
                        writeToPLC_Flag1.Value = (short)6; // 6代表上位机报警
                        writeToPLC_Flag1.WriteToPLCDatas.Add(new WriteToPLC_Data()
                        {
                            Name = "d1VehicleCode",
                            Adress = 2034,
                            ValueType = PLCValueType.String,
                            ValueTypeStrLength = 20,
                            Value = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
                        });
                        SxPLCWriteData_Add(ref s4PLCWriteData, "d1VehicleScanCode", writeToPLC_Flag1);
                        stopwatch1.Stop();
                        AddMessage(LogType.Info,
                            stationNameStr + $"_载具扫码失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                            "ms");
                        return;
                    }

                    string[] cavitySNs = cavityData.Split('.');
                    string partNo = "";
                    if (cavitySNs != null && cavitySNs.Length >= 1)
                    {
                        partNo = cavitySNs[0];
                    }

                    #endregion 查询载具上的产品信息

                    List<TestItem> item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = d1VehicleCode,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "1",
                    });
                    stopwatch2.Start();
                    int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        partNo, item, out string errorMsg);
                    stopwatch2.Stop();
                    d1VehicleScanCode = (short)result == 1 ? d1VehicleScanCode : (short)result;
                }

                #endregion 进站

                //Funs[plcNo].WriteMultipleRegisters<string>(2034, d1VehicleCode, 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2033, d1VehicleScanCode);  // plc发送1代表请求扫码，上位机发送2代表扫码OK，3代表扫码NG，6代表上位机报警；7s未给结果代表扫码超时（扫不到码）；请求前200ms确保 扫码信号 为0；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1VehicleScanCode";
                writeToPLC_Flag.Adress = 2033;
                writeToPLC_Flag.Value = d1VehicleScanCode;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d1VehicleCode",
                    Adress = 2034,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = d1VehicleCode
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1VehicleScanCode", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 载具扫码出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2034, " ", 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2033, (short)6);  // 6代表上位机报警

                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1VehicleScanCode";
                writeToPLC_Flag.Adress = 2033;
                writeToPLC_Flag.Value = (short)6; // 6代表上位机报警
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d1VehicleCode",
                    Adress = 2034,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1VehicleScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_载具扫码;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_1出站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_1出站接口
        /// </summary>
        private void S4_1出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s4PLCData["d1ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                string d1VehicleCode1 = (string)s4PLCData["d1VehicleCode1"]; // 载具1码（弹夹穴位1）
                d1VehicleCode1 = d1VehicleCode1.Replace("\0", "");
                string d1VehicleCode2 = (string)s4PLCData["d1VehicleCode2"]; // 载具2码（弹夹穴位2）
                d1VehicleCode2 = d1VehicleCode2.Replace("\0", "");
                string d1VehicleCode3 = (string)s4PLCData["d1VehicleCode3"]; // 载具3码（弹夹穴位3）
                d1VehicleCode3 = d1VehicleCode3.Replace("\0", "");
                string d1VehicleCode4 = (string)s4PLCData["d1VehicleCode4"]; // 载具4码（弹夹穴位4）
                d1VehicleCode4 = d1VehicleCode4.Replace("\0", "");
                string d1VehicleCode5 = (string)s4PLCData["d1VehicleCode5"]; // 载具5码（弹夹穴位5）
                d1VehicleCode5 = d1VehicleCode5.Replace("\0", "");
                string d1VehicleCode6 = (string)s4PLCData["d1VehicleCode6"]; // 载具6码（弹夹穴位6）
                d1VehicleCode6 = d1VehicleCode6.Replace("\0", "");
                string d1VehicleCode7 = (string)s4PLCData["d1VehicleCode7"]; // 载具7码（弹夹穴位7）
                d1VehicleCode7 = d1VehicleCode7.Replace("\0", "");
                string d1VehicleCode8 = (string)s4PLCData["d1VehicleCode8"]; // 载具8码（弹夹穴位8）
                d1VehicleCode8 = d1VehicleCode8.Replace("\0", "");
                string d1VehicleCode9 = (string)s4PLCData["d1VehicleCode9"]; // 载具9码（弹夹穴位9）
                d1VehicleCode9 = d1VehicleCode9.Replace("\0", "");
                string d1VehicleCode10 = (string)s4PLCData["d1VehicleCode10"]; // 载具10码（弹夹穴位10）
                d1VehicleCode10 = d1VehicleCode10.Replace("\0", "");
                string d1VehicleCode11 = (string)s4PLCData["d1VehicleCode11"]; // 载具11码（弹夹穴位11）
                d1VehicleCode11 = d1VehicleCode11.Replace("\0", "");
                string d1VehicleCode12 = (string)s4PLCData["d1VehicleCode12"]; // 载具12码（弹夹穴位12）
                d1VehicleCode12 = d1VehicleCode12.Replace("\0", "");
                string d1VehicleCode13 = (string)s4PLCData["d1VehicleCode13"]; // 载具13码（弹夹穴位13）
                d1VehicleCode13 = d1VehicleCode13.Replace("\0", "");
                string d1VehicleCode14 = (string)s4PLCData["d1VehicleCode14"]; // 载具14码（弹夹穴位14）
                d1VehicleCode14 = d1VehicleCode14.Replace("\0", "");
                string d1VehicleCode15 = (string)s4PLCData["d1VehicleCode15"]; // 载具15码（弹夹穴位15）
                d1VehicleCode15 = d1VehicleCode15.Replace("\0", "");
                int d1Result = (int)s4PLCData["d1Result"]; // 产品结果
                bool pass = d1Result == 1;

                // 存 载具SN列表
                List<string> vehicleCodes = new List<string>()
                {
                    d1VehicleCode1, d1VehicleCode2, d1VehicleCode3, d1VehicleCode4, d1VehicleCode5,
                    d1VehicleCode6, d1VehicleCode7, d1VehicleCode8, d1VehicleCode9, d1VehicleCode10,
                    d1VehicleCode11, d1VehicleCode12, d1VehicleCode13, d1VehicleCode14, d1VehicleCode15
                };

                // 统一查 产品SN列表
                List<string> partNos = new List<string>();
                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        partNos.Add("");
                    else
                    {
                        string partNo = "";

                        #region 查询载具上的产品信息

                        string cavityData = string.Empty;
                        int snResult = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d1MES_FLAG";
                            writeToPLC_Flag1.Adress = 2065;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d1MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                                "ms");
                            return;
                        }

                        string[] cavitySNs = cavityData.Split('.');
                        if (cavitySNs != null && cavitySNs.Length >= 1)
                            partNo = cavitySNs[0];

                        #endregion 查询载具上的产品信息

                        partNos.Add(partNo);
                    }
                }

                // 统一上传
                stopwatch2.Start();
                List<int> results = new List<int>();
                for (int i = 0; i < partNos.Count; i++)
                {
                    string index = (i + 1).ToString(); // 弹夹穴号

                    if (string.IsNullOrEmpty(partNos[i]))
                        results.Add(1);
                    else
                    {
                        List<TestItem> items1 = new List<TestItem>();
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴号",
                            Parameter_value = index,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "产品结果",
                            Parameter_value = d1Result == 1 ? "OK" : "NG",
                            Parameter_unit = ""
                        });

                        int result1 = SwitctProcessData_old(stationNameStr, items1, equipmentCode, processItem
                            , workorder_code, mtltmrk, partNos[i], pass, sn, index);

                        results.Add(result1);
                    }
                }

                short result = 0;
                if (results.All(a => a == 1))
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                #region 存储绑定数据到 边线MES系统中

                if (result == 1)
                {
                    string data = string.Join(".", vehicleCodes);
                    int resultMesR = XiaomiMES_RouteCommunication.SNBindData(sn, data);
                    if (resultMesR != 0)
                    {
                        result = 4;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_[{equipmentCode}]{processItem}_出站接口失败！MES边线程序返回：{resultMesR}");
                    }
                }

                #endregion 存储绑定数据到 边线MES系统中

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2065, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1MES_FLAG";
                writeToPLC_Flag.Adress = 2065;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2065, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1MES_FLAG";
                writeToPLC_Flag.Adress = 2065;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}上传出站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_1节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_1节拍接口(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s4PLCData["d1OEEType"]).ToString(); // 节拍类型(plc写入)
                string d1OEEProductSN = (string)s4PLCData["d1OEEProductSN"]; // 载具SN
                d1OEEProductSN = d1OEEProductSN.Replace("\0", "");
                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    // MES_Flag
                    //Funs[plcNo].WriteMultipleRegisters<short>(2398, (short)4);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d1OEEMES_FLAG";
                    writeToPLC_Flag1.Adress = 2398;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d1OEEMES_FLAG", writeToPLC_Flag1);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                string d1OEEPartNo = string.Empty; // 物料码
                if (string.IsNullOrEmpty(d1OEEProductSN))
                {
                    stopwatch2.Start();
                    // MES_Flag
                    //Funs[plcNo].WriteMultipleRegisters<short>(2398, (short)1);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d1OEEMES_FLAG";
                    writeToPLC_Flag1.Adress = 2398;
                    writeToPLC_Flag1.Value = (short)1;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d1OEEMES_FLAG", writeToPLC_Flag1);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 上传内容无效已自动省略;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                        stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else
                {
                    // 查产品SN ZS
                    d1OEEPartNo = "Test";
                }

                short d1OEEMES_FLAG = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, d1OEEPartNo, d1OEEProductSN);

                d1OEEMES_FLAG = result.Item1;
                resultStr = result.Item2;

                stopwatch2.Start();
                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2398, d1OEEMES_FLAG);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1OEEMES_FLAG";
                writeToPLC_Flag.Adress = 2398;
                writeToPLC_Flag.Value = d1OEEMES_FLAG;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1OEEMES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2398, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d1OEEMES_FLAG";
                writeToPLC_Flag.Adress = 2398;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d1OEEMES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_2桁架
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_2桁架(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // ZS 弹夹扫码
                string d2BulletclipCode = " "; // 扫到的码
                short d2BulletclipStates = 1; // 弹夹状态(上位机写入)

                short d2BulletclipScanCode = 2;
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2432, d2BulletclipCode, 20);  // 扫到的码
                //Funs[plcNo].WriteMultipleRegisters<short>(2431, d2BulletclipStates);     // 弹夹状态(上位机写入)
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2430, d2BulletclipScanCode);  // plc发送1代表请求扫码，上位机发送2代表扫码OK，3代表扫码NG，6代表上位机报警；7s未给结果代表扫码超时（扫不到码）；请求前200ms确保 扫码信号 为0；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d2BulletclipScanCode";
                writeToPLC_Flag.Adress = 2430;
                writeToPLC_Flag.Value = d2BulletclipScanCode;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d2BulletclipCode",
                    Adress = 2432,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = d2BulletclipCode
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d2BulletclipStates",
                    Adress = 2431,
                    ValueType = PLCValueType.Short,
                    Value = d2BulletclipStates
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d2BulletclipScanCode", writeToPLC_Flag);

                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 弹夹扫码出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                Funs[plcNo].WriteMultipleRegisters<string>(2432, " ", 20);
                Funs[plcNo].WriteMultipleRegisters<short>(2431, (short)0);
                // MES_Flag
                Funs[plcNo].WriteMultipleRegisters<short>(2430, (short)6); // 6代表上位机报警

                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d2BulletclipScanCode";
                writeToPLC_Flag.Adress = 2430;
                writeToPLC_Flag.Value = (short)6;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d2BulletclipCode",
                    Adress = 2432,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = " "
                });
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data()
                {
                    Name = "d2BulletclipStates",
                    Adress = 2431,
                    ValueType = PLCValueType.Short,
                    Value = (short)0
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d2BulletclipScanCode", writeToPLC_Flag);

                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_弹夹扫码;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_3进站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_3进站接口（提升机1）
        /// </summary>
        private void S4_3进站接口(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            try
            {
                stopwatch1.Start();
                string sn = (string)s4PLCData["d3ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                int d3Result = (int)s4PLCData["d3Result"]; // 产品结果

                #region 查询15个载具码

                List<string> vehicleCodes = new List<string>(); // 15个载具码

                string vehicleData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref vehicleData);
                if (string.IsNullOrEmpty(vehicleData))
                    vehicleData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d3MES_FLAG";
                    writeToPLC_Flag1.Adress = 2463;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_进站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = vehicleData.Split('.');
                if (cavitySNs != null && cavitySNs.Length > 0)
                {
                    for (int i = 0; i < cavitySNs.Length; i++)
                    {
                        if (string.IsNullOrEmpty(cavitySNs[i]))
                            vehicleCodes.Add("");
                        else
                            vehicleCodes.Add(cavitySNs[i]);
                    }
                }

                #endregion 查询15个载具码

                #region 查询15个产品SN

                List<string> portNos = new List<string>(); // 15个产品SN

                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        portNos.Add("");
                    else
                    {
                        // 查询
                        string cavityData = string.Empty;
                        int snResult1 = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult1 != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d3MES_FLAG";
                            writeToPLC_Flag1.Adress = 2463;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult1};总用时" +
                                stopwatch1.ElapsedMilliseconds + "ms");
                            return;
                        }

                        string[] partSNs = cavityData.Split('.');
                        if (partSNs != null && partSNs.Length >= 1)
                            portNos.Add(partSNs[0]);
                        else
                            portNos.Add("");
                    }
                }

                #endregion 查询15个产品SN

                // 调用MES进站(最多15个)
                stopwatch2.Start();
                List<int> results = new int[15].ToList(); // 结果集；0代表产品为空
                for (int i = 0; i < vehicleCodes.Count; i++)
                {
                    // 循环进站
                    if (!string.IsNullOrEmpty(vehicleCodes[i]))
                    {
                        // 产品SN（物料码）校验
                        string portNo = portNos[i];
                        List<TestItem> item = new List<TestItem>();
                        item.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴位",
                            Parameter_value = (i + 1).ToString(),
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                        });
                        results[i] = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode,
                            GlobalContext.Mtltmrk, portNo, item, out string errorMsg);
                    }
                }

                stopwatch2.Stop();

                short result = 0;
                bool haveMesWarn = results.Contains(5);
                bool havePCWarn = results.Contains(6);
                if (haveMesWarn)
                    result = 2; // 5->2
                else if (havePCWarn)
                    result = 6; // 6->4
                else
                    result = 1;

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2463, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d3MES_FLAG";
                writeToPLC_Flag.Adress = 2463;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug, $"PLC{plcNo}_{stationNameStr}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Stop();

                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2463, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d3MES_FLAG";
                writeToPLC_Flag.Adress = 2463;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag);

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr}S4_3进站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_S4_3进站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_3出站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_3出站接口（提升机1）
        /// </summary>
        private void S4_3出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目

            try
            {
                stopwatch1.Start();
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s4PLCData["d3ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                int d3Result = (int)s4PLCData["d3Result"]; // 产品结果
                bool isPass = d3Result == 1; // 产品结果 bool

                #region 查询15个载具码

                List<string> vehicleCodes = new List<string>(); // 15个载具码

                string vehicleData = string.Empty;
                int snResult1 = XiaomiMES_RouteCommunication.SNQueryData(sn, ref vehicleData);
                if (string.IsNullOrEmpty(vehicleData))
                    vehicleData = "";
                if (snResult1 != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d3MES_FLAG";
                    writeToPLC_Flag1.Adress = 2463;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult1};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = vehicleData.Split('.');
                if (cavitySNs != null && cavitySNs.Length > 0)
                {
                    for (int i = 0; i < cavitySNs.Length; i++)
                    {
                        if (string.IsNullOrEmpty(cavitySNs[i]))
                            vehicleCodes.Add("");
                        else
                            vehicleCodes.Add(cavitySNs[i]);
                    }
                }

                #endregion 查询15个载具码

                // 统一查 产品SN列表
                List<string> partNos = new List<string>();
                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        partNos.Add("");
                    else
                    {
                        string partNo = "";

                        #region 查询载具上的产品信息

                        string cavityData = string.Empty;
                        int snResult = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d3MES_FLAG";
                            writeToPLC_Flag1.Adress = 2463;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                                "ms");
                            return;
                        }

                        string[] partSNs = cavityData.Split('.');
                        if (partSNs != null && partSNs.Length >= 1)
                            partNo = partSNs[0];

                        #endregion 查询载具上的产品信息

                        partNos.Add(partNo);
                    }
                }

                // 统一上传 - 调用MES出站
                stopwatch2.Start();
                List<int> results = new List<int>();
                for (int i = 0; i < partNos.Count; i++)
                {
                    string index = (i + 1).ToString(); // 弹夹穴号

                    if (string.IsNullOrEmpty(partNos[i]))
                        results.Add(1);
                    else
                    {
                        List<TestItem> items1 = new List<TestItem>();
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴号",
                            Parameter_value = index,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "产品结果",
                            Parameter_value = d3Result == 1 ? "OK" : "NG",
                            Parameter_unit = ""
                        });

                        int result1 = SwitctProcessData_old(stationNameStr, items1, equipmentCode, processItem
                            , workorder_code, mtltmrk, partNos[i], isPass, sn, index);

                        results.Add(result1);
                    }
                }

                short result = 0;
                if (results.All(a => a == 1))
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2463, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d3MES_FLAG";
                writeToPLC_Flag.Adress = 2463;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag);
                OnMessage(LogType.Debug, $"PLC{plcNo}_{stationNameStr}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2463, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d3MES_FLAG";
                writeToPLC_Flag.Adress = 2463;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag);

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr}S4_3出站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_S4_3出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_4进站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_4进站接口（提升机2）
        /// </summary>
        private void S4_4进站接口(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            try
            {
                stopwatch1.Start();
                string sn = (string)s4PLCData["d4ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                int d4Result = (int)s4PLCData["d4Result"]; // 产品结果

                #region 查询15个载具码

                List<string> vehicleCodes = new List<string>(); // 15个载具码

                string vehicleData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref vehicleData);
                if (string.IsNullOrEmpty(vehicleData))
                    vehicleData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d3MES_FLAG";
                    writeToPLC_Flag1.Adress = 2463;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_进站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = vehicleData.Split('.');
                if (cavitySNs != null && cavitySNs.Length > 0)
                {
                    for (int i = 0; i < cavitySNs.Length; i++)
                    {
                        if (string.IsNullOrEmpty(cavitySNs[i]))
                            vehicleCodes.Add("");
                        else
                            vehicleCodes.Add(cavitySNs[i]);
                    }
                }

                #endregion 查询15个载具码

                #region 查询15个产品SN

                List<string> portNos = new List<string>(); // 15个产品SN

                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        portNos.Add("");
                    else
                    {
                        // 查询
                        string cavityData = string.Empty;
                        int snResult1 = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult1 != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d3MES_FLAG";
                            writeToPLC_Flag1.Adress = 2463;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d3MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult1};总用时" +
                                stopwatch1.ElapsedMilliseconds + "ms");
                            return;
                        }

                        string[] partSNs = cavityData.Split('.');
                        if (partSNs != null && partSNs.Length >= 1)
                            portNos.Add(partSNs[0]);
                        else
                            portNos.Add("");
                    }
                }

                #endregion 查询15个产品SN

                // 调用MES进站(最多15个)
                stopwatch2.Start();
                List<int> results = new int[15].ToList(); // 结果集；0代表产品为空
                for (int i = 0; i < vehicleCodes.Count; i++)
                {
                    // 循环进站
                    if (!string.IsNullOrEmpty(vehicleCodes[i]))
                    {
                        // 产品SN（物料码）校验
                        string portNo = portNos[i];
                        List<TestItem> item = new List<TestItem>();
                        item.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴位",
                            Parameter_value = (i + 1).ToString(),
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                        });
                        item.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                        });
                        results[i] = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode,
                            GlobalContext.Mtltmrk, portNo, item, out string errorMsg);
                    }
                }

                stopwatch2.Stop();

                short result = 0;
                bool haveMesWarn = results.Contains(5);
                bool havePCWarn = results.Contains(6);
                if (haveMesWarn)
                    result = 2; // 5->2
                else if (havePCWarn)
                    result = 6; // 6->4
                else
                    result = 1;

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2496, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d4MES_FLAG";
                writeToPLC_Flag.Adress = 2496;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug, $"PLC{plcNo}_{stationNameStr}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Stop();

                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2496, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d4MES_FLAG";
                writeToPLC_Flag.Adress = 2496;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag);
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr}S4_4进站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_S4_4进站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_4出站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_4出站接口（提升机2）
        /// </summary>
        private void S4_4出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();
                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s4PLCData["d4ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                int d4Result = (int)s4PLCData["d4Result"]; // 产品结果
                bool isPass = d4Result == 1; // 产品结果 bool

                #region 查询15个载具码

                List<string> vehicleCodes = new List<string>(); // 15个载具码

                string vehicleData = string.Empty;
                int snResult1 = XiaomiMES_RouteCommunication.SNQueryData(sn, ref vehicleData);
                if (string.IsNullOrEmpty(vehicleData))
                    vehicleData = "";
                if (snResult1 != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d4MES_FLAG";
                    writeToPLC_Flag1.Adress = 2496;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult1};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = vehicleData.Split('.');
                if (cavitySNs != null && cavitySNs.Length > 0)
                {
                    for (int i = 0; i < cavitySNs.Length; i++)
                    {
                        if (string.IsNullOrEmpty(cavitySNs[i]))
                            vehicleCodes.Add("");
                        else
                            vehicleCodes.Add(cavitySNs[i]);
                    }
                }

                #endregion 查询15个载具码

                // 统一查 产品SN列表
                List<string> partNos = new List<string>();
                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        partNos.Add("");
                    else
                    {
                        string partNo = "";

                        #region 查询载具上的产品信息

                        string cavityData = string.Empty;
                        int snResult = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d4MES_FLAG";
                            writeToPLC_Flag1.Adress = 2496;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                                "ms");
                            return;
                        }

                        string[] partSNs = cavityData.Split('.');
                        if (partSNs != null && partSNs.Length >= 1)
                            partNo = partSNs[0];

                        #endregion 查询载具上的产品信息

                        partNos.Add(partNo);
                    }
                }

                // 调用MES出站
                stopwatch2.Start();
                // 统一上传
                List<int> results = new List<int>();
                for (int i = 0; i < partNos.Count; i++)
                {
                    string index = (i + 1).ToString(); // 弹夹穴号

                    if (string.IsNullOrEmpty(partNos[i]))
                        results.Add(1);
                    else
                    {
                        List<TestItem> items1 = new List<TestItem>();
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴号",
                            Parameter_value = index,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "产品结果",
                            Parameter_value = d4Result == 1 ? "OK" : "NG",
                            Parameter_unit = ""
                        });

                        int result1 = SwitctProcessData_old(stationNameStr, items1, equipmentCode, processItem
                            , workorder_code, mtltmrk, partNos[i], isPass, sn, index);

                        results.Add(result1);
                    }
                }

                short result = 0;
                if (results.All(a => a == 1))
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2496, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d4MES_FLAG";
                writeToPLC_Flag.Adress = 2496;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag);
                OnMessage(LogType.Debug, $"PLC{plcNo}_{stationNameStr}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2496, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d4MES_FLAG";
                writeToPLC_Flag.Adress = 2496;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d4MES_FLAG", writeToPLC_Flag);

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr}S4_4出站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_S4_4出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_5弹夹扫码
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_5弹夹扫码(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // ZS 弹夹扫码
                string d5BulletclipCode = " "; // 扫到的码

                short d5BulletclipScanCode = 2;
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2529, d5BulletclipCode, 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2528, d5BulletclipScanCode);  // plc发送1代表请求扫码，上位机发送2代表扫码OK，3代表扫码NG，6代表上位机报警；7s未给结果代表扫码超时（扫不到码）；请求前200ms确保 扫码信号 为0；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5BulletclipScanCode";
                writeToPLC_Flag.Adress = 2528;
                writeToPLC_Flag.Value = d5BulletclipScanCode;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "d5BulletclipCode",
                    Adress = 2529,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = d5BulletclipCode
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5BulletclipScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 弹夹扫码出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2529, " ", 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2528, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5BulletclipScanCode";
                writeToPLC_Flag.Adress = 2528;
                writeToPLC_Flag.Value = (short)6;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "d5BulletclipCode",
                    Adress = 2529,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = " "
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5BulletclipScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_弹夹扫码;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_5载具扫码
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_5载具扫码(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();

                // ZS 载具扫码
                string d5VehicleCode = " "; // 扫到的码
                short d5VehicleScanCode = 2;

                #region 进站

                if (d5VehicleScanCode == 2 && !string.IsNullOrEmpty(d5VehicleCode))
                {
                    // 查产品SN

                    #region 查询载具上的产品信息

                    string cavityData = string.Empty;
                    int snResult = XiaomiMES_RouteCommunication.SNQueryData(d5VehicleCode, ref cavityData);
                    if (string.IsNullOrEmpty(cavityData))
                        cavityData = "";
                    if (snResult != 0)
                    {
                        WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                        writeToPLC_Flag1.Name = "d5VehicleScanCode";
                        writeToPLC_Flag1.Adress = 2559;
                        writeToPLC_Flag1.Value = (short)6;
                        writeToPLC_Flag1.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                        {
                            Name = "d5VehicleCode",
                            Adress = 2560,
                            ValueType = PLCValueType.String,
                            ValueTypeStrLength = 20,
                            Value = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
                        });
                        SxPLCWriteData_Add(ref s4PLCWriteData, "d5VehicleScanCode", writeToPLC_Flag1);
                        stopwatch1.Stop();
                        AddMessage(LogType.Info,
                            stationNameStr + $"_载具扫码失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                            "ms");
                        return;
                    }

                    string[] cavitySNs = cavityData.Split('.');
                    string partNo = "";
                    if (cavitySNs != null && cavitySNs.Length >= 1)
                    {
                        partNo = cavitySNs[0];
                    }

                    #endregion 查询载具上的产品信息

                    List<TestItem> item = new List<TestItem>();
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具码",
                        Parameter_value = d5VehicleCode,
                    });
                    item.Add(new TestItem()
                    {
                        Parameter_name = "载具穴号",
                        Parameter_value = "1",
                    });
                    stopwatch2.Start();
                    int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                        partNo, item, out string errorMsg);
                    stopwatch2.Stop();
                    d5VehicleScanCode = (short)result == 1 ? d5VehicleScanCode : (short)result;
                }

                #endregion 进站

                //Funs[plcNo].WriteMultipleRegisters<string>(2560, d5VehicleCode, 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2559, d5VehicleScanCode);  // plc发送1代表请求扫码，上位机发送2代表扫码OK，3代表扫码NG，6代表上位机报警；7s未给结果代表扫码超时（扫不到码）；请求前200ms确保 扫码信号 为0；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5VehicleScanCode";
                writeToPLC_Flag.Adress = 2559;
                writeToPLC_Flag.Value = d5VehicleScanCode;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "d5VehicleCode",
                    Adress = 2560,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = d5VehicleCode
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5VehicleScanCode", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 载具扫码出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<string>(2560, " ", 20);
                //// MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2559, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5VehicleScanCode";
                writeToPLC_Flag.Adress = 2559;
                writeToPLC_Flag.Value = (short)6;
                writeToPLC_Flag.WriteToPLCDatas.Add(new WriteToPLC_Data() // 1空；2ng；3假产品；
                {
                    Name = "d5VehicleCode",
                    Adress = 2560,
                    ValueType = PLCValueType.String,
                    ValueTypeStrLength = 20,
                    Value = " "
                });
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5VehicleScanCode", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_载具扫码;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        // 上次采集到的SN
        //private string sn_S4_5出站接口 = string.Empty;
        /// <summary>
        /// [S4] 取放桁架 - S4_5出站接口
        /// </summary>
        private void S4_5出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s4PLCData["d5ProductSN"]; // 产品SN（弹夹码）
                sn = sn.Replace("\0", "");
                string d5VehicleCode1 = (string)s4PLCData["d5VehicleCode1"]; // 载具1码（弹夹穴位1）
                d5VehicleCode1 = d5VehicleCode1.Replace("\0", "");
                string d5VehicleCode2 = (string)s4PLCData["d5VehicleCode2"]; // 载具2码（弹夹穴位2）
                d5VehicleCode2 = d5VehicleCode2.Replace("\0", "");
                string d5VehicleCode3 = (string)s4PLCData["d5VehicleCode3"]; // 载具3码（弹夹穴位3）
                d5VehicleCode3 = d5VehicleCode3.Replace("\0", "");
                string d5VehicleCode4 = (string)s4PLCData["d5VehicleCode4"]; // 载具4码（弹夹穴位4）
                d5VehicleCode4 = d5VehicleCode4.Replace("\0", "");
                string d5VehicleCode5 = (string)s4PLCData["d5VehicleCode5"]; // 载具5码（弹夹穴位5）
                d5VehicleCode5 = d5VehicleCode5.Replace("\0", "");
                string d5VehicleCode6 = (string)s4PLCData["d5VehicleCode6"]; // 载具6码（弹夹穴位6）
                d5VehicleCode6 = d5VehicleCode6.Replace("\0", "");
                string d5VehicleCode7 = (string)s4PLCData["d5VehicleCode7"]; // 载具7码（弹夹穴位7）
                d5VehicleCode7 = d5VehicleCode7.Replace("\0", "");
                string d5VehicleCode8 = (string)s4PLCData["d5VehicleCode8"]; // 载具8码（弹夹穴位8）
                d5VehicleCode8 = d5VehicleCode8.Replace("\0", "");
                string d5VehicleCode9 = (string)s4PLCData["d5VehicleCode9"]; // 载具9码（弹夹穴位9）
                d5VehicleCode9 = d5VehicleCode9.Replace("\0", "");
                string d5VehicleCode10 = (string)s4PLCData["d5VehicleCode10"]; // 载具10码（弹夹穴位10）
                d5VehicleCode10 = d5VehicleCode10.Replace("\0", "");
                string d5VehicleCode11 = (string)s4PLCData["d5VehicleCode11"]; // 载具11码（弹夹穴位11）
                d5VehicleCode11 = d5VehicleCode11.Replace("\0", "");
                string d5VehicleCode12 = (string)s4PLCData["d5VehicleCode12"]; // 载具12码（弹夹穴位12）
                d5VehicleCode12 = d5VehicleCode12.Replace("\0", "");
                string d5VehicleCode13 = (string)s4PLCData["d5VehicleCode13"]; // 载具13码（弹夹穴位13）
                d5VehicleCode13 = d5VehicleCode13.Replace("\0", "");
                string d5VehicleCode14 = (string)s4PLCData["d5VehicleCode14"]; // 载具14码（弹夹穴位14）
                d5VehicleCode14 = d5VehicleCode14.Replace("\0", "");
                string d5VehicleCode15 = (string)s4PLCData["d5VehicleCode15"]; // 载具15码（弹夹穴位15）
                d5VehicleCode15 = d5VehicleCode15.Replace("\0", "");
                int d5Result = (int)s4PLCData["d5Result"]; // 产品结果
                bool pass = d5Result == 1;

                // 存 载具SN列表
                List<string> vehicleCodes = new List<string>()
                {
                    d5VehicleCode1, d5VehicleCode2, d5VehicleCode3, d5VehicleCode4, d5VehicleCode5,
                    d5VehicleCode6, d5VehicleCode7, d5VehicleCode8, d5VehicleCode9, d5VehicleCode10,
                    d5VehicleCode11, d5VehicleCode12, d5VehicleCode13, d5VehicleCode14, d5VehicleCode15
                };

                // 统一查 产品SN列表
                List<string> partNos = new List<string>();
                foreach (string vehicleCode in vehicleCodes)
                {
                    if (string.IsNullOrEmpty(vehicleCode))
                        partNos.Add("");
                    else
                    {
                        string partNo = "";

                        #region 查询载具上的产品信息

                        string cavityData = string.Empty;
                        int snResult = XiaomiMES_RouteCommunication.SNQueryData(vehicleCode, ref cavityData);
                        if (string.IsNullOrEmpty(cavityData))
                            cavityData = "";
                        if (snResult != 0)
                        {
                            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                            writeToPLC_Flag1.Name = "d5MES_FLAG";
                            writeToPLC_Flag1.Adress = 2591;
                            writeToPLC_Flag1.Value = (short)4;
                            SxPLCWriteData_Add(ref s4PLCWriteData, "d5MES_FLAG", writeToPLC_Flag1);
                            stopwatch1.Stop();
                            AddMessage(LogType.Info,
                                stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds +
                                "ms");
                            return;
                        }

                        string[] cavitySNs = cavityData.Split('.');
                        if (cavitySNs != null && cavitySNs.Length >= 1)
                            partNo = cavitySNs[0];

                        #endregion 查询载具上的产品信息

                        partNos.Add(partNo);
                    }
                }

                // 统一上传
                stopwatch2.Start();
                List<int> results = new List<int>();
                for (int i = 0; i < partNos.Count; i++)
                {
                    string index = (i + 1).ToString(); // 弹夹穴号

                    if (string.IsNullOrEmpty(partNos[i]))
                        results.Add(1);
                    else
                    {
                        List<TestItem> items1 = new List<TestItem>();
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹码",
                            Parameter_value = sn,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "弹夹穴号",
                            Parameter_value = index,
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具码",
                            Parameter_value = vehicleCodes[i],
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "载具穴号",
                            Parameter_value = "1",
                            Parameter_unit = ""
                        });
                        items1.Add(new TestItem()
                        {
                            Parameter_name = "产品结果",
                            Parameter_value = d5Result == 1 ? "OK" : "NG",
                            Parameter_unit = ""
                        });

                        int result1 = SwitctProcessData_old(stationNameStr, items1, equipmentCode, processItem
                            , workorder_code, mtltmrk, partNos[i], pass, sn, index);
                        results.Add(result1);
                    }
                }

                short result = 0;
                if (results.All(a => a == 1))
                    result = 1;
                else if (results.Contains(3))
                    result = 3;
                else if (results.Contains(2))
                    result = 2;
                else if (results.Contains(4))
                    result = 4;
                else
                    result = 4;
                stopwatch2.Stop();

                #region 存储绑定数据到 边线MES系统中

                if (result == 1)
                {
                    // 删除绑定信息
                    int resultMesR = XiaomiMES_RouteCommunication.SNDeleteData(sn);
                    if (resultMesR != 0)
                    {
                        result = 4;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_[{equipmentCode}]{processItem}_出站接口失败！MES边线程序返回：{resultMesR}");
                    }
                }

                #endregion 存储绑定数据到 边线MES系统中

                // MES_Flag 为4MES报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2591, result);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5MES_FLAG";
                writeToPLC_Flag.Adress = 2591;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2591, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5MES_FLAG";
                writeToPLC_Flag.Adress = 2591;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}上传出站接口！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S4] 取放桁架 - S4_5节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S4_5节拍接口(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            string resultStr = string.Empty;
            try
            {
                stopwatch1.Start();
                string oEEType = ((int)s4PLCData["d5OEEType"]).ToString(); // 节拍类型(plc写入)
                string d5OEEProductSN = (string)s4PLCData["d5OEEProductSN"]; // 载具SN
                d5OEEProductSN = d5OEEProductSN.Replace("\0", "");
                bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
                if (!actionBool)
                {
                    stopwatch2.Start();
                    // MES_Flag
                    //Funs[plcNo].WriteMultipleRegisters<short>(2924, (short)4);  // 上位机；发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d5OEEMES_FLAG";
                    writeToPLC_Flag1.Adress = 2924;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d5OEEMES_FLAG", writeToPLC_Flag1);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
                        "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }

                string d5OEEPartNo = string.Empty; // 物料码
                if (string.IsNullOrEmpty(d5OEEProductSN))
                {
                    stopwatch2.Start();
                    // MES_Flag
                    //Funs[plcNo].WriteMultipleRegisters<short>(2924, (short)1);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "d5OEEMES_FLAG";
                    writeToPLC_Flag1.Adress = 2924;
                    writeToPLC_Flag1.Value = (short)1;
                    SxPLCWriteData_Add(ref s4PLCWriteData, "d5OEEMES_FLAG", writeToPLC_Flag1);
                    stopwatch2.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_节拍接口-- 上传内容无效已自动省略;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                        stopwatch2.ElapsedMilliseconds + "ms");
                    return;
                }
                else
                {
                    // 查产品SN
                    d5OEEPartNo = "Test"; // ZS
                }

                short d5OEEMES_FLAG = 0;
                // 上传OEE
                (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, d5OEEPartNo, d5OEEProductSN);

                d5OEEMES_FLAG = result.Item1;
                resultStr = result.Item2;

                stopwatch2.Start();
                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2924, d5OEEMES_FLAG);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5OEEMES_FLAG";
                writeToPLC_Flag.Adress = 2924;
                writeToPLC_Flag.Value = d5OEEMES_FLAG;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5OEEMES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2924, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "d5OEEMES_FLAG";
                writeToPLC_Flag.Adress = 2924;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s4PLCWriteData, "d5OEEMES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion [S4] 取放桁架

        #endregion PLC4 刘果段

        #region PLC5 张超凡

        #region [S5] Tray盘下料装备

        /// <summary>
        /// S5工位的数据- 触发信号上次的值
        /// </summary>
        private Dictionary<string, object> s5PLCSignal_Old = new Dictionary<string, object>();

        /// <summary>
        /// S5工位的数据（含触发信号）
        /// </summary>
        private Dictionary<string, object> s5PLCData = new Dictionary<string, object>();

        /// <summary>
        /// S5工位的数据- 回写点位
        /// </summary>
        private Dictionary<string, WriteToPLC_Flag> s5PLCWriteData = new Dictionary<string, WriteToPLC_Flag>();

        /// <summary>
        /// [S5] Tray盘下料装备
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        //private void ReadStation_S5(int plcNo)
        //{
        //    // [S1] Tray盘上料装备
        //    // [S2] FCT
        //    // [S3] 值板机
        //    // [S4_1] 载具下线装备 [S4_5] 载具上线装备
        //    // [S5] Tray盘下料装备
        //    /// 上位机心跳
        //    /// 获取设备报警数据与状态信息
        //    string stationCode = "[S5]";
        //    string stationName = "Tray盘下料装备";
        //    string stationNameStr = stationCode + stationName;

        //    #region 创建字典
        //    // 触发信号字典 赋值
        //    s5PLCSignal_Old.Add("e1PLC_FLAG_Check", 0);          // PLC_FLAG 进站校验
        //    s5PLCSignal_Old.Add("e1PLC_FLAG", 0);                // PLC_FLAG 出站接口
        //    s5PLCSignal_Old.Add("e1OEEPLC_FLAG", 0);             // PLC_FLAG 节拍接口
        //    s5PLCSignal_Old.Add("e1AGVUpCall", 0);               // AGV上料叫agv信号 AGV上料
        //    s5PLCSignal_Old.Add("e1AGVUpEnd", 0);                // AGV上料完成信号 AGV上料
        //    s5PLCSignal_Old.Add("e1AGVDownCall", 0);             // AGV下料叫agv信号 AGV下料
        //    s5PLCSignal_Old.Add("e1AGVDownEnd", 0);              // AGV下料完成信号 AGV下料

        //    // PLC数据字典 赋值
        //    s5PLCData.Add("e1PLC_FLAG_Check", 0);    // PLC_FLAG 进站校验
        //    s5PLCData.Add("e1MES_FLAG_Check", 0);    // MES_FLAG
        //    s5PLCData.Add("e1ProductSN_Check", "");  // 

        //    s5PLCData.Add("e1PLC_FLAG", 0);      // PLC_FLAG 出站接口
        //    s5PLCData.Add("e1MES_FLAG", 0);      // MES_FLAG
        //    s5PLCData.Add("e1ProductSN", "");    // 产品SN
        //    s5PLCData.Add("e1PartNo", "");       // 物料码
        //    s5PLCData.Add("e1Result", 0);        // 产品结果

        //    s5PLCData.Add("e1OEEPLC_FLAG", 0);  // PLC_FLAG 节拍接口
        //    s5PLCData.Add("e1OEEMES_FLAG", 0);  // MES_FLAG
        //    s5PLCData.Add("e1OEEProductSN", "");// 产品SN（载具SN）
        //    s5PLCData.Add("e1OEEType", 0);      // 节拍类型(plc写入) 

        //    s5PLCData.Add("e1AGVUpCall", 0);   // AGV上料叫agv信号 AGV上料
        //    s5PLCData.Add("e1AGVUpStart", 0);  // AGV上料开始信号
        //    s5PLCData.Add("e1AGVUpEnd", 0);    // AGV上料完成信号
        //    s5PLCData.Add("e1AGVDownCall", 0);   // AGV下料叫agv信号 AGV下料
        //    s5PLCData.Add("e1AGVDownStart", 0);  // AGV下料开始信号
        //    s5PLCData.Add("e1AGVDownEnd", 0);    // AGV下料完成信号
        //    #endregion 创建字典

        //    while (IsRun)
        //    {
        //        try
        //        {
        //            if (!GlobalContext._IsCon_Funs5)
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);
        //                continue;
        //            }
        //            if (Funs[plcNo].IsConnected)  // 检查PLC是否已连接上
        //            {
        //                Stopwatch stopwatch1 = new Stopwatch();
        //                Stopwatch stopwatch2 = new Stopwatch();
        //                stopwatch1.Start();

        //                stopwatch2.Start();
        //                #region 一次性读取所有数据
        //                int[] data1 = Funs[plcNo].ReadHoldingRegisters(2000, 100);
        //                int[] data2 = Funs[plcNo].ReadHoldingRegisters(2100, 46);
        //                int[] datas = data1.Concat(data2).ToArray();

        //                s5PLCData["e1PLC_FLAG_Check"] = datas[2];  // 进站校验
        //                s5PLCData["e1MES_FLAG_Check"] = datas[3];
        //                int[] e1ProductSN_CheckData = datas.Skip(4).Take(20).ToArray();
        //                s5PLCData["e1ProductSN_Check"] = ModbusClient.ConvertRegistersToString(e1ProductSN_CheckData, 0, 40);
        //                s5PLCData["e1PLC_FLAG"] = datas[34];        // 出站接口
        //                s5PLCData["e1MES_FLAG"] = datas[35];
        //                int[] e1ProductSNData = datas.Skip(36).Take(20).ToArray();
        //                s5PLCData["e1ProductSN"] = ModbusClient.ConvertRegistersToString(e1ProductSNData, 0, 40);
        //                int[] e1PartNoData = datas.Skip(56).Take(20).ToArray();
        //                s5PLCData["e1PartNo"] = ModbusClient.ConvertRegistersToString(e1PartNoData, 0, 40);
        //                s5PLCData["e1Result"] = datas[76];

        //                s5PLCData["e1OEEPLC_FLAG"] = datas[87];  // 节拍接口
        //                s5PLCData["e1OEEMES_FLAG"] = datas[88];
        //                int[] e1OEEProductSNData = datas.Skip(89).Take(20).ToArray();
        //                s5PLCData["e1OEEProductSN"] = ModbusClient.ConvertRegistersToString(e1OEEProductSNData, 0, 40);
        //                s5PLCData["e1OEEType"] = datas[109];

        //                s5PLCData["e1AGVUpCall"] = datas[120];      // AGV上料
        //                s5PLCData["e1AGVUpStart"] = datas[121];
        //                s5PLCData["e1AGVUpEnd"] = datas[122];

        //                s5PLCData["e1AGVDownCall"] = datas[133];  // AGV下料
        //                s5PLCData["e1AGVDownStart"] = datas[134];
        //                s5PLCData["e1AGVDownEnd"] = datas[135];
        //                #endregion 一次性读取所有数据
        //                stopwatch2.Stop();

        //                #region 回写操作，写后清空flag
        //                PLCWriteData(Funs[plcNo], ref s5PLCData, ref s5PLCWriteData);
        //                #endregion 回写操作，写后清空flag

        //                #region 进站校验
        //                try
        //                {
        //                    int e1PLC_FLAG_Check = (int)s5PLCData["e1PLC_FLAG_Check"];
        //                    int e1MES_FLAG_Check = (int)s5PLCData["e1MES_FLAG_Check"];
        //                    int e1PLC_FLAG_CheckOld = (int)s5PLCSignal_Old["e1PLC_FLAG_Check"];
        //                    if (e1PLC_FLAG_Check != e1PLC_FLAG_CheckOld)
        //                    {
        //                        if (e1PLC_FLAG_Check == 1 && e1MES_FLAG_Check == 0)  // 0->1
        //                            Task.Run(() => S5进站校验(plcNo, stationNameStr));  // MreTasks[2].Set();
        //                        else if (e1PLC_FLAG_Check == 0 && e1MES_FLAG_Check != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)0);

        //                        s5PLCSignal_Old["e1PLC_FLAG_Check"] = s5PLCData["e1PLC_FLAG_Check"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 进站校验出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 进站校验

        //                #region 出站接口
        //                try
        //                {
        //                    int e1PLC_FLAG = (int)s5PLCData["e1PLC_FLAG"];
        //                    int e1MES_FLAG = (int)s5PLCData["e1MES_FLAG"];
        //                    int e1PLC_FLAGOld = (int)s5PLCSignal_Old["e1PLC_FLAG"];
        //                    if (e1PLC_FLAG != e1PLC_FLAGOld)
        //                    {
        //                        if (e1PLC_FLAG == 1 && e1MES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S5出站接口(plcNo, stationCode, stationName));  // MreTasks[3].Set();
        //                        else if (e1PLC_FLAG == 0 && e1MES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2035, (short)0);

        //                        s5PLCSignal_Old["e1PLC_FLAG"] = s5PLCData["e1PLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2035, (short)6);  // 6代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传出站接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 出站接口

        //                #region 节拍接口
        //                try
        //                {
        //                    int e1OEEPLC_FLAG = (int)s5PLCData["e1OEEPLC_FLAG"];
        //                    int e1OEEMES_FLAG = (int)s5PLCData["e1OEEMES_FLAG"];
        //                    int e1OEEPLC_FLAGOld = (int)s5PLCSignal_Old["e1OEEPLC_FLAG"];
        //                    if (e1OEEPLC_FLAG != e1OEEPLC_FLAGOld)
        //                    {
        //                        if (e1OEEPLC_FLAG == 1 && e1OEEMES_FLAG == 0)  // 0->1
        //                            Task.Run(() => S5节拍接口(plcNo, stationNameStr));  // MreTasks[4].Set();
        //                        else if (e1OEEPLC_FLAG == 0 && e1OEEMES_FLAG != 0)
        //                            Funs[plcNo].WriteMultipleRegisters<short>(2088, (short)0);

        //                        s5PLCSignal_Old["e1OEEPLC_FLAG"] = s5PLCData["e1OEEPLC_FLAG"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2088, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上传节拍接口出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 节拍接口

        //                #region AGV上料
        //                // AGV上料叫AGV信号
        //                try
        //                {
        //                    int e1AGVUpCall = (int)s5PLCData["e1AGVUpCall"];
        //                    int e1AGVUpCallOld = (int)s5PLCSignal_Old["e1AGVUpCall"];
        //                    if (e1AGVUpCall != e1AGVUpCallOld)
        //                    {
        //                        if (e1AGVUpCall == 1)  // 0->1
        //                            Task.Run(() => S5AGV上料叫agv(plcNo, stationNameStr));  // MreTasks[5].Set();

        //                        s5PLCSignal_Old["e1AGVUpCall"] = s5PLCData["e1AGVUpCall"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2120, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV上料叫agv出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                // AGV上料完成信号
        //                try
        //                {
        //                    int e1AGVUpEnd = (int)s5PLCData["e1AGVUpEnd"];
        //                    int e1AGVUpEndOld = (int)s5PLCSignal_Old["e1AGVUpEnd"];
        //                    if (e1AGVUpEnd != e1AGVUpEndOld)
        //                    {
        //                        if (e1AGVUpEnd == 1)  // 0->1
        //                            Task.Run(() => S5AGV上料完成(plcNo, stationNameStr));  // MreTasks[6].Set();

        //                        s5PLCSignal_Old["e1AGVUpEnd"] = s5PLCData["e1AGVUpEnd"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2122, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV上料完成信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion AGV上料

        //                #region AGV下料
        //                // AGV下料叫agv信号
        //                try
        //                {
        //                    int e1AGVDownCall = (int)s5PLCData["e1AGVDownCall"];
        //                    int e1AGVDownCallOld = (int)s5PLCSignal_Old["e1AGVDownCall"];
        //                    if (e1AGVDownCall != e1AGVDownCallOld)
        //                    {
        //                        if (e1AGVDownCall == 1)  // 0->1
        //                            Task.Run(() => S5AGV下料叫agv(plcNo, stationNameStr));  // MreTasks[7].Set();

        //                        s5PLCSignal_Old["e1AGVDownCall"] = s5PLCData["e1AGVDownCall"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2133, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV下料叫agv信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                // AGV下料完成信号
        //                try
        //                {
        //                    int e1AGVDownEnd = (int)s5PLCData["e1AGVDownEnd"];
        //                    int e1AGVDownEndOld = (int)s5PLCSignal_Old["e1AGVDownEnd"];
        //                    if (e1AGVDownEnd != e1AGVDownEndOld)
        //                    {
        //                        if (e1AGVDownEnd == 1)  // 0->1
        //                            Task.Run(() => S5AGV下料完成(plcNo, stationNameStr));  // MreTasks[8].Set();

        //                        s5PLCSignal_Old["e1AGVDownEnd"] = s5PLCData["e1AGVDownEnd"];
        //                    }
        //                }
        //                catch (Exception ex)
        //                {
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2135, (short)4);  // 4代表上位机报警

        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} AGV下料完成信号出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion AGV下料

        //                #region 心跳
        //                try
        //                {
        //                    short states = 0;
        //                    Funs[plcNo].WriteMultipleRegisters<short>(2000, states);
        //                }
        //                catch (Exception ex)
        //                {
        //                    string str = ex.StackTrace;
        //                    AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr} 上位机心跳写入出错！错误信息：" + ex.Message + "异常位置：" + str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
        //                }
        //                #endregion 心跳

        //                UpdatePLCMonitor(1, plcNo, 1);  // 更新PLC状态的UI  // 更新PLC状态的UI

        //                stopwatch1.Stop();
        //                //if (stopwatch1.ElapsedMilliseconds > 60)  // ZS 稳定后取消注释该项
        //                OnMessage(LogType.Info, $"循环读取PLC数据一次，总用时{stopwatch1.ElapsedMilliseconds}ms[读取用时{stopwatch2.ElapsedMilliseconds}ms]");
        //            }
        //            else
        //            {
        //                UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //                AddMessage_Station(stationNameStr, LogType.Info, "PLC" + plcNo.ToString() + "_" + stationNameStr + "连接失败！");

        //                Funs[plcNo].Connect();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            UpdatePLCMonitor(1, plcNo, 0);  // 更新PLC状态的UI
        //            AddMessage_Station(stationNameStr, LogType.Error, $"PLC{plcNo}_{stationNameStr}运行出错！错误信息：" + ex.Message.ToString());

        //            Funs[plcNo].ReConnect();
        //        }

        //        Thread.Sleep(IntervalReadPLC);
        //    }
        //}

        /// <summary>
        /// [S5] Tray盘下料装备 - 进站校验
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S5进站校验(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                string sn = (string)s5PLCData["e1ProductSN_Check"]; // 产品SN（载具码）
                sn = sn.Replace("\0", "");

                // 获取产品SN By 载具码

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "e1MES_FLAG_Check";
                    writeToPLC_Flag1.Adress = 2003;
                    writeToPLC_Flag1.Value = (short)6;
                    SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG_Check", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_进站校验失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = cavityData.Split('.');
                string partNo = string.Empty;
                if (cavitySNs != null && cavitySNs.Length >= 1)
                    partNo = cavitySNs[0];

                #endregion 查询载具上的产品信息

                // 产品SN（物料码）校验
                List<TestItem> item = new List<TestItem>();
                item.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = sn,
                });
                item.Add(new TestItem()
                {
                    Parameter_name = "载具穴号",
                    Parameter_value = "1",
                });

                stopwatch2.Start();
                int result = SaveStationInData(stationNameStr, GlobalContext.WorkOrderCode, GlobalContext.Mtltmrk,
                    partNo, item, out string errorMsg);
                stopwatch2.Stop();
                short e1MES_FLAG_Check = (short)result;

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, e1MES_FLAG_Check);  // 上位机发送1代表OK可以进站；2代表不需要进站；3代表本站返修料；5客户MES报警；6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = e1MES_FLAG_Check;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG_Check", writeToPLC_Flag);
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} 进站校验出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // MES_Flag
                //Funs[plcNo].WriteMultipleRegisters<short>(2003, (short)6);  // 6代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1MES_FLAG_Check";
                writeToPLC_Flag.Adress = 2003;
                writeToPLC_Flag.Value = (short)6;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG_Check", writeToPLC_Flag);
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_进站校验;总用时" + stopwatch1.ElapsedMilliseconds + "ms;调用MES用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S5] Tray盘下料装备 - 出站接口
        /// </summary>
        /// <param name="plcNo"></param>
        /// <param name="stationCode"></param>
        /// <param name="stationName"></param>
        private void S5出站接口(int plcNo, string stationCode, string stationName)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();

            string equipmentCode = GlobalContext.LineCode + "-" + stationCode; // 设备编号
            string stationNameStr = stationCode + stationName;
            string processItem = stationName; // 测试项目
            try
            {
                stopwatch1.Start();

                string workorder_code = GlobalContext.WorkOrderCode; // 工单号
                //string batch_num = GlobalContext.BatchNumber;         // 批次号
                string mtltmrk = GlobalContext.Mtltmrk; // 产品型号
                //string plcDate_YMD = DateTime.Now.ToString("yyyyMMdd");

                string sn = (string)s5PLCData["e1ProductSN"]; // 产品SN（载具SN码）
                sn = sn.Replace("\0", "");
                //string partNo = (string)s5PLCData["e1PartNo"];   // 物料码
                //partNo = partNo.Replace("\0", "");

                #region 查询载具上的产品信息

                string cavityData = string.Empty;
                int snResult = XiaomiMES_RouteCommunication.SNQueryData(sn, ref cavityData);
                if (string.IsNullOrEmpty(cavityData))
                    cavityData = "";
                if (snResult != 0)
                {
                    WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
                    writeToPLC_Flag1.Name = "e1MES_FLAG";
                    writeToPLC_Flag1.Adress = 2035;
                    writeToPLC_Flag1.Value = (short)4;
                    SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG", writeToPLC_Flag1);
                    stopwatch1.Stop();
                    AddMessage(LogType.Info,
                        stationNameStr + $"_出站接口失败！MES边线软件返回结果{snResult};总用时" + stopwatch1.ElapsedMilliseconds + "ms");
                    return;
                }

                string[] cavitySNs = cavityData.Split('.');
                string partNo = string.Empty;
                if (cavitySNs != null && cavitySNs.Length >= 1)
                    partNo = cavitySNs[0];

                #endregion 查询载具上的产品信息

                int e1Result = (int)s5PLCData["e1Result"]; // 产品结果
                bool pass = e1Result == 1;

                stopwatch2.Start();
                // 上传MES
                List<TestItem> items = new List<TestItem>();
                items.Add(new TestItem()
                {
                    Parameter_name = "载具码",
                    Parameter_value = sn,
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "载具穴号",
                    Parameter_value = "1",
                    Parameter_unit = ""
                });
                items.Add(new TestItem()
                {
                    Parameter_name = "产品结果",
                    Parameter_value = e1Result == 1 ? "OK" : "NG",
                    Parameter_unit = ""
                });

                int result1 = SwitctProcessData_old(stationNameStr, items, equipmentCode, processItem
                    , workorder_code, mtltmrk, partNo, pass, sn, "1");
                //int result = result1 == 1 ? 1 : (GlobalContext.IsSendProcessData ? 4 : 1);
                short result = result1 == 1 ? (short)1 : (short)3;
                stopwatch2.Stop();

                #region 存储绑定数据到 边线MES系统中

                if (result == 1)
                {
                    // 删除绑定信息
                    int resultMesR = XiaomiMES_RouteCommunication.SNDeleteData(sn);
                    if (resultMesR != 0)
                    {
                        result = 4;
                        AddMessage_Station(stationNameStr, LogType.Error,
                            $"PLC{plcNo}_[{equipmentCode}]{processItem}_出站接口失败！MES边线程序返回：{resultMesR}");
                    }
                }

                #endregion 存储绑定数据到 边线MES系统中

                // MES_Flag 为MES报错
                // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
                //Funs[plcNo].WriteMultipleRegisters<short>(2035, result);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1MES_FLAG";
                writeToPLC_Flag.Adress = 2035;
                writeToPLC_Flag.Value = result;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG", writeToPLC_Flag);

                OnMessage(LogType.Debug,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                stopwatch2.Restart();
                // MES_Flag 为4上位机报错
                //Funs[plcNo].WriteMultipleRegisters<short>(2035, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1MES_FLAG";
                writeToPLC_Flag.Adress = 2035;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1MES_FLAG", writeToPLC_Flag);
                stopwatch2.Stop();

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_[{equipmentCode}]{processItem}上传出站接口报错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_出站接口;总用时" + stopwatch1.ElapsedMilliseconds + "ms;上传接口用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S5] Tray盘下料装备 - 节拍接口
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        //private void S5节拍接口(int plcNo, string stationNameStr)
        //{
        //    Stopwatch stopwatch1 = new Stopwatch();
        //    Stopwatch stopwatch2 = new Stopwatch();
        //    string resultStr = string.Empty;
        //    try
        //    {
        //        stopwatch1.Start();
        //        string oEEType = ((int)s5PLCData["e1OEEType"]).ToString(); // 节拍类型(plc写入)
        //        string e1OEEProductSN = (string)s5PLCData["e1OEEProductSN"]; // 载具SN
        //        e1OEEProductSN = e1OEEProductSN.Replace("\0", "");
        //        bool actionBool = Enum.TryParse(oEEType, out XiaomiDeviceOEE deviceOEE);
        //        if (!actionBool)
        //        {
        //            stopwatch2.Start();
        //            // MES_Flag
        //            //Funs[plcNo].WriteMultipleRegisters<short>(2088, (short)4);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
        //            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
        //            writeToPLC_Flag1.Name = "e1OEEMES_FLAG";
        //            writeToPLC_Flag1.Adress = 2088;
        //            writeToPLC_Flag1.Value = (short)4;
        //            SxPLCWriteData_Add(ref s5PLCWriteData, "e1OEEMES_FLAG", writeToPLC_Flag1);
        //            stopwatch2.Stop();
        //            AddMessage(LogType.Info,
        //                stationNameStr + $"_节拍接口-- 设备上传了未识别的节拍类型【{oEEType}】请检查;总用时" + stopwatch1.ElapsedMilliseconds +
        //                "ms;写入用时" + stopwatch2.ElapsedMilliseconds + "ms");
        //            return;
        //        }

        //        string e1OEEPartNo = string.Empty; // 物料码
        //        if (string.IsNullOrEmpty(e1OEEProductSN))
        //        {
        //            stopwatch2.Start();
        //            // MES_Flag
        //            //Funs[plcNo].WriteMultipleRegisters<short>(2088, (short)1);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
        //            WriteToPLC_Flag writeToPLC_Flag1 = new WriteToPLC_Flag(); // MES_Flag
        //            writeToPLC_Flag1.Name = "e1OEEMES_FLAG";
        //            writeToPLC_Flag1.Adress = 2088;
        //            writeToPLC_Flag1.Value = (short)1;
        //            SxPLCWriteData_Add(ref s5PLCWriteData, "e1OEEMES_FLAG", writeToPLC_Flag1);
        //            stopwatch2.Stop();
        //            AddMessage(LogType.Info,
        //                stationNameStr + $"_节拍接口-- 上传内容无效已自动省略;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
        //                stopwatch2.ElapsedMilliseconds + "ms");
        //            return;
        //        }
        //        else
        //        {
        //            // 查产品SN
        //            e1OEEPartNo = "Test"; // ZS
        //        }

        //        short e1OEEMES_FLAG = 0;
        //        // 上传OEE
        //        (short, string) result = SaveOEEData(plcNo, stationNameStr, deviceOEE, e1OEEPartNo, e1OEEProductSN);

        //        e1OEEMES_FLAG = result.Item1;
        //        resultStr = result.Item2;

        //        stopwatch2.Start();
        //        // MES_Flag
        //        //Funs[plcNo].WriteMultipleRegisters<short>(2088, e1OEEMES_FLAG);  // 上位机发送1代表OK；2代表上传客户MES失败；3代表上位机保存数据失败；4代表上位机报警；
        //        WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
        //        writeToPLC_Flag.Name = "e1OEEMES_FLAG";
        //        writeToPLC_Flag.Adress = 2088;
        //        writeToPLC_Flag.Value = e1OEEMES_FLAG;
        //        SxPLCWriteData_Add(ref s5PLCWriteData, "e1OEEMES_FLAG", writeToPLC_Flag);
        //        stopwatch2.Stop();
        //    }
        //    catch (Exception ex)
        //    {
        //        string str = ex.StackTrace;
        //        AddMessage_Station(stationNameStr, LogType.Error,
        //            $"PLC{plcNo}_{stationNameStr} 节拍接口出错！错误信息：" + ex.Message + "异常位置：" +
        //            str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

        //        // MES_Flag
        //        stopwatch2.Start();
        //        //Funs[plcNo].WriteMultipleRegisters<short>(2088, (short)4);  // 4代表上位机报警
        //        WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
        //        writeToPLC_Flag.Name = "e1OEEMES_FLAG";
        //        writeToPLC_Flag.Adress = 2088;
        //        writeToPLC_Flag.Value = (short)4;
        //        SxPLCWriteData_Add(ref s5PLCWriteData, "e1OEEMES_FLAG", writeToPLC_Flag);
        //        stopwatch2.Stop();
        //    }

        //    stopwatch1.Stop();
        //    AddMessage(LogType.Info,
        //        stationNameStr + $"_节拍接口-- {resultStr};总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
        //        stopwatch2.ElapsedMilliseconds + "ms");
        //}

        /// <summary>
        /// [S5] Tray盘下料装备 - AGV上料叫agv
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S5AGV上料叫agv(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS 呼叫AGV
                short e1AGVUpCall = 2;

                stopwatch2.Start();
                // e1AGVUpCall
                //Funs[plcNo].WriteMultipleRegisters<short>(2120, e1AGVUpCall);  // 1：plc请求上料（plc请求）；10秒响应清证明上位机掉线；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVUpCall";
                writeToPLC_Flag.Adress = 2120;
                writeToPLC_Flag.Value = e1AGVUpCall;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVUpCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV上料叫agv出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // e1AGVUpCall
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2120, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVUpCall";
                writeToPLC_Flag.Adress = 2120;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVUpCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV上料叫agv;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S5] Tray盘下料装备 - AGV上料完成
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S5AGV上料完成(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS AGV上料完成,让小车离开
                short e1AGVUpEnd = 2;

                stopwatch2.Start();
                // e1AGVUpEnd
                //Funs[plcNo].WriteMultipleRegisters<short>(2122, e1AGVUpEnd);  // 1：plc通知完成结果（plc请求）；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVUpEnd";
                writeToPLC_Flag.Adress = 2122;
                writeToPLC_Flag.Value = e1AGVUpEnd;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVUpEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV上料完成出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // e1AGVUpEnd
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2122, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVUpEnd";
                writeToPLC_Flag.Adress = 2122;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVUpEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV上料完成;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S5] Tray盘下料装备 - AGV下料叫agv
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S5AGV下料叫agv(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS 呼叫AGV
                short e1AGVDownCall = 2;

                stopwatch2.Start();
                // e1AGVDownCall
                //Funs[plcNo].WriteMultipleRegisters<short>(2133, e1AGVDownCall);  // 1：plc请求下料（plc请求）；10秒响应清证明上位机掉线；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVDownCall";
                writeToPLC_Flag.Adress = 2133;
                writeToPLC_Flag.Value = e1AGVDownCall;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVDownCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV下料叫agv出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // e1AGVDownCall
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2133, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVDownCall";
                writeToPLC_Flag.Adress = 2133;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVDownCall", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV下料叫agv;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        /// <summary>
        /// [S5] Tray盘下料装备 - AGV下料完成
        /// </summary>
        /// <param name="plcNo">PLC编号</param>
        /// <param name="stationNameStr">工站全称</param>
        private void S5AGV下料完成(int plcNo, string stationNameStr)
        {
            Stopwatch stopwatch1 = new Stopwatch();
            Stopwatch stopwatch2 = new Stopwatch();
            try
            {
                stopwatch1.Start();
                // ZS AGV上料完成,让小车离开
                short e1AGVDownEnd = 2;

                stopwatch2.Start();
                // e1AGVDownEnd
                //Funs[plcNo].WriteMultipleRegisters<short>(2135, e1AGVDownEnd);  // 1：plc通知完成结果（plc请求）；2：调用成功（上位机返回）；3：AGV报警（上位机返回）；4：上位机报警（上位机返回）；
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVDownEnd";
                writeToPLC_Flag.Adress = 2135;
                writeToPLC_Flag.Value = e1AGVDownEnd;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVDownEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }
            catch (Exception ex)
            {
                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC{plcNo}_{stationNameStr} AGV下料完成出错！错误信息：" + ex.Message + "异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));

                // e1AGVDownEnd
                stopwatch2.Start();
                //Funs[plcNo].WriteMultipleRegisters<short>(2135, (short)4);  // 4代表上位机报警
                WriteToPLC_Flag writeToPLC_Flag = new WriteToPLC_Flag(); // MES_Flag
                writeToPLC_Flag.Name = "e1AGVDownEnd";
                writeToPLC_Flag.Adress = 2135;
                writeToPLC_Flag.Value = (short)4;
                SxPLCWriteData_Add(ref s5PLCWriteData, "e1AGVDownEnd", writeToPLC_Flag);
                stopwatch2.Stop();
            }

            stopwatch1.Stop();
            AddMessage(LogType.Info,
                stationNameStr + "_AGV下料完成;总用时" + stopwatch1.ElapsedMilliseconds + "ms;写入用时" +
                stopwatch2.ElapsedMilliseconds + "ms");
        }

        #endregion [S5] Tray盘下料装备

        #endregion PLC5 张超凡

        #region 缓存读取到的PLC数据 与 需要写入的PLC数据

        /// <summary>
        /// PLC读取到的数据 -添加数据
        /// </summary>
        public static void SxPLCData_Add(ref Dictionary<string, object> sxPlcData, string newKey, object newValue)
        {
            if (sxPlcData.ContainsKey(newKey))
                sxPlcData[newKey] = newValue;
            else
                sxPlcData.Add(newKey, newValue);
        }

        /// <summary>
        /// PLC需要写入的数据 -添加数据
        /// </summary>
        public static void SxPLCWriteData_Add(ref Dictionary<string, WriteToPLC_Flag> sxPLCWriteData, string newKey,
            WriteToPLC_Flag newValue)
        {
            if (sxPLCWriteData.ContainsKey(newKey))
                sxPLCWriteData[newKey] = newValue;
            else
                sxPLCWriteData.Add(newKey, newValue);
        }

        /// <summary>
        /// PLC回写操作，写后清空flag
        /// </summary>
        /// <param name="modbusClient">modbus对象</param>
        /// <param name="pLCReadDatas">读取到的数据字典</param>
        /// <param name="pLCWriteDatas">需要写入的数据</param>
        public static void PLCWriteData(ModbusClientHelper modbusClient, ref Dictionary<string, object> pLCReadDatas,
            ref Dictionary<string, WriteToPLC_Flag> pLCWriteDataDic)
        {
            if (pLCWriteDataDic != null && pLCWriteDataDic.Count > 0)
            {
                List<WriteToPLC_Flag> pLCWriteDatas = pLCWriteDataDic.Values.ToList();

                for (int i = 0; i < pLCWriteDatas.Count; i++)
                {
                    string mesFlagName = pLCWriteDatas[i].Name;
                    int mesFlagAdress = pLCWriteDatas[i].Adress;
                    short mesFlagValue = (short)pLCWriteDatas[i].Value; // short

                    if (mesFlagValue != 0) // 不为0则证明需要写入结果信息
                    {
                        // 先回写数据
                        List<WriteToPLC_Data> writeToPLCDatas = pLCWriteDatas[i].WriteToPLCDatas;
                        for (int j = 0; j < writeToPLCDatas.Count; j++)
                        {
                            int mesDataAdress = writeToPLCDatas[j].Adress;
                            PLCValueType mesDataType = writeToPLCDatas[j].ValueType;
                            switch (mesDataType)
                            {
                                case PLCValueType.Short:
                                    short mesDataValueShort = (short)writeToPLCDatas[j].Value;
                                    modbusClient.WriteMultipleRegisters<short>(mesDataAdress, mesDataValueShort);
                                    break;
                                case PLCValueType.String:
                                    string mesDataValueStr = (string)writeToPLCDatas[j].Value;
                                    int mesDataValueStrLength = writeToPLCDatas[j].ValueTypeStrLength;
                                    modbusClient.WriteMultipleRegisters<string>(mesDataAdress, mesDataValueStr,
                                        mesDataValueStrLength);
                                    break;
                            }
                        }

                        // 再回写信号
                        modbusClient.WriteMultipleRegisters<short>(mesFlagAdress, mesFlagValue);

                        // 存储读取数据的字典
                        pLCReadDatas[mesFlagName] = (int)mesFlagValue;
                        // 存储写入数据的字典 - 清空写入值
                        pLCWriteDatas[i].Value = (short)0;
                        pLCWriteDataDic[mesFlagName] = pLCWriteDatas[i];
                    }
                }
            }
        }

        /// <summary>
        /// 提交点检数据到MES - 取数据库中缓存的 点检数据
        /// </summary>
        /// <param name="no">3</param>
        /// <param name="stationCode">设备编号</param>
        /// <param name="stationNameStr">设备名称</param>
        /// <param name="plcOrder">车间订单号</param>
        private void SubmitOneCheckDataToMESByDB(int plcNo, int stationCode, string stationNameStr, string plcOrder)
        {
            try
            {
                /// [S2]FCT （2-上传点检数据；102-清空该工单该工单的所有点检项缓存）
                /// [S3]值板机 （3-上传点检数据；103-清空该工单该工单的所有点检项缓存）
                /// [S4]取放桁架   （4-上传点检数据；104-清空该工单该工单的所有点检项缓存）
                /// [S6]CCD检测    （6-上传点检数据；106-清空该工单该工单的所有点检项缓存）
                int result1 = 0;
                switch (stationCode)
                {
                    case 2:
                    case 3:
                    case 4:
                    case 6:
                        result1 = SubmitToMESByDB(stationCode.ToString(), stationNameStr, plcOrder);
                        break;
                    case 102:
                        result1 = ClearOneCheckDataByDB("2", stationNameStr, plcOrder);
                        break;
                    case 103:
                        result1 = ClearOneCheckDataByDB("3", stationNameStr, plcOrder);
                        break;
                    case 104:
                        result1 = ClearOneCheckDataByDB("4", stationNameStr, plcOrder);
                        break;
                    case 106:
                        result1 = ClearOneCheckDataByDB("6", stationNameStr, plcOrder);
                        break;
                    default:
                        // MES_Flag 为“6未找到正确设备编号”
                        Funs[plcNo].WriteMultipleRegisters<int>(2406, 6);
                        AddMessage_Station(stationNameStr, LogType.Error, $"PLC通知上传点检数据到MES运行出错！未找到需要点检的正确设备编号");

                        return;
                }

                short result = result1 == 1 ? (short)1 : (short)2;
                Funs[plcNo].WriteMultipleRegisters<int>(2406, result); // MES_Flag 为4MES报错

                OnMessage(LogType.Debug, $"PLC{plcNo}_PLC通知MES上传点检数据运行完毕！-Write" + (result == 1 ? "成功！" : "失败！"));
            }
            catch (Exception ex)
            {
                // MES_Flag 为2上位机报错
                Funs[plcNo].WriteMultipleRegisters<int>(2406, 2);

                string str = ex.StackTrace;
                AddMessage_Station(stationNameStr, LogType.Error,
                    $"PLC通知上传点检数据到MES运行出错！错误信息：" + ex.Message.ToString() + ";异常位置：" +
                    str.Substring(str.LastIndexOf("\\") + 1, str.Length - str.LastIndexOf("\\") - 1));
            }
        }

        #endregion 缓存读取到的PLC数据 与 需要写入的PLC数据

        #region UI刷新

        /// <summary>
        /// 更新商品信息的UI + 下发产品信息（SN）
        /// </summary>
        private void UpdateProductInfo()
        {
            currentWC.Text = GlobalContext.WorkOrderCode; // 订单号
            currentMtltmrk.Text = GlobalContext.Mtltmrk; // 产品型号
            //currentBN.Text = GlobalContext.BatchNumber;    // 批次号
            //txt_CurSupplierCode.Text = "";  // 供应商代号
        }

        /// <summary>
        /// 更新PLC连接状态的UI
        /// </summary>
        /// <param name="no">PLC编号</param>
        /// <param name="status">状态</param>
        private void UpdatePLCMonitor(int imgNo, int plcNo, int status)
        {
            if (this != null && !this.IsDisposed)
            {
                switch (imgNo)
                {
                    case 1:
                        this.BeginInvoke(new Action(() => { picPLC.Image = imageListState.Images[status]; }));
                        break;
                    case 2:
                        this.BeginInvoke(new Action(() => { pictureBox2.Image = imageListState.Images[status]; }));
                        break;
                    case 3:
                        this.BeginInvoke(new Action(() => { pictureBox3.Image = imageListState.Images[status]; }));
                        break;
                    case 4:
                        this.BeginInvoke(new Action(() => { pictureBox4.Image = imageListState.Images[status]; }));
                        break;
                    case 5:
                        this.BeginInvoke(new Action(() => { pictureBox5.Image = imageListState.Images[status]; }));
                        break;
                    case 6:
                        this.BeginInvoke(new Action(() => { pictureBox6.Image = imageListState.Images[status]; }));
                        break;
                    case 7:
                        this.BeginInvoke(new Action(() => { pictureBox7.Image = imageListState.Images[status]; }));
                        break;
                    case 8:
                        this.BeginInvoke(new Action(() => { pictureBox8.Image = imageListState.Images[status]; }));
                        break;
                    default:
                        break;
                }
            }

            Task.Run(() => // 更新PLC交互页的指示灯
            {
                try
                {
                    if (Form_Main.formPLCDB != null && !Form_Main.formPLCDB.IsDisposed)
                    {
                        Form_Main.formPLCDB.UpdatePLCFunMonitor(plcNo, status);
                    }
                }
                catch
                {
                }
            });
        }

        #endregion UI刷新

        #region 日志

        /// <summary>
        /// 添加各工位运行日志（同步至PLC交互页面）
        /// </summary>
        /// <param name="stationNameStr">工站名称</param>
        /// <param name="logType">日志类型</param>
        /// <param name="message">日志内容</param>
        /// <param name="snNumber">产品数字SN</param>
        public void AddMessage_Station(string stationNameStr, LogType logType, string message, string snNumber = "")
        {
            if (!(stationNameStr.Equals("获取设备报警数据与状态信息")))
            {
                AddMessage(logType, message); // 首页展示+日志记录
            }

            PLCDBFormMessage plcMessage = new PLCDBFormMessage()
            {
                StationName = stationNameStr,
                SnNumber = snNumber,
                Message = message,
                CreateTime = DateTime.Now
            };
            // PLC交互页展示
            Task.Run(() =>
            {
                try
                {
                    if (Form_Main.formPLCDB != null && !Form_Main.formPLCDB.IsDisposed)
                    {
                        Form_Main.formPLCDB.UpdateMessage(plcMessage);
                    }
                }
                catch
                {
                }
            });
        }

        /// <summary>
        /// 添加运行日志
        /// </summary>
        /// <param name="logType">日志类型</param>
        /// <param name="message">日志内容</param>
        public void AddMessage(LogType logType, string message)
        {
            OnMessage(logType, message);
            string date = DateTime.Now.ToString("yyyy/MM/dd");
            string time = DateTime.Now.ToString("HH:mm:ss:fff");
            string msgShow = time + "--> " + message + "\r\n";

            this.BeginInvoke(new Action(() =>
            {
                systemLog.Rows.Insert(0, date, time, message);
                if (systemLog.Rows.Count >= 100)
                    systemLog.Rows.RemoveAt(systemLog.Rows.Count - 1);
            }));
        }

        /// <summary>
        /// 添加运行日志-保存
        /// </summary>
        /// <param name="logType">日志类型</param>
        /// <param name="message">日志内容</param>
        private void OnMessage(LogType logType, string msg)
        {
            MessageEvent?.Invoke(logType, msg);
        }

        /// <summary>
        /// 保存PLC写入日志
        /// </summary>
        /// <param name="logType"></param>
        /// <param name="logValue"></param>
        private void WritePLCLog(LogType logType, string logValue)
        {
            switch ((int)logType)
            {
                case 0:
                    _PLCLogNet.WriteDebug(logValue);
                    break;
                case 1:
                    _PLCLogNet.WriteInfo(logValue);
                    break;
                case 2:
                    _PLCLogNet.WriteWarn(logValue);
                    break;
                case 3:
                    _PLCLogNet.WriteError(logValue);
                    break;
                default:
                    _PLCLogNet.WriteFatal(logValue);
                    break;
            }
        }

        /// <summary>
        /// IOT Mqtt回调方法- With DataId
        /// </summary>
        /// <param name="id"></param>
        /// <param name="v"></param>
        /// <param name="dataId"></param>
        public void CallbackWithDataId(string id, string msg, string dataId)
        {
            //_MqttLogNet.WriteInfo("-------CallbackWithDataId-------");
            //byte[] buffer1 = Encoding.Default.GetBytes(v);
            //byte[] buffer2 = Encoding.Convert(Encoding.UTF8, Encoding.Default, buffer1, 0, buffer1.Length);
            //string strBuffer = Encoding.Default.GetString(buffer2, 0, buffer2.Length);
            //Console.WriteLine("{0} -> {1} {2}", id, strBuffer, dataId);

            string datetime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
            _IOTMqttLogNet.WriteInfo($"{datetime}-> [消息ID:{id}][事件ID:{dataId}]{msg}");
        }

        /// <summary>
        /// AGV Mqtt回调方法- 记录Log并处理数据
        /// </summary>
        /// <param name="obj"></param>
        private void AGVMqttShowLog(ResultData_MQTT resultData_MQTT)
        {
            string datetime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
            _AGVMqttLogNet.WriteInfo($"{datetime}->返回结果：{resultData_MQTT.ResultCode}，返回信息：{resultData_MQTT.ResultMsg}");

            // 接收到的信息
            string topic = (string)resultData_MQTT.ResultObject1; // 订阅的标识
            string jsonData = (string)resultData_MQTT.ResultObject2; // 订阅的数据
            if (resultData_MQTT.ResultCode == 1 && !string.IsNullOrEmpty(topic)) // 是接收到的数据
            {
            }
        }

        #endregion 日志


        //private void button1_Click(object sender, EventArgs e)
        //{
        //    OpenDailogFalg=true;
        //    if (OpenDailogFalg)
        //    {
        //        using (var dialog = new BandBarodeDialog())
        //        {
        //            string strCarrierBarcode = "N801A-003";

        //            dialog._CarrierBarcode = strCarrierBarcode;
        //            string sn = SQLHelper.GetProductBarcodeByCarrierCode(strCarrierBarcode);
        //            dialog._ProductBarcode = sn;
        //            var rs = dialog.ShowDialog();
        //            if (rs == DialogResult.OK)
        //            {
        //                AddMessage(LogType.Info, $"扫码校验通过，载具码:{strCarrierBarcode};产品码:{sn};产品码:{sn}");
        //                OpenDailogFalg = false;//关闭扫码
        //            }
        //        }
        //    }
        //}
    }
}