HEGII.gt.mes.plc/PLC/PLC_S/EPTS/DefectiveArea/EPTS_DefectiveArea_OUT.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Threading;
using System.Timers;

using Curtain.DataAccess;
using Curtain.Extension.ExObjectConvert;
using Curtain.Extension.ExSystemData;
using Curtain.Framework.Json;
using Curtain.Log;
using Curtain.Net.Sockets.PLC;
using Curtain.Net.Sockets.PLC.Model.Siemens;

/// <summary>
/// 获取设备参数的定时服务
/// </summary>
namespace PLC_S.EPTS
{
    /// <summary>
    /// 次品区出
    /// </summary>
    public class EPTS_DefectiveArea_OUT : IWindowsServer, IShowFormLog
    {
        public const string M_NAME = "EPTS_DA_OUT";
        private Logger logger = null;
        private Logger logger_t = null;
        private Logger logger_e = null;
        private Logger logger_e_out = null;

        private bool _Started = false;
        //private System.Timers.Timer _timing = null;
        private BackgroundWorker backgroundWorker = null;

        public bool Started
        {
            get
            {
                //return _timing?.Enabled ?? false;
                //_Started = backgroundWorker.IsBusy;
                return _Started;
            }
        }

        public IFormLogShow FormLogShow
        {
            get;
            set;
        }
        public int Interval
        {
            get;
            set;
        }
        public string EPTS_CODE
        {
            get;
            set;
        }

        public EPTS_DefectiveArea_OUT()
        {
		}

        public void Start(int value)
        {
            try
            {
			    string S_NAME = "EPTS_" + EPTS_CODE;

                logger = Logger.CreateLogger(S_NAME + "-S");

                logger_t = Logger.CreateLogger(S_NAME + "-T");
                logger_e = Logger.CreateLogger(S_NAME + "-E");
                logger_e_out = Logger.CreateLogger(S_NAME + "-EO");

                logger.FileNameWithoutDate = true;
                logger.FileExistDays = 30;
                logger.LevelOneFile = true;
                logger.FilePrefix = null;
                logger.FileSuffix = logger.Name;

                logger_t.FileExistDays = 30;
                logger_t.LevelOneFile = true;
                logger_t.SubFolderFormat = logger_t.Name;

                logger_e.FileExistDays = 0;

                logger_e_out.FileExistDays = 0;
                logger_e_out.FilePrefix = null;
                logger_e_out.FileSuffix = S_NAME;
                logger_e_out.Directory = "..\\_PLC_Logs";

                logger.OutputTrace($"{M_NAME}_Starting:[{EPTS_CODE}]");
                FormLogShow?.ShowLog($"{M_NAME}_Starting:[{EPTS_CODE}]");

                if (Interval < 1000)
                {
                    Interval = 1000;
                }
                //if (Interval > 60000)
                //{
                //    Interval = 60000;
                //}

                backgroundWorker = new BackgroundWorker();
                backgroundWorker.WorkerSupportsCancellation = true;
                backgroundWorker.DoWork += BackgroundWorker_DoWork;
                backgroundWorker.RunWorkerCompleted += BackgroundWorker_RunWorkerCompleted;

                _Started = true;
                backgroundWorker.RunWorkerAsync();

                logger.OutputTrace($"{M_NAME}_Started:[{Interval}]");
                FormLogShow?.ShowLog($"{M_NAME}_Started:[{Interval}]");
            }
            catch (Exception ex)
            {
                logger.OutputError(ex);
            }
        }

        private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            logger.OutputTrace(JsonHelper.ToJson(e));
        }

        private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                INI_DA_OUT plc_ini = INI_DA_OUT.Get(EPTS_CODE);
                if (plc_ini.PLC_VALUEFLAG != "1")
                {
                    return;
                }
                while (_Started && !e.Cancel)
                {
                    this.Do(plc_ini);
                    Thread.Sleep(Interval);
                }
            }
            catch (Exception ex)
            {
                logger_e_out.OutputError(ex);
                logger_e.OutputError(ex);
            }
        }

        private void Do(INI_DA_OUT plc_ini)
        {
            try
            {
                logger_t.BeginTracking();
                using (SocketClient<SiemensS7_1200Model> plc = new SocketClient<SiemensS7_1200Model>())
                {
                    string outputMessage = $"[{EPTS_CODE}]PLC_Connect={JsonHelper.FromObject(plc_ini)}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    try
                    {
                        plc.Connect(plc_ini.PLC_IP, plc_ini.PLC_PORT);
                    }
                    catch (Exception ex1)
                    {
                        logger_t.OutputWarn(ex1.Message);
                        logger_e.OutputWarn(ex1.Message);
                        logger_e_out.OutputWarn(ex1.Message);
                        return;
                    }

                    // 1. 读取PLC 标识
                    outputMessage = $"[{EPTS_CODE}]GET_F_Code=[ ]{plc_ini.Add_F_Code + plc_ini.Add_F_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    PLCResult<short> flag_result = plc.Read<short>(plc_ini.Add_F_Code, plc_ini.Add_F_CodeNum);
                    outputMessage = $"[{EPTS_CODE}]END_F_Code=[{flag_result.Data}]{plc_ini.Add_F_Code + plc_ini.Add_F_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (flag_result.Data != 1)
                    {
                        return;
                    }

                    List<int> lenNos = new List<int>();
                    // 3. 读取PLC 出巷道 01
                    outputMessage = $"[{EPTS_CODE}]GET_Len_01=[ ]{plc_ini.Add_Len_01 + plc_ini.Add_LenNum_01}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    PLCResult<short> len_result = plc.Read<short>(plc_ini.Add_Len_01, plc_ini.Add_LenNum_01);
                    outputMessage = $"[{EPTS_CODE}]END_Len_01=[{len_result.Data}]{plc_ini.Add_Len_01 + plc_ini.Add_LenNum_01}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(1);
                    }
                    // 3. 读取PLC 出巷道 02
                    outputMessage = $"[{EPTS_CODE}]GET_Len_02=[ ]{plc_ini.Add_Len_02 + plc_ini.Add_LenNum_02}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    len_result = plc.Read<short>(plc_ini.Add_Len_02, plc_ini.Add_LenNum_02);
                    outputMessage = $"[{EPTS_CODE}]END_Len_02=[{len_result.Data}]{plc_ini.Add_Len_02 + plc_ini.Add_LenNum_02}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(2);
                    }
                    // 3. 读取PLC 出巷道 03
                    outputMessage = $"[{EPTS_CODE}]GET_Len_03=[ ]{plc_ini.Add_Len_03 + plc_ini.Add_LenNum_03}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    len_result = plc.Read<short>(plc_ini.Add_Len_03, plc_ini.Add_LenNum_03);
                    outputMessage = $"[{EPTS_CODE}]END_Len_03=[{len_result.Data}]{plc_ini.Add_Len_03 + plc_ini.Add_LenNum_03}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(3);
                    }
                    // 3. 读取PLC 出巷道 04
                    outputMessage = $"[{EPTS_CODE}]GET_Len_04=[ ]{plc_ini.Add_Len_04 + plc_ini.Add_LenNum_04}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    len_result = plc.Read<short>(plc_ini.Add_Len_04, plc_ini.Add_LenNum_04);
                    outputMessage = $"[{EPTS_CODE}]END_Len_04=[{len_result.Data}]{plc_ini.Add_Len_04 + plc_ini.Add_LenNum_04}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(4);
                    }
                    // 3. 读取PLC 出巷道 05
                    outputMessage = $"[{EPTS_CODE}]GET_Len_05=[ ]{plc_ini.Add_Len_05 + plc_ini.Add_LenNum_05}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    len_result = plc.Read<short>(plc_ini.Add_Len_05, plc_ini.Add_LenNum_05);
                    outputMessage = $"[{EPTS_CODE}]END_Len_05=[{len_result.Data}]{plc_ini.Add_Len_05 + plc_ini.Add_LenNum_05}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(5);
                    }
                    // 3. 读取PLC 出巷道 06
                    outputMessage = $"[{EPTS_CODE}]GET_Len_06=[ ]{plc_ini.Add_Len_06 + plc_ini.Add_LenNum_06}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    len_result = plc.Read<short>(plc_ini.Add_Len_06, plc_ini.Add_LenNum_06);
                    outputMessage = $"[{EPTS_CODE}]END_Len_06=[{len_result.Data}]{plc_ini.Add_Len_06 + plc_ini.Add_LenNum_06}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (len_result.Data > 0)
                    {
                        lenNos.Add(6);
                    }

                    if (lenNos.Count > 0)
                    {
                        // 5. 获取注浆ID
                        using (IDataAccess dataAccess = PLC_S_DataAccess.GetDataAccess())
                        {
                            dataAccess.BeginTransaction();
                            foreach (int lenNo in lenNos)
                            {
                                CDAParameter lenNopara = new CDAParameter("LINENO", lenNo);
                                string sqlString = "update tp_pm_defectivearea t set t.SEQNO = t.SEQNO-1 where t.LINENO = @LINENO@";
                                dataAccess.ExecuteNonQuery(sqlString, new CDAParameter("LINENO", lenNopara));
                            }

                            dataAccess.ExecuteNonQuery("delete from tp_pm_defectivearea where SEQNO < 1");
                            dataAccess.Commit();
                        }
                    }

                    // 7. 写入PLC 标识 = 2
                    outputMessage = $"[{EPTS_CODE}]SET_F_Code=[ ]{plc_ini.Add_F_Code + plc_ini.Add_F_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    PLCResult f_result = plc.Write<short>(plc_ini.Add_F_Code, plc_ini.Add_F_CodeNum, 2);
                    outputMessage = $"[{EPTS_CODE}]END_F_Code=[2]{plc_ini.Add_F_Code + plc_ini.Add_F_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);

                    // 7. 写入PLC ERROR标识 = 0
                    outputMessage = $"[{EPTS_CODE}]SET_E_Code=[ ]{plc_ini.Add_Error + plc_ini.Add_ErrorNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    PLCResult e_result = plc.Write<short>(plc_ini.Add_Error, plc_ini.Add_ErrorNum, 0);
                    outputMessage = $"[{EPTS_CODE}]END_E_Code=[0]{plc_ini.Add_Error + plc_ini.Add_ErrorNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                }
            }
            catch (Exception ex)
            {
                logger_e_out.OutputError(ex);
                logger_e.OutputError(ex);
                logger_t.OutputError(ex);
                FormLogShow?.ShowLog($"[{EPTS_CODE}]ERROR={ex.Message}");
            }
            finally
            {
                logger_t.EndTracking();
            }
        }

        public void Stop()
        {
            try
            {
                logger.OutputTrace($"{M_NAME}_Stoping:[{EPTS_CODE}]");
                FormLogShow?.ShowLog($"{M_NAME}_Stoping:[{EPTS_CODE}]");

                _Started = false;
                backgroundWorker?.CancelAsync();
                backgroundWorker?.Dispose();
                backgroundWorker = null;

                logger.OutputTrace($"{M_NAME}_Stoped:[{EPTS_CODE}]");
                FormLogShow?.ShowLog($"{M_NAME}_Stoped:[{EPTS_CODE}]");
            }
            catch (Exception ex)
            {
                logger.OutputError(ex);
            }
            finally
            {
                _Started = false;
            }
        }

        public void Dispose()
        {
            try
            {
                _Started = false;
                backgroundWorker?.CancelAsync();
                backgroundWorker?.Dispose();
                backgroundWorker = null;
            }
            catch (Exception ex)
            {
                logger.OutputError(ex);
            }
            finally
            {
                _Started = false;
            }
        }
    }
}