HEGII.gt.mes.plc/PLC/PLC_S/EPTS/Palletizing/EPTS_Palletizing.cs

using System;
using System.ComponentModel;
using System.Data;
using System.Threading;

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_Palletizing : IWindowsServer, IShowFormLog
	{
		public const string M_NAME = "EPTS_PZ";
		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_Palletizing()
		{
		}

		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_PZ plc_ini = INI_PZ.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_PZ 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 条码
					string code = plc_ini.Add_BarCode;
					string codeNum = plc_ini.Add_BarCodeNum;

					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"))
					{
						return;
					}

					// 取相关信息
					short seatcovercode = -1;
					short logoid = -1;
					short gmouldtypeid = -1;
					using (IDataAccess dataAccess = PLC_S_DataAccess.GetDataAccess())
					{
						string sqlString = @"
                        SELECT g.seatcovercode
                                ,gdd.logoid
                                ,g.goods_line_type
                            FROM tp_pm_groutingdailydetail gdd
                            INNER JOIN tp_mst_goods g
                            ON g.goodsid = gdd.goodsid
                            WHERE gdd.barcode = @barcode@";

						CDAParameter[] ps = new CDAParameter[]
						{
							new CDAParameter("barcode", bar_result.Data),
						};

						DataTable dataTable = dataAccess.ExecuteDatatable(sqlString, ps);
						if (dataTable.HasData())
						{
							seatcovercode = dataTable.Rows[0]["seatcovercode"].ToInt16();
							logoid = dataTable.Rows[0]["logoid"].ToInt16();
							gmouldtypeid = dataTable.Rows[0]["goods_line_type"].ToInt16();
						}
					}

					if (seatcovercode > -1)
					{
						// 写入PLC 盖板标识码
						outputMessage = $"[{EPTS_CODE}]SET_SeatCoverCode=[{seatcovercode}]{plc_ini.Add_SeatCoverCode + plc_ini.Add_SeatCoverCodeNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);
						PLCResult result = plc.Write<short>(plc_ini.Add_SeatCoverCode, plc_ini.Add_SeatCoverCodeNum, seatcovercode);
						outputMessage = $"[{EPTS_CODE}]END_SeatCoverCode=[{seatcovercode}]{plc_ini.Add_SeatCoverCode + plc_ini.Add_SeatCoverCodeNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);

						// 写入PLC 商标
						outputMessage = $"[{EPTS_CODE}]SET_logoid=[{logoid}]{plc_ini.Add_LogoID + plc_ini.Add_LogoIDNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);
						result = plc.Write<short>(plc_ini.Add_LogoID, plc_ini.Add_LogoIDNum, logoid);
						outputMessage = $"[{EPTS_CODE}]END_logoid=[{logoid}]{plc_ini.Add_LogoID + plc_ini.Add_LogoIDNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);

						// 写入PLC 商标
						outputMessage = $"[{EPTS_CODE}]SET_gmouldtypeid=[{gmouldtypeid}]{plc_ini.Add_GmouldTypeID + plc_ini.Add_GmouldTypeIDNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);
						result = plc.Write<short>(plc_ini.Add_GmouldTypeID, plc_ini.Add_GmouldTypeIDNum, gmouldtypeid);
						outputMessage = $"[{EPTS_CODE}]END_gmouldtypeid=[{gmouldtypeid}]{plc_ini.Add_GmouldTypeID + plc_ini.Add_GmouldTypeIDNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);

						// 写入PLC ERROR标识 = 0
						outputMessage = $"[{EPTS_CODE}]SET_E_Code=[0]{plc_ini.Add_Error + plc_ini.Add_ErrorNum}";
						logger_t.OutputTrace(outputMessage);
						FormLogShow?.ShowLog(outputMessage);
						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);
					}
					else
					{
						// 写入PLC ERROR标识 = 1
						outputMessage = $"[{EPTS_CODE}]SET_E_Code=[1]{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);
					}

					// 写入PLC 标识 = 2
					outputMessage = $"[{EPTS_CODE}]SET_F_Code=[2]{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);
				}
			}
			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;
			}
		}
	}
}