HEGII.gt.mes.plc/PLC/PLC_S/ServerModel/PieceWork.cs


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Threading;
using Curtain.Core;
using Curtain.DataAccess;
using Curtain.Extension.ExObjectConvert;
using Curtain.Extension.ExSystemData;
using Curtain.Framework.Json;
using Curtain.Helpers;
using Curtain.Log;
using Curtain.Net.Sockets.PLC;
using Curtain.Net.Sockets.PLC.Model;
using Curtain.Net.Sockets.PLC.Model.Melsec;
using PLC_S.Proxy;

namespace PLC_S.ServerModel
{
    /// <summary>
    /// 计件（2-20机械修坯助修）
    /// </summary>
    public class PieceWork : SocketServer<SimpleSocketServerModel>, IShowFormLog, IWindowsServer
    {
        public Dictionary<string, PLC_S_PW> PLC_FLAGS = new Dictionary<string, PLC_S_PW>();
        public Dictionary<string, PLC_S_GC> PLC_FLAGS_GC = new Dictionary<string, PLC_S_GC>();
        public const string M_NAME = "PW";
        private readonly MES_S _mes_s = null;
        private readonly Logger logger = Logger.CreateLogger(M_NAME);
        private readonly LogInfo logger_t = new LogInfo();
        private readonly LogInfo logger_e = new LogInfo();

        private bool _S_STOP = false;
        public int Interval
        {
            get;
            set;
        }
        public string EPTS_CODE
        {
            get;
            set;
        }

        public PieceWork()
        {
            logger.FileExistDays = 30;
            logger.FilePrefix = "";
            logger.FileSuffix = M_NAME;
            logger_t.LevelOneFile = true;
            logger.FileNameWithoutDate = true;

            logger_t.SubFolderFormat = "<name>";
            logger_t.FileExistDays = 30;
            logger_t.LevelOneFile = true;

            logger_e.FileExistDays = 0;

            this.Model.FormatType = CommandFormatType.StartStopChar;

            this.ServerStarting += ServerSocket_ServerStarting;
            this.ServerStarted += ServerSocket_ServerStarted;
            this.ServerStoping += ServerSocket_ServerStoping;
            this.ServerStoped += ServerSocket_ServerStoped;

            this.ServerMessage += ServerSocket_ServerMessage;
            this.Received += ServerSocket_Received;
            _mes_s = MES_S.Get();
        }

        #region Server
        public IFormLogShow FormLogShow
        {
            get;
            set;
        }

        private void ServerSocket_ServerStarting(object sender, CancelEventArgs e)
        {
            try
            {
                _S_STOP = false;
                logger.OutputTrace($"{M_NAME}_ServerStarting");
            }
            catch { }
        }
        private void ServerSocket_ServerStarted(object sender, EventArgs e)
        {
            try
            {
                _S_STOP = false;
                logger.OutputTrace($"{M_NAME}_ServerStarted");
            }
            catch { }
        }
        private void ServerSocket_ServerStoping(object sender, CancelEventArgs e)
        {
            try
            {
                _S_STOP = true;
                logger.OutputTrace($"{M_NAME}_ServerStoping");
            }
            catch { }
        }
        private void ServerSocket_ServerStoped(object sender, EventArgs e)
        {
            try
            {
                _S_STOP = true;
                logger.OutputTrace($"{M_NAME}_ServerStoped");
            }
            catch { }
        }
        private void ServerSocket_ServerMessage(object sender, ServerMessageEventArgs e)
        {
            try
            {
                _S_STOP = true;
                string message = e.ToString();
                string cip = e?.Client?.IP;
                if (e.Type == ServerMessageType.Debug)
                {
                    Logger.Debug(message, $"{M_NAME}-T[{cip}]", logger_t);
                }
                if (e.Type == ServerMessageType.Error)
                {
                    Logger.Error(e.Exception, message, $"{M_NAME}-E[{cip}]", logger_e);
                }
                if (e.Type == ServerMessageType.Trace)
                {
                    Logger.Trace(message, $"{M_NAME}-T[{cip}]", logger_t);
                }
                if (e.Type == ServerMessageType.Warning)
                {
                    Logger.Warn(message, $"{M_NAME}-E[{cip}]", logger_e);
                }
                FormLogShow?.ShowLog("ServerMessage=" + message);
            }
            catch { }
            try
            {
                if (e.Code == "CNS-T-001")
                {
                    string flag = "PW1201";
                    PLC_S_PW plc_s = new PLC_S_PW();
                    INIHelper ini = INIHelper.Create($@"PLC_S_INI\PLC_S_{M_NAME}.ini");
                    plc_s.IP = ini.Read(flag, "IP");
                    plc_s.Port = ini.Read(flag, "Port").ToInt32();
                    plc_s.Add_FlagCode = ini.Read(flag, "Add_FlagCode");
                    plc_s.Add_FlagCodeNum = ini.Read(flag, "Add_FlagCodeNum");

                    SocketClient<MelsecA1EAsciiModel> plc = new SocketClient<MelsecA1EAsciiModel>();
                    plc.Connect(plc_s.IP, plc_s.Port);

                    try
                    {
                        string outputMessage = $"[]SET_FlagCode=[0]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                        Logger.Trace(outputMessage, null, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                        plc?.Write<int>(plc_s.Add_FlagCode, plc_s.Add_FlagCodeNum, 0);
                        outputMessage = $"[]END_FlagCode=[0]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                        Logger.Trace(outputMessage, null, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                    }
                    catch
                    {
                    }
                    plc?.Disconnect();
                    plc?.Close();
                }
            }
            catch
            {
            }
        }
        #endregion

        private string _RECEIVED_CODE = null;
        /// <summary>
        /// 2-20机械修坯助修
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ServerSocket_Received(object sender, ReceiveSession e)
        {
            string cIP = e?.Client?.IP;
            string logKeyT = $"{M_NAME}-T[{cIP}]";
            string logKeyE = $"{M_NAME}-E[{cIP}]";
            string outputMessage = e.ToString();
            Logger.Trace(outputMessage, logKeyT, logger_t);
            FormLogShow?.ShowLog(outputMessage);

            string receivedCode = Guid.NewGuid().ToString();
            _RECEIVED_CODE = receivedCode;
            _S_STOP = true;
            lock (this)
            {
                if (_RECEIVED_CODE != receivedCode)
                {
                    outputMessage = $"[{e.Content}]不是当前请求，退出排队";
                    Logger.Warn(outputMessage, logKeyT, logger_t);
                    Logger.Warn(outputMessage, logKeyE, logger_e);
                    FormLogShow?.ShowLog(outputMessage);
                    return;
                }
                _S_STOP = false;
                PLC_S_PW plc_s = null;
                SocketClient<MelsecA1EAsciiModel> plc = null;
                try
                {
                    if (string.IsNullOrWhiteSpace(e.Content))
                    {
                        outputMessage = "接收数据为空";
                        Logger.Warn(outputMessage, logKeyT, logger_t);
                        Logger.Warn(outputMessage, logKeyE, logger_e);
                        FormLogShow?.ShowLog(outputMessage);
                        return;
                    }

                    outputMessage = e.Content;
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    string flag = null;
                    string[] c = e.Content.Split('#');

                    if (c.Length > 0)
                    {
                        flag = c[0];
                    }
                    string barcode = null;
                    if (c.Length > 1)
                    {
                        barcode = c[1];
                    }

                    plc_s = GetPLC_S_PW(flag, e, logKeyE);

                    if (plc_s == null || plc_s.USER_CDOES == null)
                    {
                        outputMessage = $"[{e.Content}]设备代码[{flag}]未找到ini配置或有错误";
                        Logger.Error(null, outputMessage, logKeyT, logger_t);
                        Logger.Error(null, outputMessage, logKeyE, logger_e);
                        FormLogShow?.ShowLog(outputMessage);
                        return;
                    }
                    plc = new SocketClient<MelsecA1EAsciiModel>();
                    plc.Connect(plc_s.IP, plc_s.Port);
                    outputMessage = $"[{e.Content}]PLC_Connect=[{plc_s.IP}:{plc_s.Port}]";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    if (string.IsNullOrWhiteSpace(flag))
                    {
                        outputMessage = $"[{e.Content}]接收设备代码为空";
                        Logger.Warn(outputMessage, logKeyT, logger_t);
                        Logger.Warn(outputMessage, logKeyE, logger_e);
                        FormLogShow?.ShowLog(outputMessage);
                        SendError(plc_s, e, logKeyT, logKeyE, plc);
                        return;
                    }
                    if (string.IsNullOrWhiteSpace(barcode) || barcode == "0" || barcode.StartsWith("0"))
                    {
                        outputMessage = $"[{e.Content}]接收条码为空";
                        Logger.Warn(outputMessage, logKeyT, logger_t);
                        Logger.Warn(outputMessage, logKeyE, logger_e);
                        FormLogShow?.ShowLog(outputMessage);
                        SendError(plc_s, e, logKeyT, logKeyE, plc);
                        return;
                    }

                    outputMessage = $"[{e.Content}]SET_FlagCode=[1]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);
                    //plc.Write<string>(plc_s.Add_FlagCode, plc_s.Add_FlagCodeNum, "1");
                    plc.Write<int>(plc_s.Add_FlagCode, plc_s.Add_FlagCodeNum, 1);
                    outputMessage = $"[{e.Content}]END_FlagCode=[1]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    //PLCResult<string> flag_result = null;
                    PLCResult<int> flag_result_int = null;
                    while (true)
                    {
                        Thread.Sleep(plc_s.Thread_Sleep);
                        outputMessage = $"[{e.Content}]GET_RoomCode=[ ]{plc_s.Add_RoomCode + plc_s.Add_RoomCodeNum}";
                        Logger.Trace(outputMessage, logKeyT, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                        //flag_result = plc.Read<string>(plc_s.Add_RoomCode, plc_s.Add_RoomCodeNum);
                        flag_result_int = plc.Read<int>(plc_s.Add_RoomCode, plc_s.Add_RoomCodeNum, 1);
                        outputMessage = $"[{e.Content}]END_RoomCode=[{flag_result_int.Data}]{plc_s.Add_RoomCode + plc_s.Add_RoomCodeNum}";
                        Logger.Trace(outputMessage, logKeyT, logger_t);
                        FormLogShow?.ShowLog(outputMessage);

                        //if (!string.IsNullOrWhiteSpace(flag_result.Data) &&
                        //    flag_result.Data != "0")
                        //{
                        //    break;
                        //}
                        if (flag_result_int.Data > 0)
                        {
                            break;
                        }
                        if (_S_STOP)
                        {
                            outputMessage = $"[{e.Content}]STOP[S]";
                            Logger.Trace(outputMessage, logKeyT, logger_t);
                            FormLogShow?.ShowLog(outputMessage);
                            //SendError(plc_s, e, logKeyT, logKeyE, plc);
                            return;
                        }
                    }

                    //string roomcode = flag_result?.Data;
                    //int room_num = 0;
                    //if (string.IsNullOrWhiteSpace(roomcode))
                    //{
                    //    room_num = Convert.ToInt32(roomcode);
                    //}
                    int room_num = flag_result_int.Data;
                    string roomcode = room_num.ToString();

                    outputMessage = $"[{e.Content}]SET_RoomCode=[0]{plc_s.Add_RoomCode + plc_s.Add_RoomCodeNum}";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);
                    //plc.Write<string>(plc_s.Add_RoomCode, plc_s.Add_RoomCodeNum, "0");
                    plc.Write<int>(plc_s.Add_RoomCode, plc_s.Add_RoomCodeNum, 0);
                    outputMessage = $"[{e.Content}]END_RoomCode=[0]{plc_s.Add_RoomCode + plc_s.Add_RoomCodeNum}";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    if (room_num < 1 || room_num > 2)
                    {
                        outputMessage = $"[{barcode}][{roomcode}]读取房号失败";
                        Logger.Warn(outputMessage, logKeyT, logger_t);
                        Logger.Warn(outputMessage, logKeyE, logger_e);
                        FormLogShow?.ShowLog(outputMessage);
                        SendError(plc_s, e, logKeyT, logKeyE, plc);
                        return;
                    }

                    //outputMessage = $"[{e.Content}]usercode_s=[{plc_s.USER_CDOE}]";
                    //Logger.Trace(outputMessage, logKeyT, logger_t);
                    //FormLogShow?.ShowLog(outputMessage);

                    string usercode = plc_s.USER_CDOES[room_num];
                    using (IDataAccess dataAccess = PLC_S_DataAccess.GetDataAccess(e))
                    {
                        string sqlString = $@"
                            SELECT t.usercode
                              FROM tp_mst_workstation t
                             WHERE t.workstationid = {usercode}
                            ";

                        usercode = dataAccess.ExecuteScalar(sqlString) + "";
                    }

                    outputMessage = $"[{e.Content}]usercode=[{usercode}]";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    string result = "OK";
                    outputMessage = $"[{e.Content}]AddWorkPieceByStatus3=[F:{plc_s.Add_GoodsCodeNum}][P_ID:{plc_s.P_ID}][Code:{roomcode}]";
                    Logger.Trace(outputMessage, logKeyT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);

                    if (plc_s.Add_GoodsCodeNum == "1")
                    {
                        result = SmartDeviceProxy.Instance.Invoke<string>(
                            p => p.AddWorkPieceByStatus3(
                                _mes_s.AccountCode,
                                usercode,
                                null,
                                plc_s.P_ID,
                                barcode,
                                roomcode));
                    }
                    // 返回状态（成功、失败）
                    if (result == "OK")
                    {
                        outputMessage = $"[{e.Content}]result=[OK]";
                        Logger.Trace(outputMessage, logKeyT, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                        return;
                    }

                    if (result == "EE")
                    {
                        outputMessage = $"[{e.Content}]result=[{result}]MES服务端异常（详情参见MES端日志）";
                    }
                    else if (result == "EU-01")
                    {
                        outputMessage = $"[{e.Content}]result=[{result}]无效的帐套或工号（详情参见MES端日志）";
                    }
                    else
                    {
                        outputMessage = $"[{e.Content}]result=[E][{result}]其他错误（详情参见MES端日志）";
                    }
                    Logger.Warn(outputMessage, logKeyT, logger_t);
                    Logger.Warn(outputMessage, logKeyE, logger_e);
                    FormLogShow?.ShowLog(outputMessage);
                    SendError(plc_s, e, logKeyT, logKeyE, plc);
                }
                catch (Exception ex)
                {
                    FormLogShow?.ShowLog($"[{e.Content}]ERROR={ex.Message}");
                    if (plc_s != null)
                    {
                        Logger.Error(ex, $"[{e.Content}]ERROR", logKeyT, logger_t);
                        Logger.Error(ex, $"[{e.Content}]ERROR", logKeyE, logger_e);
                        SendError(plc_s, e, logKeyT, logKeyE, plc);
                    }
                    else
                    {
                        Logger.Error(ex, $"[{e.Content}]ERROR-NOFLAG", logKeyT, logger_t);
                        Logger.Error(ex, $"[{e.Content}]ERROR-NOFLAG", logKeyE, logger_e);
                    }
                }
                finally
                {
                    try
                    {
                        outputMessage = $"[{e.Content}]SET_FlagCode=[0]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                        Logger.Trace(outputMessage, logKeyT, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                        plc?.Write<int>(plc_s.Add_FlagCode, plc_s.Add_FlagCodeNum, 0);
                        outputMessage = $"[{e.Content}]END_FlagCode=[0]{plc_s.Add_FlagCode + plc_s.Add_FlagCodeNum}";
                        Logger.Trace(outputMessage, logKeyT, logger_t);
                        FormLogShow?.ShowLog(outputMessage);
                    }
                    catch (Exception ex)
                    {
                        Logger.Error(ex, $"[{e.Content}]ERROR-FIN", logKeyT, logger_t);
                        Logger.Error(ex, $"[{e.Content}]ERROR-FIN", logKeyE, logger_e);
                        FormLogShow?.ShowLog($"[{e.Content}]ERROR-FIN={ex.Message}");
                    }
                    plc?.Disconnect();
                    plc?.Close();
                    e.ReturnMessage("0000");
                }
            }
        }

        private void SendError(PLC_S_PW plc_s, ReceiveSession e, string loggerNameT,
            string loggerNameE, SocketClient<MelsecA1EAsciiModel> plc)
        {
            try
            {
                //using (SocketClient<SiemensS7_1200Model> plc = new SocketClient<SiemensS7_1200Model>())
                {
                    string outputMessage = $"[{e.Content}]SET_ErrorNum=[1]{plc_s.Add_Error + plc_s.Add_ErrorNum}";
                    Logger.Trace(outputMessage, loggerNameT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);
                    plc?.Write<int>(plc_s.Add_Error, plc_s.Add_ErrorNum, 1);
                    outputMessage = $"[{e.Content}]END_ErrorNum=[1]{plc_s.Add_Error + plc_s.Add_ErrorNum}";
                    Logger.Trace(outputMessage, loggerNameT, logger_t);
                    FormLogShow?.ShowLog(outputMessage);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex, $"[{e.Content}]ERROR-SendError", loggerNameT, logger_t);
                Logger.Error(ex, $"[{e.Content}]ERROR-SendError", loggerNameE, logger_e);
                FormLogShow?.ShowLog($"[{e.Content}]ERROR-SendError={ex.Message}");
            }
        }

        private DataRow GetGoodsCode(string barcode, ReceiveSession e, string loggerName)
        {
            IDataAccess dataAccess = null;
            try
            {
                dataAccess = PLC_S_DataAccess.GetDataAccess(e);

                string sqlString = "select g.goodscode, g.seatcovercode\n" +
                "  from tp_pm_groutingdailydetail gdd\n" +
                " inner join tp_mst_goods g\n" +
                "    on g.goodsid = gdd.goodsid\n" +
                " where gdd.barcode = :barcode";
                DataTable dataTable = dataAccess.ExecuteDatatable(sqlString, new CDAParameter(":barcode", barcode));
                if (dataTable.HasData())
                {
                    return dataTable.Rows[0];
                }
                return null;
            }
            catch (Exception ex)
            {
                //Logger.Error(ex, $"[{e.Content}]ERROR-GetGoodsCode", loggerNameT, logger_t);
                Logger.Error(ex, $"[{e.Content}]ERROR-GetGoodsCode", loggerName, logger_e);
                FormLogShow?.ShowLog($"[{e.Content}]ERROR-GetGoodsCode={ex.Message}");
                return null;
            }
            finally
            {
                dataAccess?.Close();
            }
        }

        /// <summary>
        /// 记录喷釉房
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        private bool SetGlazingRoom(string barcode, string roomcode, ReceiveSession e, string loggerName)
        {
            IDataAccess dataAccess = null;
            try
            {
                dataAccess = PLC_S_DataAccess.GetDataAccess(e);

                string sqlString = "update tp_pm_groutingdailydetail g set g.glazingroom = :roomcode where g.barcode=:barcode";
                int i = dataAccess.ExecuteNonQuery(sqlString,
                    new CDAParameter[] { new CDAParameter(":roomcode", roomcode), new CDAParameter(":barcode", barcode) });
                return true;
            }
            catch (Exception ex)
            {
                //Logger.Error(ex, $"[{e.Content}]ERROR-SetGlazingRoom", loggerNameT, logger_t);
                Logger.Error(ex, $"[{e.Content}]ERROR-SetGlazingRoom", loggerName, logger_e);
                FormLogShow?.ShowLog($"[{e.Content}]ERROR-SetGlazingRoom={ex.Message}");
                return false;
            }
            finally
            {
                dataAccess?.Close();
            }
        }

        private PLC_S_GC GetPLC_S_GC(string flag, ReceiveSession e, string loggerName)
        {
            try
            {
                flag = "GC" + flag;
                if (PLC_FLAGS_GC.ContainsKey(flag))
                {
                    return PLC_FLAGS_GC[flag];
                }
                else
                {
                    PLC_S_GC plc_s = new PLC_S_GC();
                    INIHelper ini = INIHelper.Create($@"PLC_S_INI\PLC_S_{M_NAME}.ini");

                    plc_s.IP = ini.Read(flag, "IP");
                    plc_s.Port = ini.Read(flag, "Port").ToInt32();
                    plc_s.Add_Code = ini.Read(flag, "Add_Code");
                    plc_s.Add_CodeNum = ini.Read(flag, "Add_CodeNum");
                    plc_s.Add_BarCode = ini.Read(flag, "Add_BarCode");
                    plc_s.Add_BarCodeNum = ini.Read(flag, "Add_BarCodeNum");
                    plc_s.Add_Error = ini.Read(flag, "Add_Error");
                    plc_s.Add_ErrorNum = ini.Read(flag, "Add_ErrorNum");
                    PLC_FLAGS_GC.Add(flag, plc_s);
                    return plc_s;
                }
            }
            catch (Exception ex)
            {
                //Logger.Error(ex, $"[{e.Content}]ERROR-GetPLC_S_GC", loggerNameT, logger_t);
                Logger.Error(ex, $"[{e.Content}]ERROR-GetPLC_S_GC", loggerName, logger_e);
                FormLogShow?.ShowLog($"[{e.Content}]ERROR-GetPLC_S_GC={ex.Message}");
                return null;
            }
        }

        private PLC_S_PW GetPLC_S_PW(string flag, ReceiveSession e, string loggerName)
        {
            try
            {
                flag = "PW" + flag;
                if (PLC_FLAGS.ContainsKey(flag))
                {
                    return PLC_FLAGS[flag];
                }
                else
                {
                    PLC_S_PW plc_s = new PLC_S_PW();
                    INIHelper ini = INIHelper.Create($@"PLC_S_INI\PLC_S_{M_NAME}.ini");

                    plc_s.P_ID = ini.Read(flag, "P_ID").ToInt32();
                    plc_s.USER_CDOE = ini.Read(flag, "USER_CDOE");
                    plc_s.USER_CDOES = plc_s.USER_CDOE?.Split(',');
                    plc_s.USER_CDOE = JsonHelper.ToJson(plc_s.USER_CDOES);

                    plc_s.IP = ini.Read(flag, "IP");
                    plc_s.Port = ini.Read(flag, "Port").ToInt32();
                    plc_s.Add_GoodsCode = ini.Read(flag, "Add_GoodsCode");
                    plc_s.Add_GoodsCodeNum = ini.Read(flag, "Add_GoodsCodeNum");
                    plc_s.Add_RoomCode = ini.Read(flag, "Add_RoomCode");
                    plc_s.Add_RoomCodeNum = ini.Read(flag, "Add_RoomCodeNum");
                    plc_s.Thread_Sleep = ini.Read(flag, "Thread_Sleep").ToInt32();
                    if (plc_s.Thread_Sleep < 1000)
                    {
                        plc_s.Thread_Sleep = 1000;
                    }
                    plc_s.Add_FlagCode = ini.Read(flag, "Add_FlagCode");
                    plc_s.Add_FlagCodeNum = ini.Read(flag, "Add_FlagCodeNum");
                    plc_s.Add_Error = ini.Read(flag, "Add_Error");
                    plc_s.Add_ErrorNum = ini.Read(flag, "Add_ErrorNum");
                    PLC_FLAGS.Add(flag, plc_s);
                    return plc_s;
                }
            }
            catch (Exception ex)
            {
                //Logger.Error(ex, $"[{e.Content}]ERROR-GetPLC_S_PW", loggerNameT, logger_t);
                Logger.Error(ex, $"[{e?.Content}]ERROR-GetPLC_S_PW", loggerName, logger_e);
                FormLogShow?.ShowLog($"[{e?.Content}]ERROR-GetPLC_S_PW={ex.Message}");
                return null;
            }
        }

    }
}