HEGII.gt.mes.plc/PLC/PLC_S/EPTS/KilnLoad/EPTS_KilnLoad.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;

using Newtonsoft.Json.Linq;

using PLC_S.Proxy;

/// <summary>
/// 获取设备参数的定时服务
/// </summary>
namespace PLC_S.EPTS
{
    /// <summary>
    /// 登窑 6211 6212
    /// </summary>
    public class EPTS_KilnLoad : IWindowsServer, IShowFormLog
    {
        public const string M_NAME = "EPTS_KL";
        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;
        private MES_S _mes_s = null;

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

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

        public EPTS_KilnLoad()
        {
        }

        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
            {
                _mes_s = MES_S.Get();
                INI_KL plc_ini = INI_KL.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_KL 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;
                    }

                    // 2. 读取PLC 窑车号
                    outputMessage = $"[{EPTS_CODE}]GET_KC_Code=[ ]{plc_ini.Add_KC_Code + plc_ini.Add_KC_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    // 窑车号 固定长度
                    PLCResult<short> kc_result = plc.Read<short>(plc_ini.Add_KC_Code, plc_ini.Add_KC_CodeNum);
                    outputMessage = $"[{EPTS_CODE}]END_KC_Code=[{kc_result.Data}]{plc_ini.Add_KC_Code + plc_ini.Add_KC_CodeNum}";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);
                    if (kc_result.Data <= 0)
                    {
                        return;
                    }

                    string kilnCarCode = "TK3" + kc_result.Data.ToString("000");

                    // 3. 读取PLC 条码
                    JArray jArray = new JArray();
                    List<string> barcodes = new List<string>();
                    for (int i = 0; i < 24; i++)
                    {
                        JObject jToken = new JObject();
                        string code = plc_ini.Add_BarCodes[i];
                        string codeNum = plc_ini.Add_BarCodeNums[i];

                        outputMessage = $"[{EPTS_CODE}]GET_BarCode=[ ]{code + codeNum}";
                        logger_t.OutputTrace(outputMessage);
                        FormLogShow?.ShowLog(outputMessage);
                        PLCResult<string> bar_result = plc.Read<string>(code, codeNum, 11);
                        outputMessage = $"[{EPTS_CODE}]END_BarCode=[{bar_result.Data}]{code + codeNum}";
                        logger_t.OutputTrace(outputMessage);
                        FormLogShow?.ShowLog(outputMessage);
                        if (string.IsNullOrWhiteSpace(bar_result.Data) ||
                            bar_result.Data.StartsWith("\u0000") ||
                            bar_result.Data.StartsWith("0"))
                        {
                            continue;
                        }

                        if (barcodes.Contains(bar_result.Data))
                        {
                            continue;
                        }

                        barcodes.Add(bar_result.Data);
                        jToken.Add("barCode", bar_result.Data);
                        // select * from TP_MST_DataDictionary t where  DictionaryType = 'TPC003' id=87
                        jToken.Add("kilnCarPosition", i+87);
                        jArray.Add(jToken);
                    }
                    string jsonBarcodes = jArray.ToString();

                    // 登窑工号
                    string usercode = "";
                    using (IDataAccess dataAccess = PLC_S_DataAccess.GetDataAccess())
                    {
                        string sqlString = @"
                            SELECT t.usercode
                              FROM tp_mst_workstation t
                             WHERE t.workstationtypeid = 3202
                               AND t.workstationid = @workstationid@
                            ";
                        CDAParameter[] ps = new CDAParameter[]
                        {
                            new CDAParameter("workstationid", plc_ini.WS_ID),
                        };

                        DataTable dataTable = dataAccess.ExecuteDatatable(sqlString, ps);
                        if (dataTable.HasData())
                        {
                            usercode = dataTable.Rows[0]["usercode"].ToString();
                        }
                        outputMessage = $"[{EPTS_CODE}]DB_UserCode=[{usercode}]";
                        logger_t.OutputTrace(outputMessage);
                        FormLogShow?.ShowLog(outputMessage);
                    }

                    string result = SmartDeviceProxy.Instance.Invoke<string>(
                        p => p.AddWorkPieceKiln(_mes_s.AccountCode,
                        usercode, plc_ini.P_ID, kilnCarCode, jsonBarcodes, null));

                    outputMessage = $"[{EPTS_CODE}]MES_Result=[{result}]";
                    logger_t.OutputTrace(outputMessage);
                    FormLogShow?.ShowLog(outputMessage);

                    // 返回状态（成功、失败）
                    if (result != "OK")
                    {
                        if (result == "EE")
                        {
                            outputMessage = $"[{EPTS_CODE}]result=[{result}]MES服务端异常（详情参见MES端日志）";
                        }
                        else if (result == "EU-01")
                        {
                            outputMessage = $"[{EPTS_CODE}]result=[{result}]无效的帐套或工号（详情参见MES端日志）";
                        }
                        else if (result == "EU-02")
                        {
                            outputMessage = $"[{EPTS_CODE}]result=[{result}]无效的窑车号（详情参见MES端日志）";
                        }
                        else
                        {
                            outputMessage = $"[{EPTS_CODE}]result=[{result}]其他错误（详情参见MES端日志）";
                        }
                        logger_e_out.OutputError(null, outputMessage);
                        logger_t.OutputError(null, outputMessage);
                        logger_e.OutputError(null, outputMessage);
                        FormLogShow?.ShowLog(outputMessage);

                        // 7. 写入PLC ERROR标识 = 1
                        outputMessage = $"[{EPTS_CODE}]SET_E_Code=[ ]{plc_ini.Add_Error + plc_ini.Add_ErrorNum}";
                        logger_t.OutputTrace(outputMessage);
                        FormLogShow?.ShowLog(outputMessage);
                        PLCResult e1_result = plc.Write<short>(plc_ini.Add_Error, plc_ini.Add_ErrorNum, 1);
                        outputMessage = $"[{EPTS_CODE}]END_E_Code=[1]{plc_ini.Add_Error + plc_ini.Add_ErrorNum}";
                        logger_t.OutputTrace(outputMessage);
                        FormLogShow?.ShowLog(outputMessage);
                        return;
                    }

                    // 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;
            }
        }
    }
}