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;


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


        private static short current_Srm_HandShake = 0;
        private static short current_Line_HandShake = 0;

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

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

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

        #endregion


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

        #endregion

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

        /// <summary>
        /// 是否要显示实时Rgv的PLC值堆垛机
        /// </summary>
        public static bool isShowPlcValue_Rgv = 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_Rgv = 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 srmServiceHost = new ServiceHost(typeof(iWareSda.SrmService));
                srmServiceHost.Open();

                //var lineServiceHost = new ServiceHost(typeof(iWareSda.LineService));
                //lineServiceHost.Open();

                var rgvServiceHost = new ServiceHost(typeof(iWareSda.RgvService));
                rgvServiceHost.Open();

                #endregion

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




            #endregion

            #region 构造字符串

            InitRealtimePlcValueDict();

            #endregion

            #region 状态信息获取


            //获取堆垛机的状态信息
            Srm_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(GetSrmInfo));
                thread.Name = string.Format("获取堆垛机{0}的状态", x.View.DeviceName);
                GetSrmStateThreads.Add(thread);
                StartThread(thread, x);
            });
            ////模拟测试
            //var y = Srm_CacheEntity.DeviceObjs[3];
            //var thread_test = new Thread(new ParameterizedThreadStart(GetSrmInfo));
            //thread_test.Name = string.Format("获取堆垛机{0}的状态", y.View.DeviceName);
            //GetSrmStateThreads.Add(thread_test);
            //StartThread(thread_test, y);


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

            ////获取输送线的状态信息
            //HuscoLine_CacheEntity.DeviceObjs.ForEach(x =>
            //{
            //    var thread = new Thread(new ParameterizedThreadStart(GetLineInfo));
            //    thread.Name = string.Format("获取输送线{0}的状态", x.View.DeviceName);
            //    GetLineStateThreads.Add(thread);
            //    StartThread(thread, x);
            //});

            #endregion

            #region 设备发送心跳

            //开启 堆垛机 心跳的线程
            Srm_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SendStackerHeartToSrm));
                thread.Name = string.Format("自动发送堆垛机{0}心跳", x.View.DeviceName);
                SendStackerHeartToSrmThreads.Add(thread);
                StartThread(thread, x);
            });
            //开启 Rgv 心跳的线程
            Rgv_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SendStackerHeartToRgv));
                thread.Name = string.Format("自动发送Rgv{0}心跳", x.View.DeviceName);
                SendStackerHeartToRgvThreads.Add(thread);
                StartThread(thread, x);
            });
            /*
            //开启 输送线 心跳的线程
            HuscoLine_CacheEntity.DeviceObjs.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SendStackerHeartToLine));
                thread.Name = string.Format("自动发送输送线{0}心跳", x.View.DeviceName);
                SendStackerHeartToLineThreads.Add(thread);
                StartThread(thread, x);
            });
            //*/

            #endregion

            #region UI显示

            var treadShowUI = new Thread(ShowUI);
            treadShowUI.Start();

            #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();
                    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 Rgv

        #region 设备状态信息
        /// <summary>
        /// 获取 Rgv 的状态信息
        /// </summary>
        /// <param name="obj"></param>
        private void GetRgvInfo(object obj)
        {
            var s = (RgvEntity)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_Rgv = "Rgv" + s.View.DeviceName + "连接已断开，正在尝试打开。。。";
                        errorStr_Rgv = SysHelper.Language(WareSdaStruct.LanguageFlg, errorStr_Rgv, "Piler connection disconnected,waiting for reconnection ");
                        s.plcService.Close();
                        s.plcService.OpenService();
                        Thread.Sleep(100);
                        continue;
                    }
                    else
                    {
                        var s7 = s.plcService;
                        var Rgv_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_Rgv)
                        {
                            string dbValues = SdaHelper.GetStrShow<RgvView, RgvDBForWrite, RgvDBForRead>(s.View, s.DBBlockForWrite, s.DBBlockForRead, "", "", s.View.DeviceId, s.View.DeviceName);
                            realtimePlcValueDict_Rgv[s.View.DeviceName] = dbValues;
                        }
                        else
                        {
                            realtimePlcValueDict_Rgv[s.View.DeviceName] = "";
                        }

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

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

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


        #endregion

        #region 心跳相关

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

                        errorStr_Rgv = SysHelper.Language(WareSdaStruct.LanguageFlg, "Rgv" + s.View.DeviceName + "连接已断开", "Piler connection disconnected ");
                        Thread.Sleep(100);
                        continue;
                    }
                    errorStr_Rgv = SysHelper.Language(WareSdaStruct.LanguageFlg, "Rgv" + 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_Rgv = SysHelper.Language(WareSdaStruct.LanguageFlg, "发送心跳给Rgv出现异常。。。" + ex.Message, "Send to stacker for heart beat throw expection: " + ex.Message);
                    Log4NetHelper.WriteErrorLog(LogType.SdaService, "发送给Rgv的心跳出现异常:" + 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_Rgv.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
                {
                    foreach (var item in realtimePlcValueDict_Srm)
                    {
                        if (item.Key == "Srm1")
                        {
                            this.tb_Srm1.Text = item.Value;
                        }
                        else if (item.Key == "Srm2")
                        {
                            this.tb_Srm2.Text = item.Value;
                        }
                        else if (item.Key == "Srm3")
                        {
                            this.tb_Srm3.Text = item.Value;
                        }
                        else if (item.Key == "Srm4")
                        {
                            this.tb_Srm4.Text = item.Value;
                        }
                    }

                    var str_rgv = "";
                    foreach (var item in realtimePlcValueDict_Rgv)
                    {
                        str_rgv += item.Value;
                    }
                    this.tb_Rgv.Text = str_rgv;

                }
                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, "");
            });
            Rgv_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_Rgv = true;
        }

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

    }
}