using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Threading;
using System.Windows.Forms;
//logtxtWrite---0是记录到send记事本里(参数有误)，1是记录到plcLog.txt里(写入成功)，其他将记录到d:\log_ShuYing\alarm记事本里(产生异常)
using logtxtWrite;
using iWareCommon.Utils;

using iWareSda.Common;
using iWareModel;
using System.Linq;
using iWareCommon;
using Newtonsoft.Json.Linq;


namespace iWareSda
{
    public partial class SdaMainForm : Form
    {
        #region 变量声明


        private static short current_Srm_HandShake = 0;
#pragma warning disable CS0414 // 字段“SdaMainForm.current_Line_HandShake”已被赋值，但从未使用过它的值
        private static short current_Line_HandShake = 0;
#pragma warning restore CS0414 // 字段“SdaMainForm.current_Line_HandShake”已被赋值，但从未使用过它的值

        /// <summary>
        /// 堆垛机实时PLC值字典
        /// </summary>
        private static IDictionary<string, string> realtimePlcValueDict_Srm = new Dictionary<string, string>();

        /// <summary>
        /// Station实时PLC值字典
        /// </summary>
        private static IDictionary<string, string> realtimePlcValueDict_Station = new Dictionary<string, string>();

        #region 发送WCS心跳
        /// <summary>
        /// 发送堆垛机的心跳
        /// </summary>
        private List<Thread> SendStackerHeartToSrmThreads = new List<Thread>();
        private List<Thread> SendStackerHeartToStationThreads = new List<Thread>();
        /// <summary>
        /// 发送输送线的心跳
        /// </summary>
        private List<Thread> SendStackerHeartToLineThreads = new List<Thread>();

        #endregion


        private List<Thread> GetSrmStateThreads = new List<Thread>();
        private List<Thread> GetStationStateThreads = new List<Thread>();
        private List<Thread> GetLineStateThreads = new List<Thread>();

        #endregion

        /// <summary>
        /// 是否要显示实时的PLC值堆垛机
        /// </summary>
        public static bool isShowPlcValue_Srm = false;

        /// <summary>
        /// 是否要显示实时Station的PLC值堆垛机
        /// </summary>
        public static bool isShowPlcValue_Station = false;

        static string errorStr = string.Empty;

        static string infoStr_ChangeHandshake = string.Empty;
        static string errorStr_Line = string.Empty;
        static string errorStr_Srm = string.Empty;
        static string errorStr_Station = string.Empty;
        static string infoStr_SaveLine = string.Empty;

        static string infoStr_Connection = string.Empty;

        /// <summary>
        /// 握手信号信息
        /// </summary>
        static string infoStr_handshake = string.Empty;

        static string error_deletedata = string.Empty;


        public SdaMainForm()
        {
            InitializeComponent();
            Control.CheckForIllegalCrossThreadCalls = false;

            this.lbl_Main1.Text = SysHelper.Language(WareSdaStruct.LanguageFlg, "鲁丽木业包装线数据访问服务", "Data service runing");
            this.lbl_Main2.Text = SysHelper.Language(WareSdaStruct.LanguageFlg, "请勿关闭！", "Please do not close!");
            this.Text = SysHelper.Language(WareSdaStruct.LanguageFlg, "鲁丽木业包装线数据访问服务", "Data service");
            this.tabPage_Main.Text = SysHelper.Language(WareSdaStruct.LanguageFlg, "服务", "Service");
        }


        /// <summary>初始化获取设备信息和服务（开启线程服务）
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormMain_Load(object sender, EventArgs e)
        {
            #region 设备通讯配置初始化
            try
            {
                #region 对外发布WCF形式数据访问服务

                var StationServiceHost = new ServiceHost(typeof(iWareSda.StationService));
                StationServiceHost.Open();

                #endregion

            }
            catch (Exception ex)
            {
                Log4NetHelper.WriteErrorLog(LogType.SdaService, "对外发布WCF形式数据访问服务异常:" + ex.Message, ex);
                MessageBox.Show("对外发布WCF形式数据访问服务异常:" + ex.Message);
                return;
            }




            #endregion

            #region 构造字符串

            InitRealtimePlcValueDict();

            #endregion

            #region 状态信息获取



            //获取Station的状态信息
            Station_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(GetStationInfo));
                thread.Name = string.Format("获取Station{0}的状态", x.View.DeviceName);
                GetStationStateThreads.Add(thread);
                StartThread(thread, x);
            });




            #endregion

            #region 设备发送心跳


            //开启 Station 心跳的线程
            Station_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SendStackerHeartToStation));
                thread.Name = string.Format("自动发送Station{0}心跳", x.View.DeviceName);
                SendStackerHeartToStationThreads.Add(thread);
                StartThread(thread, x);
            });

            #endregion


            new Thread(DeleteData).Start();
            //*/
        }

        /// <summary>
        /// 关闭退出应用（退出线程服务）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormMain_FormClosed(object sender, FormClosedEventArgs e)
        {
            //关闭SrmWCF服务
            //CloseWcf(LineServiceHost);

            Environment.Exit(0);
        }

        #region 辅助类

        /// <summary>窗体关闭
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            var msg = SysHelper.Language(WareSdaStruct.LanguageFlg, "正常情况下请勿关闭此窗体！", "Do not close this form under normal circumstances！");
            if (!SysMessageUtil.ConfirmYesNo(WareSdaStruct.LanguageFlg, msg))
            {
                e.Cancel = true;
            }
        }


        /// <summary>开启带参数的线程
        /// 
        /// </summary>
        private void StartThread(Thread thread, object obj)
        {
            if (thread != null)
            {
                thread.IsBackground = true;
                thread.Start(obj);
            }
        }

        /// <summary>关闭线程
        /// 
        /// </summary>
        /// <param name="thread">需要关闭的线程</param>
        private void CloseThread(Thread thread)
        {
            if (thread != null)
            {
                thread.Abort();
            }
        }

        /// <summary>关闭WCF
        /// 
        /// </summary>
        /// <param name="host">需要关闭的WCF</param>
        private void CloseWcf(ServiceHost host)
        {
            if (host != null)
            {
                host.Close();
            }
        }
        #endregion

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (progressBar1.Value < 100)
                progressBar1.Value += 5;
            else
                progressBar1.Value = 0;

            errorStr =
                infoStr_Connection + "\r\n" +
                infoStr_ChangeHandshake + "\r\n"
                + errorStr_Line + "\r\n"
                 + infoStr_SaveLine + "\r\n"
                 + infoStr_handshake + "\r\n"
                   + error_deletedata + "\r\n"
                 + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
                ;
            rtbError.Text = errorStr;

        }


        #region 线程处理

        #region 定时删除数据

        /// <summary>
        /// 定时删除数据
        /// </summary>
        public void DeleteData()
        {
            while (true)
            {
                try
                {
                    LogTextHelper.BatchDeleteLog();//删除默认的地址

                    string folderPath = @"d:\\Log";//注意：这里配置的地址是api的log地址 [Editby shaocx,2023-02-20]
                    LogTextHelper.BatchDeleteLog(folderPath);
                    error_deletedata = "";
                }
                catch (Exception ex)
                {
                    error_deletedata = "定时删除数据出现异常:" + ex.Message;
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.SdaService, "定时删除数据 出现异常", ex);
                }
                finally
                {
                    Thread.Sleep(24 * 60 * 60 * 1000);//每天一次 
                }
            }
        }

        #endregion


        #region 堆垛机

        #region 设备状态信息
        /// <summary>
        /// 获取 堆垛机 的状态信息
        /// </summary>
        /// <param name="obj"></param>
        private void GetSrmInfo(object obj)
        {
            var s = (SrmEntity)obj;
            if (s.plcService != null && !s.plcService.IsConnected)
            {
                s.plcService.Close();
                s.plcService.OpenService();
            }
            while (true)
            {
                try
                {
                    s.InitData();
                    if (s.plcService == null || !s.plcService.IsConnected)
                    {
                        errorStr_Srm = "堆垛机" + s.View.DeviceName + "连接已断开，正在尝试打开。。。";
                        errorStr_Srm = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Srm, "Piler connection disconnected,waiting for reconnection ");
                        s.plcService.Close();
                        s.plcService.OpenService();
                        Thread.Sleep(100);
                        continue;
                    }
                    else
                    {
                        var s7 = s.plcService;
                        var srm_db = s.DBBlockForWrite;

                        s.SetPropertyValueForRead();
                        s.SetPropertyValueForWrite();
                        //特别赋值模式
                        s.View.ModeName = EnumberHelper.GetEnumName<ESrmMode>(s.View.R_Mode);
                        s.View.StateName = EnumberHelper.GetEnumName<ESrmState>(s.View.R_State);
                        s.View.SrmSourcePlace = s.GetSrmSourcePlace();
                        s.View.SrmToPlace = s.GetSrmToPlace();

                        if (SdaMainForm.isShowPlcValue_Srm)
                        {
                            string dbValues = SdaHelper.GetStrShow<SrmView, SrmDBForWrite, SrmDBForRead>(s.View, s.DBBlockForWrite, s.DBBlockForRead, "", "", s.View.DeviceId, s.View.DeviceName);
                            realtimePlcValueDict_Srm[s.View.DeviceName] = dbValues;
                        }
                        else
                        {
                            realtimePlcValueDict_Srm[s.View.DeviceName] = "";
                        }


                        //判断如果ACK=1，则写入STB为0
                        if (s.View.W_Ack == 1)
                        {
                            MessageModel fr = s.plcService.WriteValuePoint(s.DBBlockForWrite.W_Stb, 0, s.View.W_Stb);
                            if (fr.result == false)
                            {
                                Log4NetHelper.WriteErrorLog(LogType.SrmTheadService, "获取 堆垛机 的状态信息时，判断ACK=1，更新STB为0时错误:" + fr.resMsg, null);
                            }
                        }

                        //赋值报警
                        s.View.R_WarningDBList = s.GetAlertDatas();

                        //s.IsConnected = s.plcService.IsConnected;
                        ////区域1
                        //s.R_AutoMode_1 = Convert.ToBoolean(s.plcService.ReadValuePoint(s.LineDB.R_AutoMode_1, typeof(bool)));
                        //s.R_ManualMode_1 = Convert.ToBoolean(s.plcService.ReadValuePoint(s.LineDB.R_ManualMode_1, typeof(bool)));
                        //s.R_SysError_1 = Convert.ToBoolean(s.plcService.ReadValuePoint(s.LineDB.R_SysError_1, typeof(bool)));
                        //s.R_MESCut_1 = Convert.ToBoolean(s.plcService.ReadValuePoint(s.LineDB.R_MESCut_1, typeof(bool)));

                    }
                }
                catch (Exception ex)
                {
                    s.InitData();
                    errorStr_Srm = "GetSrmInfo出现异常:" + ex.Message;
                    errorStr_Srm = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Srm,
                        "GetSrmInfo throw exceptions: " + ex.Message);

                    Log4NetHelper.WriteErrorLog(LogType.SrmSdaService, "获取 堆垛机 的状态信息出现异常", ex);
                }
                Thread.Sleep(500);//延迟500毫秒
            }
        }


        #endregion

        #region 心跳相关

        /// <summary>
        /// 发送给堆垛机的心跳
        /// </summary>
        /// <param name="obj"></param>
        private void SendStackerHeartToSrm(object obj)
        {
            while (true)
            {
                var s = (SrmEntity)obj;
                try
                {
                    if (s.plcService != null && !s.plcService.IsConnected)
                    {

                        errorStr_Srm = SysHelper.Language(WareSdaStruct.LanguageFlg, "堆垛机" + s.View.DeviceName + "连接已断开", "Piler connection disconnected ");
                        Thread.Sleep(100);
                        continue;
                    }
                    errorStr_Srm = SysHelper.Language(WareSdaStruct.LanguageFlg, "堆垛机" + s.View.DeviceName + "连接已连接。。。", "Piler connection connected ");
                    if (s.plcService != null && s.plcService.IsConnected)
                    {
                        if (current_Srm_HandShake >= WareSdaStruct.MaxHandShake)
                        {
                            current_Srm_HandShake = 0;
                        }
                        MessageModel fr = s.plcService.WriteValuePoint(s.DBBlockForWrite.W_HandShake, current_Srm_HandShake, s.View.W_HandShake);
                        current_Srm_HandShake++;
                    }
                    else
                    {
                        Thread.Sleep(100);
                        continue;
                    }
                    Thread.Sleep(1000);//约定 等待1秒
                }
                catch (Exception ex)
                {
                    errorStr_Srm = SysHelper.Language(WareSdaStruct.LanguageFlg, "发送心跳给堆垛机出现异常。。。" + ex.Message, "Send to stacker for heart beat throw expection: " + ex.Message);
                    Log4NetHelper.WriteErrorLog(LogType.SdaService, "发送给堆垛机的心跳出现异常:" + ex.Message, ex);
                }
            }
        }

        #endregion

        #endregion

        #region Station

        #region 设备状态信息
        /// <summary>
        /// 获取 Station 的状态信息
        /// </summary>
        /// <param name="obj"></param>
        private void GetStationInfo(object obj)
        {
            var s = (StationEntity)obj;
            if (s.plcService != null && !s.plcService.IsConnected)
            {
                s.plcService.Close();
                s.plcService.OpenService();
            }
            while (true)
            {
                try
                {
                    s.InitData();
                    if (s.plcService == null || !s.plcService.IsConnected)
                    {
                        errorStr_Station = "Station" + s.View.DeviceName + "连接已断开，正在尝试打开。。。";
                        errorStr_Station = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Station, "Piler connection disconnected,waiting for reconnection ");
                        s.plcService.Close();
                        s.plcService.OpenService();
                        Thread.Sleep(100);
                        continue;
                    }
                    else
                    {
                        var s7 = s.plcService;
                        var Station_db = s.DBBlockForWrite;

                        s.SetPropertyValueForRead();
                        s.SetPropertyValueForWrite();
                        //特别赋值模式
                        //s.View.ModeName = s.GetMoleName(s.View.R_Mode);
                        //s.View.BodyTestName = s.GetBodyTestName(s.View.r_S);
                        //s.View.StateName = s.GetStateName(s.View.R_State);

                        if (SdaMainForm.isShowPlcValue_Station)
                        {
                            string dbValues = SdaHelper.GetStrShow<StationView, StationDBForWrite, StationDBForRead>(s.View, s.DBBlockForWrite, s.DBBlockForRead, "", "", s.View.DeviceId, s.View.DeviceName);
                            realtimePlcValueDict_Station[s.View.DeviceName] = dbValues;
                        }
                        else
                        {
                            realtimePlcValueDict_Station[s.View.DeviceName] = "";
                        }

                        foreach (var item in s.View.R_StationForReadCommList)
                        {
                            //判断如果ACK=1，则写入STB为0
                            if (item.R_ACK == true)
                            {
                                var writeObj = s.View.W_StationForWriteCommList.Where(x => x.StationCode == item.StationCode).FirstOrDefault();
                                var writeAddressObj = s.DBBlockForWrite.W_StationForWriteCommList.Where(x => x.StationCode == item.StationCode).FirstOrDefault();
                                MessageModel fr = null;
                                if (fr.result == false)
                                {
                                    Log4NetHelper.WriteErrorLog(LogType.SrmTheadService, "获取 Station和输送线 的状态信息时，判断ACK=1，更新STB为0时错误:" + fr.resMsg, null);
                                }
                            }
                        }

                        //赋值报警
                        //s.View.R_Line_WarningDBList = s.GetLineAlertDatas();
                        s.View.R_Station_WarningDBList = s.GetStationAlertDatas();
                    }
                }
                catch (Exception ex)
                {
                    s.InitData();
                    errorStr_Station = "GetStationInfo出现异常:" + ex.Message;
                    errorStr_Station = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Station,
                        "GetStationInfo throw exceptions: " + ex.Message);

                    Log4NetHelper.WriteErrorLog(LogType.StationSdaService, "获取 Station 的状态信息出现异常", ex);
                }
                Thread.Sleep(1000);
            }
        }


        #endregion

        #region 心跳相关

        /// <summary>
        /// 发送给Station的心跳
        /// </summary>
        /// <param name="obj"></param>
        private void SendStackerHeartToStation(object obj)
        {
            bool handShakeValue = true;
            while (true)
            {
                var s = (StationEntity)obj;
                handShakeValue = !handShakeValue;
                try
                {
                    if (s.plcService != null && !s.plcService.IsConnected)
                    {

                        errorStr_Station = SysHelper.Language(WareSdaStruct.LanguageFlg, "Station" + s.View.DeviceName + "连接已断开", "Piler connection disconnected ");
                        Thread.Sleep(100);
                        continue;
                    }
                    errorStr_Station = SysHelper.Language(WareSdaStruct.LanguageFlg, "Station" + s.View.DeviceName + "连接已连接。。。", "Piler connection connected ");
                    if (s.plcService != null && s.plcService.IsConnected)
                    {
                        MessageModel fr = s.plcService.WriteValuePoint(s.DBBlockForWrite.W_HandShake, handShakeValue, s.View.W_HandShake);
                    }
                    else
                    {
                        Thread.Sleep(100);
                        continue;
                    }
                    Thread.Sleep(1000);//约定 等待1秒
                }
                catch (Exception ex)
                {
                    errorStr_Station = SysHelper.Language(WareSdaStruct.LanguageFlg, "发送心跳给Station出现异常。。。" + ex.Message, "Send to stacker for heart beat throw expection: " + ex.Message);
                    Log4NetHelper.WriteErrorLog(LogType.SdaService, "发送给Station的心跳出现异常:" + ex.Message, ex);
                }
            }
        }

        #endregion

        #endregion

        #region 输送线


        #region 输送线设备状态信息
        /// <summary>
        /// 获取 输送线 的状态信息
        /// </summary>
        /// <param name="obj"></param>
        private void GetLineInfo(object obj)
        {
            var deviceName = "输送线";
            var line = (HuscoLineEntity)obj;
            if (line.plcService != null && !line.plcService.IsConnected)
            {
                line.plcService.Close();
                line.plcService.OpenService();
            }
            string handShareAddress = "C1Sta130.Integers[10]";
            while (true)
            {
                try
                {
                    line.InitData();
                    if (line.plcService == null || !line.plcService.IsConnected)
                    {
                        infoStr_Connection = deviceName + "连接已断开，正在尝试打开。。。" + GetNowTime();
                        infoStr_Connection = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_Connection, "Line connection disconnected,waiting for reconnection " + GetNowTime());
                        line.plcService.Close();
                        line.plcService.OpenService();
                        Thread.Sleep(100);
                        continue;
                    }
                    else
                    {
                        infoStr_Connection = deviceName + "已连接" + GetNowTime();
                        infoStr_Connection = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_Connection, "Line is connected " + GetNowTime());

                        line.SetPropertyValueForRead();
                        line.SetPropertyValueForWrite();

                        string _AssemblyBarcode = ReadAssemblyBarcode(line.plcService);
                        string _CoilCode = ReadCoilCode(line.plcService);
                        int rejectStation = ReadRejectStation(line.plcService);
                        //_AssemblyBarcode = "";
                        //_CoilCode = "";

                        //赋值报警
                        //line.View.R_WarningDBList = line.GetAlertDatas();

                        string dbValues = SdaHelper.GetStrShow<HuscoLineView, HuscoLineDBForWrite, HuscoLineDBForRead>(line.View, line.DBBlockForWrite, line.DBBlockForRead, HuscoLine_CacheEntity.W_DBHeader, HuscoLine_CacheEntity.R_DBHeader, line.View.DeviceId, line.View.DeviceName);
                        this.tb_Station.Text = dbValues + " \r\n  AssemblyBarcode:" + _AssemblyBarcode + " \r\n CoilCode:" + _CoilCode + " \r\n";

                        //首先读取握手信号是否是true，只有true 的时候才能拿值
                        var isRead = Convert.ToInt32(line.plcService.ReadValuePoint("", handShareAddress, typeof(Int32)));

                        infoStr_handshake = "握手信号" + handShareAddress + "：" + isRead + GetNowTime();
                        infoStr_handshake = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_handshake, "Handshke" + handShareAddress + ":" + isRead + GetNowTime());
                        if (isRead == 0)
                        {
                            infoStr_SaveLine = "握手信号不是1" + GetNowTime();
                            infoStr_SaveLine = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_SaveLine, "The handshake signal is not 1!" + GetNowTime());
                            Thread.Sleep(2000);
                            continue;
                        }





                        //更改握手信号为false
                        MessageModel mm = line.plcService.WriteValuePoint("", handShareAddress, 0, 66);
                        if (mm.result == false)
                        {
                            infoStr_ChangeHandshake = "更改握手信号为false失败:" + mm.resMsg + GetNowTime();
                            infoStr_ChangeHandshake = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_ChangeHandshake, "Update handshake to false failed: " + mm.resMsg + GetNowTime());
                        }
                        else
                        {

                            infoStr_ChangeHandshake = "更改握手信号为false成功!" + GetNowTime();
                            infoStr_ChangeHandshake = SysHelper.Language(WareSdaStruct.LanguageFlg, infoStr_ChangeHandshake, "Update handshake to 0  success" + GetNowTime());
                        }
                        //*/
                    }
                }
                catch (Exception ex)
                {
                    line.InitData();
                    errorStr_Line = "GetLineInfo出现异常:" + ex.Message + GetNowTime();
                    errorStr_Line = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Line,
                        "GetLineInfo throw exceptions: " + ex.Message + GetNowTime());
                    Log4NetHelper.WriteErrorLog(LogType.SrmTheadService, "获取 " + deviceName + " 的状态信息出现异常", ex);
                }
                Thread.Sleep(10 * 1000);//10秒一次
            }
        }


        #endregion

        #region 输送线心跳相关

        /// <summary>
        /// 发送给输送线的心跳
        /// </summary>
        /// <param name="obj"></param>
        private void SendStackerHeartToLine(object obj)
        {
            //try
            //{
            //    var s = (HuscoLineEntity)obj;
            //    while (true)
            //    {
            //        if (s.plcService != null && !s.plcService.IsConnected)
            //        {
            //            errorStr_Line = SysHelper.Language(WareSdaStruct.LanguageFlg, "输送线连接已断开", "Line connection disconnected ");
            //            Thread.Sleep(100);
            //            continue;
            //        }
            //        errorStr_Line = SysHelper.Language(WareSdaStruct.LanguageFlg, "输送线连接已连接。。。", "Line connection connected ");
            //        if (s.plcService != null && s.plcService.IsConnected)
            //        {
            //            if (current_Line_HandShake >= WareSdaStruct.MaxHandShake)
            //            {
            //                current_Line_HandShake = 0;
            //            }
            //            MessageModel fr = s.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, s.DBBlockForWrite.W_HeartBeat, current_Line_HandShake, s.View.W_HeartBeat);
            //            current_Line_HandShake++;
            //        }
            //        else
            //        {
            //            Thread.Sleep(100);
            //            continue;
            //        }
            //        Thread.Sleep(1000);//约定 等待2秒
            //    }
            //}
            //catch (Exception ex)
            //{
            //    errorStr_Line = SysHelper.Language(WareSdaStruct.LanguageFlg, "发送心跳给输送线出现异常。。。" + ex.Message, "Send to line for heart beat throw expection: " + ex.Message);
            //    Log4NetHelper.WriteErrorLog(LogType.SdaService, "发送给输送线的心跳出现异常:" + ex.Message, ex);
            //}
        }

        #endregion

        private void button1_Click(object sender, EventArgs e)
        {
            var srm = Srm_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)EDevice.一号堆垛机);
            short taskId = 222;
            MessageModel b2 = srm.plcService.WriteValuePoint(srm.DBBlockForWrite.W_TaskNo, taskId, srm.View.W_TaskNo);
            if (!b2.result)
            {
                var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            }
        }

        #endregion

        #region 数据展示

        /// <summary>
        /// 设置1/2号堆垛机的前端显示
        /// </summary>
        private void ShowUI()
        {
            while (true)
            {
                Thread.Sleep(1000);
                try
                {

                    var str_Station = "";
                    foreach (var item in realtimePlcValueDict_Station)
                    {
                        str_Station += item.Value;
                    }
                    this.tb_Station.Text = str_Station;

                }
                catch (Exception)
                {
                    continue;
                }
            }
        }

        #endregion
        private void button2_Click(object sender, EventArgs e)
        {
            var srm = Srm_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)EDevice.一号堆垛机);
            short taskId = 9999;
            MessageModel b2 = srm.plcService.WriteValuePoint(srm.DBBlockForWrite.W_HandShake, taskId, srm.View.W_HandShake);
            if (!b2.result)
            {
                var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            }
        }
        #endregion


        #region 私有方法

        /// <summary>
        /// 初始化实时PLC值的字典
        /// </summary>
        private static void InitRealtimePlcValueDict()
        {
            Srm_CacheEntity.DeviceObjs.ForEach(x =>
            {
                realtimePlcValueDict_Srm.Add(x.View.DeviceName, "");
            });
            Station_CacheEntity.DeviceObjs.ForEach(x =>
            {
                realtimePlcValueDict_Srm.Add(x.View.DeviceName, "");
            });
        }

        #endregion

        private void button3_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T1_Finish, true, srm.View.W_T1_Finish);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }

        private void button8_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T2_Finish, true, srm.View.W_T2_Finish);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }

        private void button9_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T3_Finish, true, srm.View.W_T3_Finish);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }


        private void tabPage4_Click(object sender, EventArgs e)
        {

        }

        private void button4_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T1_Die, 1, srm.View.W_T1_Die);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }
        private void button7_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T1_Die, 2, srm.View.W_T1_Die);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }

        private void button5_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T1_Stock, 1, srm.View.W_T1_Stock);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }

        private void button6_Click(object sender, EventArgs e)
        {
            //var srm = HuscoLine_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == (int)DeviceEnum.台车);
            //short taskId = 9999;
            //MessageModel b2 = srm.plcService.WriteValuePoint(HuscoLine_CacheEntity.W_DBHeader, srm.DBBlockForWrite.W_T1_Stock, 2, srm.View.W_T1_Stock);
            //if (!b2.result)
            //{
            //    var msg = string.Format("向堆垛机{0}发送任务{1},写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, "", taskId);
            //    MessageBox.Show(msg);
            //}
        }


        private string ReadAssemblyBarcode(PLCService plcService)
        {
            var code = "";
            var address = "C1Sta130.PartData.Track.AssemblyBarcode";
            for (int i = 0; i < 25; i++)
            {
                var data = Convert.ToString(plcService.ReadValuePoint("", address + ".DATA[" + i + "]", typeof(char)));
                if (data.Contains("\0") || data.Contains("\r") || data.Contains("\n"))
                {
                    break;
                }
                code += Convert.ToString(data);
            }
            return code.Trim().ToString();
        }

        private string ReadCoilCode(PLCService plcService)
        {
            var code = "";
            var address = "C1Sta130.PartData.Track.CoilCode";
            for (int i = 0; i < 25; i++)
            {
                var data = Convert.ToString(plcService.ReadValuePoint("", address + ".DATA[" + i + "]", typeof(char)));
                if (data.Contains("\0") || data.Contains("\r") || data.Contains("\n"))
                {
                    break;
                }
                code += Convert.ToString(data);
            }
            return code.Trim().ToString();
        }



        private Int32 ReadRejectStation(PLCService plcService)
        {
            var address = "C1Sta130.PartData.RejectStation";
            var data = Convert.ToInt32(plcService.ReadValuePoint("", address, typeof(Int32)));
            return data;
        }

        private string GetNowTime()
        {
            return "[" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "]";
        }

        private void btn_Show_Click(object sender, EventArgs e)
        {
            isShowPlcValue_Srm = true;
        }

        private void btn_Hide_Click(object sender, EventArgs e)
        {
            isShowPlcValue_Srm = false;
        }

        private void button2_Click_1(object sender, EventArgs e)
        {
            isShowPlcValue_Station = true;
        }

        private void button1_Click_1(object sender, EventArgs e)
        {
            isShowPlcValue_Station = false;
        }

        /*
        /// <summary>
        /// 一直存在StationACK信号无法清除的BUG，做个定时清除的线程
        /// </summary>
        public void HandleStationAckBug(object obj)
        {
            var s = (StationEntity)obj;
            
            while (true)
            {
                Thread.Sleep(1000);
                bool finishStation = (bool)s.plcService.ReadValuePoint(s.DBBlockForRead.R_Station_Finish, typeof(bool));
                bool finisAck = (bool)s.plcService.ReadValuePoint(s.DBBlockForWrite.W_Station_FinishACK, typeof(bool));

                if (finisAck == false && finishStation == true)
                {
                    Thread.Sleep(10000);//如果10秒还没清除，就强制清除
                    finishStation = (bool)s.plcService.ReadValuePoint(s.DBBlockForRead.R_Station_Finish, typeof(bool));
                    finisAck = (bool)s.plcService.ReadValuePoint(s.DBBlockForWrite.W_Station_FinishACK, typeof(bool));
                    if (finisAck == false && finishStation == true)
                    {
                        s.plcService.WriteValuePoint(s.DBBlockForWrite.W_Station_FinishACK, true, s.View.W_Station_FinishACK);//重发一次 20230503 王铮
                    }

                }
            }
        }
        //*/

    }
}