using IWareCC.CacheInfo; using IWareCC.CacheInfo.Container; using IWareCC.ChaiDie.Entity; using IWareCC.ChaiDie.Handle.DoChaiDieTaskAuto; using IWareCC.ChaiDie.Handle.FinishChaiDieTaskAuto; using IWareCC.Conveyor.Entity; using IWareCC.Conveyor.Handle.DoConveyorTaskAuto; using IWareCC.Conveyor.Handle.FinishConveyorTaskAuto; using IWareCC.DecomposeTask.Handle.DecomposeTask; using IWareCC.DevInforService; using IWareCC.Extend; using IWareCC.HandleTask.Handle.HandleTask; using IWareCC.ORM; using IWareCC.Properties; using IWareCC.RGV.Entity; using IWareCC.RGV.Handle.DoRgvTaskAuto; using IWareCC.RGV.Handle.FinishRgvTaskAuto; using IWareCC.SRM.Entity; using IWareCC.SRM.Handle.DoStackerTaskAuto; using IWareCC.SRM.Handle.FinishStackerTaskAuto; using IWareCC.WCf.ControlCenterWcfService; using IWareCommon.Enum.Chaidie; using IWareCommon.Enum.Common; using IWareCommon.Enum.Conveyor; using IWareCommon.Enum.Rgv; using IWareCommon.Enum.Srm; using IWareCommon.Help; using S7.Net; using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Diagnostics; using System.Linq; using System.ServiceModel; using System.ServiceProcess; using System.Text; using System.Threading; using System.Threading.Tasks; namespace IWareCC { partial class Service : ServiceBase { /// /// 过去已经生成过的任务号集合 【EditBy shaocx,2022-09-18】 /// public static List existTaskCodeList = new List(); Thread AutoClearTaskOlderThey7Day; private bool COnline = false; private int COffLineTimes = 0; private int CHandShake = 0; private int CLastHandShake = 0; #region 外形检测是否通过 /// /// 获取外行检测线程 /// private Thread GetCheckShapeThreads; #endregion #region WCF服务 /// /// ControlCenterWcf服务 /// private ServiceHost ControlCenterWcfHost = null; #endregion #region 发送WCS心跳 /// /// 发送堆垛机的心跳 /// private List SendStackerHeartThreads = new List(); /// /// 发送RGV的心跳 /// private List SendRGVHeartThreads = new List(); /// /// 发送输送线与RGV的心跳 /// private Thread SendConveyorAndChaiDeiHeartThread; #endregion #region 设备状态 /// /// 获取每台堆垛机状态的线程 /// private List GetStackerStateThreads = new List(); #region 获取每种类型输送线信息 /// /// 获取每条输送线的状态线程 /// private List GetConveyors1StateThreads = new List(); /// /// 获取每条输送线的状态线程 /// private List GetConveyors2StateThreads = new List(); /// /// 获取每条输送线的状态线程 /// private List GetConveyors3StateThreads = new List(); /// /// 获取每条输送线的状态线程 /// private List GetConveyors4StateThreads = new List(); /// /// 获取每条输送线的状态线程 /// private List GetConveyors5StateThreads = new List(); #endregion /// /// 获取每台Rgv的状态线程 /// private List GetRgvStateThreads = new List(); /// /// 获取每台拆叠机的状态线程 /// private List GetChaiDieStateThreads = new List(); #endregion #region 检查设备是否在线 /// /// 检测拆叠机是否在线 /// private List CheckChaiDieIsOnLineThreads = new List(); /// /// 检测RGV是否在线 /// private List CheckRgvIsOnLineThreads = new List(); /// /// 检测输送线是否在线 /// private List CheckConveyorIsOnLineThreads = new List(); /// /// 检测输送线是否在线 /// private List CheckStackerIsOnLineThreads = new List(); private Thread CheckConveyorAndChaiDieIsOnLineThread; #endregion #region 设备离线次数 /// /// 添加拆叠机离线次数 /// private List AddChaiDieOffLineTimesThreads = new List(); /// /// 添加RGV离线次数 /// private List AddRgvOffLineTimesThreads = new List(); /// /// 添加输送线离线次数 /// private List AddConveyorOffLineTimesThreads = new List(); /// /// 添加堆垛机离线次数 /// private List AddStackerOffLineTimesThreads = new List(); #endregion #region 发送设备报警信息 /// /// 发送拆叠机告警状态的线程 /// private List SendChaiDieAlertThreads = new List(); /// /// 发送RGV告警状态的线程 /// private List SendRgvAlertThreads = new List(); /// /// 发送输送线告警状态的线程 /// private List SendConveyorAlertThreads = new List(); /// /// 发送堆垛机告警状态的线程 /// private List SendStackerAlertThreads = new List(); #endregion #region 分解处理任务 /// /// 分解任务的线程 /// private Thread DecomposeTaskThread = null; /// /// 处理任务的线程 /// private Thread HandleTaskThread = null; #endregion #region 给设备自动发送任务 /// /// 自动执行堆垛机任务 /// private Thread DoStackerTaskAutoThreads; /// /// 自动执行RGV任务 /// private Thread DoRgvTaskAutoThreads; /// /// 自动执行输送线任务 /// private Thread DoConveyorTaskAutoThreads; /// /// 自动执行拆盘机任务 /// private Thread DoChaiDieTaskAutoThreads; #endregion #region 设备完成任务反馈 /// /// 自动完成堆垛机任务 /// private List FinishStackerTaskAutoThreads = new List(); /// /// 自动完成RGV任务 /// private List FinishRgvTaskAutoThreads = new List(); /// /// 自动完成输送线任务 /// private Thread FinishConveyorTaskAutoThreads; /// /// 自动完成拆盘机任务 /// private List FinishChaiDieTaskAutoThreads = new List(); #endregion #region STP置位 private List RsetConveyorStpThreads = new List(); private List RsetRgvStpThreads = new List(); private List RsetChaiDieStpThreads = new List(); #endregion public Service() { InitializeComponent(); } protected override void OnStart(string[] args) { LogTextHelper.WriteLine(Resources.LogDir, "西门子IWareCC服务开始启动!"); #region 开启WCF服务 //ControlCenterWcf服务 ControlCenterWcfHost = new ServiceHost(typeof(ControlCenterWcfService)); ControlCenterWcfHost.Open(); #endregion #region 设备状态信息 //开启获取每台堆垛机状态的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetStackerState)); thread.Name = string.Format("获取输堆垛机{0}的状态", x.SrmName); GetStackerStateThreads.Add(thread); StartThread(thread, x); }); #region 分别获取每种类型输送线信息 //开启获取每条输送机状态的线程 CacheEntity.Conveyors.Where(x => x.ConveyorType == 1).ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetConveyorState1)); thread.Name = string.Format("获取输送线{0}的状态", x.ConveyorName); GetConveyors1StateThreads.Add(thread); StartThread(thread, x); }); //开启获取每条输送机状态的线程 CacheEntity.Conveyors.Where(x => x.ConveyorType == 2).ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetConveyorState2)); thread.Name = string.Format("获取输送线{0}的状态", x.ConveyorName); GetConveyors2StateThreads.Add(thread); StartThread(thread, x); }); //开启获取每条输送机状态的线程 CacheEntity.Conveyors.Where(x => x.ConveyorType == 3).ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetConveyorState3)); thread.Name = string.Format("获取输送线{0}的状态", x.ConveyorName); GetConveyors3StateThreads.Add(thread); StartThread(thread, x); }); //开启获取每条输送机状态的线程 CacheEntity.Conveyors.Where(x => x.ConveyorType == 4 || x.ConveyorType == 5).ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetConveyorState4)); thread.Name = string.Format("获取输送线{0}的状态", x.ConveyorName); GetConveyors4StateThreads.Add(thread); StartThread(thread, x); }); //开启获取每条输送机状态的线程 CacheEntity.Conveyors.Where(x => x.ConveyorType == 6 || x.ConveyorType == 7).ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetConveyorState5)); thread.Name = string.Format("获取输送线{0}的状态", x.ConveyorName); GetConveyors5StateThreads.Add(thread); StartThread(thread, x); }); #endregion //开启获取每台Rgv状态的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetRgvState)); thread.Name = string.Format("获取Rgv{0}的状态", x.RgvName); GetRgvStateThreads.Add(thread); StartThread(thread, x); }); //开启获取每台拆叠机状态的线程 CacheEntity.ChaiDies.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(GetChaiDieState)); thread.Name = string.Format("获取Rgv{0}的状态", x.ChaiDieName); GetChaiDieStateThreads.Add(thread); StartThread(thread, x); }); #endregion #region 检测设备是否在线 //开启检查堆垛机是否在线的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(CheckStackerIsOnLine)); thread.Name = string.Format("自动检测堆垛机{0}是否在线", x.SrmName); CheckStackerIsOnLineThreads.Add(thread); StartThread(thread, x); }); //开启检查RGV是否在线的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(CheckRgvIsOnLine)); thread.Name = string.Format("自动检测Rgv{0}是否在线", x.RgvName); CheckRgvIsOnLineThreads.Add(thread); StartThread(thread, x); }); CheckConveyorAndChaiDieIsOnLineThread = new Thread(new ThreadStart(ConveyorAndChaiDieIsOnLine)); CheckConveyorAndChaiDieIsOnLineThread.Name = string.Format("自动检测输送线是否在线"); StartThread(CheckConveyorAndChaiDieIsOnLineThread); //开启检查输送线是否在线的线程 CacheEntity.Conveyors.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(CheckConveyorIsOnLine)); thread.Name = string.Format("自动检测输送线{0}是否在线", x.ConveyorName); CheckConveyorIsOnLineThreads.Add(thread); StartThread(thread, x); }); //开启检查拆叠机是否在线的线程 CacheEntity.ChaiDies.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(CheckChaiDieIsOnLine)); thread.Name = string.Format("自动检测拆叠机{0}是否在线", x.ChaiDieName); CheckChaiDieIsOnLineThreads.Add(thread); StartThread(thread, x); }); #endregion #region 设备发送心跳 //开启发送堆垛机心跳的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendStackerHeart)); thread.Name = string.Format("自动发送堆垛机{0}心跳", x.SrmName); SendStackerHeartThreads.Add(thread); StartThread(thread, x); }); //开启发送堆垛机心跳的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendRGVHeart)); thread.Name = string.Format("自动发送堆垛机{0}心跳", x.RgvName); SendRGVHeartThreads.Add(thread); StartThread(thread, x); }); //开启发送输送线心跳的线程 SendConveyorAndChaiDeiHeartThread = new Thread(new ThreadStart(SendConveyorAndChaiDeiHeart)); SendConveyorAndChaiDeiHeartThread.Name = string.Format("自动发送输送线心跳"); StartThread(SendConveyorAndChaiDeiHeartThread); #endregion #region 开启外行检测线程 //外形检测 GetCheckShapeThreads = new Thread(new ThreadStart(GetCheckShape)); GetCheckShapeThreads.Name = string.Format("外形检测线程"); StartThread(GetCheckShapeThreads); #endregion #region 设备添加离线次数 //开启添加堆垛机离线次数的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(AddStackerOffLineTimes)); thread.Name = string.Format("自动添加堆垛机{0}离线次数", x.SrmName); AddStackerOffLineTimesThreads.Add(thread); StartThread(thread, x); }); //开启添加RGV离线次数的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(AddRgvOffLineTimes)); thread.Name = string.Format("自动添加Rgv{0}离线次数", x.RgvName); AddRgvOffLineTimesThreads.Add(thread); StartThread(thread, x); }); //开启添加输送线离线次数的线程 CacheEntity.Conveyors.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(AddConveyorOffLineTimes)); thread.Name = string.Format("自动添加输送线{0}离线次数", x.ConveyorName); AddConveyorOffLineTimesThreads.Add(thread); StartThread(thread, x); }); //开启添加拆叠机离线次数的线程 CacheEntity.ChaiDies.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(AddChaiDieOffLineTimes)); thread.Name = string.Format("自动添加拆叠机{0}离线次数", x.ChaiDieName); AddChaiDieOffLineTimesThreads.Add(thread); StartThread(thread, x); }); #endregion #region 设备发送报警信息 //开启发送堆垛机报警的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendStackerAlert)); thread.Name = string.Format("自动发送堆垛机{0}报警信息", x.SrmName); SendStackerAlertThreads.Add(thread); StartThread(thread, x); }); //开启发送RGV报警的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendRgvAlert)); thread.Name = string.Format("自动发送Rgv{0}报警信息", x.RgvName); SendRgvAlertThreads.Add(thread); StartThread(thread, x); }); //开启发送输送线报警的线程 CacheEntity.Conveyors.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendConveyorAlert)); thread.Name = string.Format("自动发送输送线{0}报警信息", x.ConveyorName); SendConveyorAlertThreads.Add(thread); StartThread(thread, x); }); //开启发送拆叠机报警的线程 CacheEntity.ChaiDies.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(SendChaiDieAlert)); thread.Name = string.Format("自动发送拆叠机{0}报警信息", x.ChaiDieName); SendChaiDieAlertThreads.Add(thread); StartThread(thread, x); }); #endregion #region 分解处理任务线程 //开启分解任务的线程 DecomposeTaskThread = new Thread(new ThreadStart(DecomposeTask)); DecomposeTaskThread.Name = "分解任务"; StartThread(DecomposeTaskThread); //开启处理任务的线程 HandleTaskThread = new Thread(new ThreadStart(HandleTask)); HandleTaskThread.Name = "处理任务"; StartThread(HandleTaskThread); #endregion #region 自动执行任务 //开启自动执行堆垛机任务的线程 DoStackerTaskAutoThreads = new Thread(new ParameterizedThreadStart(DoStackerTaskAuto)); DoStackerTaskAutoThreads.Name = string.Format("自动执行堆垛机任务"); StartThread(DoStackerTaskAutoThreads); //开启自动执行Rgv任务的线程 DoRgvTaskAutoThreads = new Thread(new ParameterizedThreadStart(DoRgvTaskAuto)); DoRgvTaskAutoThreads.Name = string.Format("自动执行Rgv任务"); StartThread(DoRgvTaskAutoThreads); //开启自动执行输送线任务的线程 DoConveyorTaskAutoThreads = new Thread(new ParameterizedThreadStart(DoConveyorTaskAuto)); DoConveyorTaskAutoThreads.Name = string.Format("自动执行输送线任务"); StartThread(DoConveyorTaskAutoThreads); //开启自动执行拆叠机任务的线程 DoChaiDieTaskAutoThreads = new Thread(new ParameterizedThreadStart(DoChaiDieTaskAuto)); DoChaiDieTaskAutoThreads.Name = string.Format("自动执行拆叠机任务"); StartThread(DoChaiDieTaskAutoThreads); #endregion #region 自动完成任务 //开启自动执行堆垛机任务的线程 CacheEntity.Srms.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(FinishStackerTaskAuto)); thread.Name = string.Format("自动完成堆垛机{0}的任务", x.SrmName); FinishStackerTaskAutoThreads.Add(thread); StartThread(thread, x); }); //开启自动执行Rgv任务的线程 CacheEntity.Rgvs.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(FinishRgvTaskAuto)); thread.Name = string.Format("自动完成Rgv{0}的任务", x.RgvName); FinishRgvTaskAutoThreads.Add(thread); StartThread(thread, x); }); //开启自动执行输送线任务的线程 FinishConveyorTaskAutoThreads = new Thread(new ParameterizedThreadStart(FinishConveyorTaskAuto)); FinishConveyorTaskAutoThreads.Name = string.Format("自动完成输送线任务"); ; StartThread(FinishConveyorTaskAutoThreads); //开启自动执行拆叠机任务的线程 CacheEntity.ChaiDies.ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(FinishChaiDieTaskAuto)); thread.Name = string.Format("自动完成拆叠机{0}的任务", x.ChaiDieName); FinishChaiDieTaskAutoThreads.Add(thread); StartThread(thread, x); }); #endregion #region 开启STP置位 CacheEntity.Conveyors.ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(RsetConveyorStp)); thread.Name = string.Format("获取输送线{0}的Stp状态", x.ConveyorName); RsetConveyorStpThreads.Add(thread); StartThread(thread, x); }); CacheEntity.Rgvs.ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(RsetRgvStp)); thread.Name = string.Format("获取RGV{0}的Stp状态", x.RgvName); RsetRgvStpThreads.Add(thread); StartThread(thread, x); }); CacheEntity.ChaiDies.ToList().ForEach(x => { var thread = new Thread(new ParameterizedThreadStart(RsetChaiDieStp)); thread.Name = string.Format("获取拆叠{0}的Stp状态", x.ChaiDieName); RsetChaiDieStpThreads.Add(thread); StartThread(thread, x); }); #endregion #region 开启自动清除7天前任务 AutoClearTaskOlderThey7Day = new Thread(AutoClearTask); AutoClearTaskOlderThey7Day.IsBackground = true; AutoClearTaskOlderThey7Day.Start(); #endregion } private void AutoClearTask() { bool tick = false; while (true) { Thread.Sleep(500); if (DateTime.Now.Hour == 1 && DateTime.Now.Minute == 0 && DateTime.Now.Second == 0 && tick == false) { tick = true; Thread.Sleep(1000); } if (tick) { DateTime t1 = DateTime.Now; DateTime t2 = t1.AddDays(-7); try { using (DbModel wcs = new DbModel()) { wcs.Database.ExecuteSqlCommand("Delete MainTask where sendtime<{0}", t2.ToString()); wcs.Database.ExecuteSqlCommand("Delete PartTask where createtime<{0}", t2.ToString()); tick = false; } } catch (Exception e) { LogTextHelper.WriteLine(Resources.LogDir, "清除7日前任务记录失败!Message:{0}", e.Message); } } } } protected override void OnStop() { LogTextHelper.WriteLine(Resources.LogDir, "西门子IWareCC服务开始关闭!"); #region 关闭WCF服务 //关闭ControleCenter服务 CloseWcf(ControlCenterWcfHost); #endregion #region 关闭心跳发送 //关闭发送Srm心跳线程 SendStackerHeartThreads.ForEach(x => CloseThread(x)); //关闭发送Rgv心跳线程 SendRGVHeartThreads.ForEach(x => CloseThread(x)); //关闭发送输送线与拆叠机心跳发送线程 CloseThread(SendConveyorAndChaiDeiHeartThread); #endregion #region 关闭外形检测线程 CloseThread(GetCheckShapeThreads); #endregion #region 关闭获取设备状态的线程 //关闭每台堆垛机获取状态的线程 GetStackerStateThreads.ForEach(x => CloseThread(x)); //关闭每条输送线获取状态的线程 GetConveyors1StateThreads.ForEach(x => CloseThread(x)); GetConveyors2StateThreads.ForEach(x => CloseThread(x)); GetConveyors3StateThreads.ForEach(x => CloseThread(x)); GetConveyors4StateThreads.ForEach(x => CloseThread(x)); GetConveyors5StateThreads.ForEach(x => CloseThread(x)); //关闭每台Rgv获取状态的线程 GetRgvStateThreads.ForEach(x => CloseThread(x)); //关闭每台拆叠机获取状态的线程 GetChaiDieStateThreads.ForEach(x => CloseThread(x)); #endregion #region 关闭检测设备是否在线的线程 //关闭每台堆垛机检测是否在线的线程 CheckStackerIsOnLineThreads.ForEach(x => CloseThread(x)); //关闭每条输送线检测是否在线的线程 CheckConveyorIsOnLineThreads.ForEach(x => CloseThread(x)); //关闭每台Rgv检测是否在线的线程 CheckRgvIsOnLineThreads.ForEach(x => CloseThread(x)); //关闭每台拆叠机检测是否在线的线程 CheckChaiDieIsOnLineThreads.ForEach(x => CloseThread(x)); //关闭检测是否在线的线程 CloseThread(CheckConveyorAndChaiDieIsOnLineThread); #endregion #region 关闭添加设备离线次数的线程 //关闭每台堆垛机添加离线次数线程 AddStackerOffLineTimesThreads.ForEach(x => CloseThread(x)); //关闭每条输送线添加离线次数线程 AddConveyorOffLineTimesThreads.ForEach(x => CloseThread(x)); //关闭每台Rgv添加离线次数线程 AddRgvOffLineTimesThreads.ForEach(x => CloseThread(x)); //关闭每台拆叠机添加离线次数线程 AddChaiDieOffLineTimesThreads.ForEach(x => CloseThread(x)); #endregion #region 关闭发送设备报警信息的线程 //关闭每台堆垛机发送报警信息的线程 SendStackerAlertThreads.ForEach(x => CloseThread(x)); //关闭每条输送线发送报警信息的线程 SendConveyorAlertThreads.ForEach(x => CloseThread(x)); //关闭每台Rgv发送报警信息的线程 SendRgvAlertThreads.ForEach(x => CloseThread(x)); //关闭每台拆叠机发送报警信息的线程 SendChaiDieAlertThreads.ForEach(x => CloseThread(x)); #endregion #region 关闭分解处理任务的线程 //关闭分解任务的线程 CloseThread(DecomposeTaskThread); //关闭处理任务的线程 CloseThread(HandleTaskThread); #endregion #region 关闭设备执行任务的线程 //关闭每台堆垛机自动执行任务的线程 CloseThread(DoStackerTaskAutoThreads); //关闭每条输送线自动执行任务的线程 CloseThread(DoConveyorTaskAutoThreads); //关闭每台Rgv自动执行任务的线程 CloseThread(DoRgvTaskAutoThreads); //关闭每台拆叠机自动执行任务的线程 CloseThread(DoChaiDieTaskAutoThreads); #endregion #region 关闭设备完成任务的线程 //关闭每台堆垛机自动完成任务的线程 FinishStackerTaskAutoThreads.ForEach(x => CloseThread(x)); //关闭每条输送线自动完成任务的的线程 CloseThread(FinishConveyorTaskAutoThreads); //关闭每台Rgv自动完成任务的线程 FinishRgvTaskAutoThreads.ForEach(x => CloseThread(x)); //关闭每台拆叠机自动完成任务的线程 FinishChaiDieTaskAutoThreads.ForEach(x => CloseThread(x)); #endregion #region 关闭stp置位 RsetConveyorStpThreads.ForEach(x => CloseThread(x)); RsetRgvStpThreads.ForEach(x => CloseThread(x)); RsetChaiDieStpThreads.ForEach(x => CloseThread(x)); #endregion #region 关闭自动清除7天前任务 CloseThread(AutoClearTaskOlderThey7Day); #endregion } #region STP置位 private void RsetRgvStp(object obj) { var s = (RgvEntity)obj; while (true) { try { if (s.WStb && s.RAck) { if (s.WriteValue(s.OpcWriteItems.Stb, 0)) { s.WriteValue(s.OpcWriteItems.Stb, 0); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "RGV{0}STP状态置位失败:{1}", s.RgvName, ex.Message); } Thread.Sleep(200); } } private void RsetConveyorStp(object obj) { var s = (ConveyorEntity)obj; while (true) { try { if (s.WSTP && s.RAck) { if (s.WriteValue(s.OpcWriteItems.STP, 0)) { s.WriteValue(s.OpcWriteItems.STP, 0); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}STP状态置位失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } private void RsetChaiDieStp(object obj) { var s = (ChaiDieEntity)obj; while (true) { try { if (s.WSTP && s.RACK) { if (s.WriteValue(s.OpcWriteItems.STP, 0) && s.WriteValue(s.OpcWriteItems.NeedCon, 0)) { s.WriteValue(s.OpcWriteItems.STP, 0); s.WriteValue(s.OpcWriteItems.NeedCon, 0); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "拆叠机{0}STP状态置位失败:{1}", s.ChaiDieName, ex.Message); } Thread.Sleep(200); } } #endregion #region 外形检测 private void GetCheckShape() { while (true) { try { using (var dbModel = new DbModel()) { var parttask = dbModel.PartTasks.FirstOrDefault(x => (x.sourceplace == "1021" || x.sourceplace == "1026") && x.isreleased == 1 && x.isfinished == 0); if (parttask != null) { string name = "Line" + parttask.sourceplace; var conveyor = CacheEntity.Conveyors.FirstOrDefault(x => x.ConveyorName == name); if (conveyor.RShape == 1 || conveyor.RShape == 2 || conveyor.RShape == 3 || conveyor.RShape == 4 || conveyor.RShape == 5) { var maintask = dbModel.MainTasks.OrderByDescending(x => x.id).FirstOrDefault(x => x.id == parttask.maintaskid); if (maintask != null) { maintask.finishstatus = 2;//,使用枚举 EMainTaskFinishstatus parttask.nexthandel = (int)ENextHandelTask.已全部完成; parttask.ishandled = 1; parttask.isfinished = 1; parttask.isreleased = 1; dbModel.SaveChanges(); } } } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "外形检测 失败:{0}", ex.Message); } Thread.Sleep(2000); } } #endregion #region 设备发送报警信息 private void SendStackerAlert(object obj) { var s = (SrmEntity)obj; while (true) { using (var dbModel = new DbModel()) { try { var alertList = new List(); var alerts = dbModel.DevAlerts.Where(x => x.name == s.SrmName && x.isfinished == (int)EYesOrNo.否).ToList(); if (s.RAlarm) { bool b1 = Enum.IsDefined(typeof(ESrmAlarm), s.RAlarmCode); string alertnumber = s.RAlarmCode.ToString(); var alert = alerts.FirstOrDefault(x => x.alertcode == alertnumber); if (alert == null && b1) { var devalert = new DevAlert() { name = s.SrmName, createtime = DateTime.Now, type = (int)EDevType.堆垛机, eqname = s.DeviceId.ToString(), finishtime = DateTime.Now, isfinished = (int)EYesOrNo.否, alertcode = s.RAlarmCode.ToString(), alertname = ((ESrmAlarm)s.RAlarmCode).ToString() }; dbModel.DevAlerts.Add(devalert); dbModel.SaveChanges(); } } else { if (alerts != null) { alerts.ForEach(x => { x.isfinished = (int)EYesOrNo.是; x.finishtime = DateTime.Now; alertList.Add(x); }); dbModel.SaveChanges(); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "记录堆垛机告警失败:{0}", ex.Message); } } Thread.Sleep(5000); } } private void SendRgvAlert(object obj) { var s = (RgvEntity)obj; while (true) { using (var dbModel = new DbModel()) { try { var alertList = new List(); var alerts = dbModel.DevAlerts.Where(x => x.name == s.RgvName && x.isfinished == (int)EYesOrNo.否).ToList(); if (s.RAlarm) { bool b1 = Enum.IsDefined(typeof(ERgvAlarm), s.RAlarmCode); string alertnumber = s.RAlarmCode.ToString(); var alert = alerts.FirstOrDefault(x => x.alertcode == alertnumber); if (alert == null && b1) { var devalert = new DevAlert() { name = s.RgvName, createtime = DateTime.Now, type = (int)EDevType.RGV, eqname = s.DeviceId.ToString(), finishtime = DateTime.Now, isfinished = (int)EYesOrNo.否, alertcode = s.RAlarmCode.ToString(), alertname = ((ERgvAlarm)s.RAlarmCode).ToString() }; dbModel.DevAlerts.Add(devalert); dbModel.SaveChanges(); } } else { if (alerts != null) { alerts.ForEach(x => { x.isfinished = (int)EYesOrNo.是; x.finishtime = DateTime.Now; alertList.Add(x); }); dbModel.SaveChanges(); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "记录RGV告警失败:{0}", ex.Message); } } Thread.Sleep(5000); } } private void SendConveyorAlert(object obj) { var s = (ConveyorEntity)obj; while (true) { using (var dbModel = new DbModel()) { try { var alertList = new List(); var alerts = dbModel.DevAlerts.Where(x => x.name == s.ConveyorName && x.isfinished == (int)EYesOrNo.否).ToList(); if (s.RAlarm) { bool b1 = Enum.IsDefined(typeof(EConveyorAlarm), s.RAlarmCode); string alertnumber = s.RAlarmCode.ToString(); var alert = alerts.FirstOrDefault(x => x.alertcode == alertnumber); if (alert == null && b1) { var devalert = new DevAlert() { name = s.ConveyorName, createtime = DateTime.Now, type = (int)EDevType.输送线, eqname = s.DeviceId.ToString(), finishtime = DateTime.Now, isfinished = (int)EYesOrNo.否, alertcode = s.RAlarmCode.ToString(), alertname = ((EConveyorAlarm)s.RAlarmCode).ToString() }; dbModel.DevAlerts.Add(devalert); dbModel.SaveChanges(); } } else { if (alerts != null) { alerts.ForEach(x => { x.isfinished = (int)EYesOrNo.是; x.finishtime = DateTime.Now; alertList.Add(x); }); dbModel.SaveChanges(); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "记录输送线告警失败:{0}", ex.Message); } } Thread.Sleep(5000); } } private void SendChaiDieAlert(object obj) { var s = (ChaiDieEntity)obj; while (true) { using (var dbModel = new DbModel()) { try { var alertList = new List(); var alerts = dbModel.DevAlerts.Where(x => x.name == s.ChaiDieName && x.isfinished == (int)EYesOrNo.否).ToList(); if (s.RAlarm) { bool b1 = Enum.IsDefined(typeof(EChaiDeiAlerm), s.RAlarmCode); string alertnumber = s.RAlarmCode.ToString(); var alert = alerts.FirstOrDefault(x => x.alertcode == alertnumber); if (alert == null && b1) { var devalert = new DevAlert() { name = s.ChaiDieName, createtime = DateTime.Now, type = (int)EDevType.拆叠机, eqname = s.DeviceId.ToString(), finishtime = DateTime.Now, isfinished = (int)EYesOrNo.否, alertcode = s.RAlarmCode.ToString(), alertname = ((EChaiDeiAlerm)s.RAlarmCode).ToString() }; dbModel.DevAlerts.Add(devalert); dbModel.SaveChanges(); } } else { if (alerts != null) { alerts.ForEach(x => { x.isfinished = (int)EYesOrNo.是; x.finishtime = DateTime.Now; alertList.Add(x); }); dbModel.SaveChanges(); } } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "记录拆叠机告警失败:{0}", ex.Message); } } Thread.Sleep(5000); } } #endregion #region 发送心跳 private void SendConveyorAndChaiDeiHeart() { CpuType t = (CpuType)Enum.Parse(typeof(CpuType), "S71200"); PlcS7 plc = new PlcS7(t, "192.168.0.20", 0, 1); plc.Open(); int bl = 1; while (true) { if (bl != 0) { bl = 0; } else { bl = 1; } if (plc != null && plc.IsConnected) { plc.Write("DB601.DBX264.0", bl); } else { plc.Close(); Thread.Sleep(100); plc.Open(); continue; } Thread.Sleep(1000); } } private void SendRGVHeart(object obj) { var s = (RgvEntity)obj; s.WRGVS71200.Open(); int bl = 1; while (true) { if (bl != 0) { bl = 0; } else { bl = 1; } if (s.WRGVS71200 != null && s.WRGVS71200.IsConnected) { s.WRGVS71200.Write(s.OpcWriteItems.HandShake, bl); } else { s.WRGVS71200.Close(); Thread.Sleep(100); s.WRGVS71200.Open(); continue; } Thread.Sleep(1000); } } private void SendStackerHeart(object obj) { var s = (SrmEntity)obj; int i = 0; s.WS71500.Open(); while (true) { if (i < 2000) { i++; } else { i = 0; } if (s.WS71500 != null && s.WS71500.IsConnected) { s.WS71500.Write(s.OpcWriteItems.HandShake, i); } else { s.WS71500.Close(); Thread.Sleep(100); s.WS71500.Open(); continue; } Thread.Sleep(1000); } } #endregion #region 设备添加离线次数 private void AddConveyorOffLineTimes(object obj) { var s = (ConveyorEntity)obj; while (true) { if (s.OffLineTimes > 5) { s.IsOnline = false; } else { s.OffLineTimes += 1; } Thread.Sleep(1000); } } private void AddRgvOffLineTimes(object obj) { var s = (RgvEntity)obj; while (true) { if (s.OffLineTimes > 10) { s.IsOnline = false; } else { s.OffLineTimes += 1; } Thread.Sleep(1000); } } private void AddStackerOffLineTimes(object obj) { var s = (SrmEntity)obj; while (true) { if (s.OffLineTimes > 10) { s.IsOnline = false; } else { s.OffLineTimes += 1; } Thread.Sleep(1000); } } private void AddChaiDieOffLineTimes(object obj) { var s = (ChaiDieEntity)obj; while (true) { if (s.OffLineTimes > 5) { s.IsOnline = false; } else { s.OffLineTimes += 1; } //s.RCDS71200.Close(); //s.RCDS71200.Open(); Thread.Sleep(1000); } } #endregion #region 检测设备是否在线 private void CheckChaiDieIsOnLine(object obj) { var s = (ChaiDieEntity)obj; while (true) { s.OffLineTimes = COffLineTimes; s.IsOnline = COnline; Thread.Sleep(1000); } } private void CheckConveyorIsOnLine(object obj) { var s = (ConveyorEntity)obj; while (true) { s.OffLineTimes = COffLineTimes; s.IsOnline = COnline; Thread.Sleep(1000); } } private void ConveyorAndChaiDieIsOnLine() { CpuType t = (CpuType)Enum.Parse(typeof(CpuType), "S71200"); PlcS7 plc = new PlcS7(t, "192.168.0.20", 0, 1); plc.Open(); try { while (true) { if (plc != null && plc.IsConnected) { CHandShake = Convert.ToInt32((plc.Read("DB600.DBW0").ToString())); } else { plc.Close(); plc.Open(); continue; } if (CHandShake != CLastHandShake) { CLastHandShake = CHandShake; COffLineTimes = 0; COnline = true; } Thread.Sleep(1000); } } catch (Exception) { LogTextHelper.WriteLine(Resources.LogDir, "输送线与拆叠机心跳读取失败!"); } } private void CheckRgvIsOnLine(object obj) { var s = (RgvEntity)obj; while (true) { if (s.RHandShake != s.LastHandShake) { s.LastHandShake = s.RHandShake; s.OffLineTimes = 0; s.IsOnline = true; } Thread.Sleep(1000); } } private void CheckStackerIsOnLine(object obj) { var s = (SrmEntity)obj; while (true) { if (s.RHandShake != s.LastHandShake) { s.LastHandShake = s.RHandShake; s.OffLineTimes = 0; s.IsOnline = true; } Thread.Sleep(1000); } } #endregion #region 设备状态信息 /// /// 获取每台拆叠机的状态信息 /// /// private void GetChaiDieState(object obj) { var opcClinet = new DevInfoServiceClient(); var s = (ChaiDieEntity)obj; CpuType t = (CpuType)Enum.Parse(typeof(CpuType), "S71200"); PlcS7 plc = new PlcS7(t, "192.168.0.20", 0, 1); plc.Open(); int midvalue; int readtimes = 0; while (true) { try { if (plc == null || !plc.IsConnected) { plc.Close(); plc.Open(); Thread.Sleep(100); continue; } int RMode = Convert.ToInt32(plc.Read(s.OpcReadItems.Mode)); bool RAlarm = Convert.ToBoolean(plc.Read(s.OpcReadItems.Alarm).ToString()); int RState = Convert.ToInt32(plc.Read(s.OpcReadItems.State)); int RAlarmCode = Convert.ToInt32(plc.Read(s.OpcReadItems.AlarmCode)); int RHandShake = Convert.ToInt32(plc.Read(s.OpcReadItems.HandShake)); int PH2 = Convert.ToInt32(plc.Read(s.OpcReadItems.Ph2)); int PH1 = Convert.ToInt32(plc.Read(s.OpcReadItems.Ph1)); int EmptyStatus = Convert.ToInt32(plc.Read(s.OpcReadItems.EmptyStatus)); bool RACK = Convert.ToBoolean(plc.Read(s.OpcReadItems.ACK).ToString()); bool WSTP = false; bool NeedCon = false; if (s.ChaiDieName == "ChaiDei3" || s.ChaiDieName == "ChaiDei4") { WSTP = Convert.ToBoolean(plc.Read(s.OpcWriteItems.STP).ToString()); NeedCon = Convert.ToBoolean(plc.Read(s.OpcWriteItems.NeedCon).ToString()); } string msg = ""; var cd = opcClinet.GetChaiDieInfo(s.ChaiDieName, out msg); s.RMode = RMode; s.RAlarm = RAlarm; s.RState = RState; s.RAlarmCode = RAlarmCode; s.RHandShake = RHandShake; s.RACK = RACK; s.PH2 = PH2; s.PH1 = PH1; midvalue = cd.EmptyStatus; if (readtimes <= 3) { if (midvalue != 0) { readtimes++; } else { s.EmptyStatus = midvalue; readtimes = 0; } } else { s.EmptyStatus = midvalue; readtimes = 0; } if (s.ChaiDieName == "ChaiDei3" || s.ChaiDieName == "ChaiDei4") { s.WSTP = WSTP; s.NeedCon = NeedCon; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "拆叠机{0}读取状态失败:{1}", s.ChaiDieName, ex.Message); } Thread.Sleep(1000); } } /// /// 获取每台RGV的状态信息 /// /// private void GetRgvState(object obj) { var s = (RgvEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var rgv = opcClinet.GetRGVInfo(s.RgvName, out msg); if (rgv != null) { s.RMode = rgv.RMode; s.RAlarm = rgv.RAlarm; s.RLoaded = rgv.RLoaded; s.RRgvPosition = rgv.RRgvPosition; s.RSPos = rgv.RSPos; s.RTPos = rgv.RTPos; s.RTaskFinish = rgv.RTaskFinish; s.RTaskNo = rgv.RTaskNo; s.RState = rgv.RState; s.RAlarmCode = rgv.RAlarmCode; s.RHandShake = rgv.RHandShake; s.RAck = rgv.RAck; s.WTaskNo = rgv.RTaskNo; s.WEStop = rgv.WEStop; s.WAckTaskFinish = rgv.WAckTaskFinish; s.WReset = rgv.WReset; s.WStb = rgv.WStb; s.WPallType = rgv.WPallType; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "RGV{0}读取状态失败:{1}", s.RgvName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每条输送线的状态信息 /// /// private void GetConveyorState1(object obj) { var s = (ConveyorEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var convy = opcClinet.GetConveyorInfo(s.ConveyorName, out msg); if (convy != null) { s.RMode = convy.RMode; s.RAlarm = convy.RAlarm; s.RTaskNo = convy.RTaskNo; s.RState = convy.RState; s.RAlarmCode = convy.RAlarmCode; s.RAck = convy.RAck; s.RPh1 = convy.RPh1; s.RPh2 = convy.RPh2; s.RPh3 = convy.RPh3; s.RShape = convy.RShape; s.WTaskNo = convy.WTaskNo; s.WSTP = convy.WSTP; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}读取状态失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每条输送线的状态信息 /// /// private void GetConveyorState2(object obj) { var s = (ConveyorEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var convy = opcClinet.GetConveyorInfo(s.ConveyorName, out msg); if (convy != null) { s.RMode = convy.RMode; s.RAlarm = convy.RAlarm; s.RTaskNo = convy.RTaskNo; s.RState = convy.RState; s.RAlarmCode = convy.RAlarmCode; s.RAck = convy.RAck; s.RPh1 = convy.RPh1; s.RPh2 = convy.RPh2; s.RPh3 = convy.RPh3; s.RShape = convy.RShape; s.WTaskNo = convy.WTaskNo; s.WSTP = convy.WSTP; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}读取状态失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每条输送线的状态信息 /// /// private void GetConveyorState3(object obj) { var s = (ConveyorEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var convy = opcClinet.GetConveyorInfo(s.ConveyorName, out msg); if (convy != null) { s.RMode = convy.RMode; s.RAlarm = convy.RAlarm; s.RTaskNo = convy.RTaskNo; s.RState = convy.RState; s.RAlarmCode = convy.RAlarmCode; s.RAck = convy.RAck; s.RPh1 = convy.RPh1; s.RPh2 = convy.RPh2; s.RPh3 = convy.RPh3; s.RShape = convy.RShape; s.WTaskNo = convy.WTaskNo; s.WSTP = convy.WSTP; s.RHeight = convy.Height; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}读取状态失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每条输送线的状态信息 /// /// private void GetConveyorState4(object obj) { var s = (ConveyorEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var convy = opcClinet.GetConveyorInfo(s.ConveyorName, out msg); if (convy != null) { s.RMode = convy.RMode; s.RAlarm = convy.RAlarm; s.RTaskNo = convy.RTaskNo; s.RState = convy.RState; s.RAlarmCode = convy.RAlarmCode; s.RAck = convy.RAck; s.RPh1 = convy.RPh1; s.RPh2 = convy.RPh2; s.RPh3 = convy.RPh3; s.RShape = convy.RShape; s.WTaskNo = convy.WTaskNo; s.WSTP = convy.WSTP; s.RHeight = convy.Height; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}读取状态失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每条输送线的状态信息 /// /// private void GetConveyorState5(object obj) { var s = (ConveyorEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var convy = opcClinet.GetConveyorInfo(s.ConveyorName, out msg); if (convy != null) { s.RMode = convy.RMode; s.RAlarm = convy.RAlarm; s.RTaskNo = convy.RTaskNo; s.RState = convy.RState; s.RAlarmCode = convy.RAlarmCode; s.RAck = convy.RAck; s.RPh1 = convy.RPh1; s.RPh2 = convy.RPh2; s.RPh3 = convy.RPh3; s.RShape = convy.RShape; s.WTaskNo = convy.WTaskNo; s.WSTP = convy.WSTP; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "输送线{0}读取状态失败:{1}", s.ConveyorName, ex.Message); } Thread.Sleep(200); } } /// /// 获取每台堆垛机的状态信息 /// /// private void GetStackerState(object obj) { var s = (SrmEntity)obj; var opcClinet = new DevInfoServiceClient(); while (true) { try { string msg = ""; var srm = opcClinet.GetStackInfo(s.SrmName, out msg); if (srm != null) { s.RSrmNo = srm.RSrmNo; s.RMode = srm.RMode; s.RAlarm = srm.RAlarm; s.RLiftFull = srm.RLiftFull; s.RPosX = srm.RPosX; s.RPosY = srm.RPosY; s.RPosZ = srm.RPosZ; s.RPosXmm = srm.RPosXmm; s.RPosYmm = srm.RPosYmm; s.RPosZmm = srm.RPosZmm; s.RPickFinish = srm.RPickFinish; s.RDeliveryFinish = srm.RDeliveryFinish; s.RTaskFinish = srm.RTaskFinish; s.RTaskNo = srm.RTaskNo; s.RState = srm.RState; s.RActualLane = srm.RActualLane; s.RAlarmCode = srm.RAlarmCode; s.RHandShake = srm.RHandShake; s.RAck = srm.RAck; s.WSrmNo = srm.RSrmNo; s.WTaskNo = srm.RTaskNo; s.WSourcePosX = srm.WSourcePosX; s.WSourcePosY = srm.WSourcePosY; s.WSourcePosZ = srm.WSourcePosZ; s.WDestinationPosX = srm.WDestinationPosX; s.WDestinationPosY = srm.WDestinationPosY; s.WDestinationPosZ = srm.WDestinationPosZ; s.WCommand = srm.WCommand; s.WEmergencyStop = srm.WEmergencyStop; s.WStb = srm.WStb; s.WCancleAlarm = srm.WCancleAlarm; s.WTaskFinishConfirm = srm.WTaskFinishConfirm; s.WPalletType = srm.WPalletType; s.WHigh = srm.WHigh; } else { continue; } } catch (Exception ex) { LogTextHelper.WriteLine(Resources.LogDir, "堆垛机{0}读取状态失败:{1}", s.SrmName, ex.Message); } Thread.Sleep(500); } } #endregion #region 设备自动任务执行 /// /// 自动执行拆叠机任务 /// /// private void DoChaiDieTaskAuto(object obj) { var decompositionTaskContainer = new PartTaskContainer(); var 选择一个未执行的堆垛机的任务 = new 选择一个未执行的拆叠机的任务(decompositionTaskContainer); var 发送拆叠机任务 = new 发送拆叠机任务(decompositionTaskContainer); 选择一个未执行的堆垛机的任务.NextHandler = 发送拆叠机任务; while (true) { 选择一个未执行的堆垛机的任务.Handle(); Thread.Sleep(500); } } /// /// 自动执行输送线任务 /// /// private void DoConveyorTaskAuto(object obj) { var decompositionTaskContainer = new PartTaskContainer(); var 选择一个未执行的输送线的任务 = new 选择一个未执行的输送线的任务(decompositionTaskContainer); var 发送输送线任务 = new 发送输送线任务(decompositionTaskContainer); 选择一个未执行的输送线的任务.NextHandler = 发送输送线任务; while (true) { 选择一个未执行的输送线的任务.Handle(); Thread.Sleep(200); } } /// /// 自动执行RGV任务 /// /// private void DoRgvTaskAuto(object obj) { var decompositionTaskContainer = new PartTaskContainer(); var 选择一个未执行的Rgv的任务 = new 选择一个未执行的Rgv的任务(decompositionTaskContainer); var 发送Rgv任务 = new 发送Rgv任务(decompositionTaskContainer); 选择一个未执行的Rgv的任务.NextHandler = 发送Rgv任务; while (true) { 选择一个未执行的Rgv的任务.Handle(); Thread.Sleep(200); } } /// /// 自动执行堆垛机任务 /// /// private void DoStackerTaskAuto(object obj) { var decompositionTaskContainer = new PartTaskContainer(); var 选择一个未执行的堆垛机的任务 = new 选择一个未执行的堆垛机的任务(decompositionTaskContainer); var 发送堆垛机任务 = new 发送堆垛机任务(decompositionTaskContainer); 选择一个未执行的堆垛机的任务.NextHandler = 发送堆垛机任务; while (true) { 选择一个未执行的堆垛机的任务.Handle(); Thread.Sleep(500); } } #endregion #region 设备完成任务处理 private void FinishStackerTaskAuto(object obj) { var s = (SrmEntity)obj; var decompositionTaskContainer = new PartTaskContainer(); var 获取当前的堆垛机任务 = new 获取当前的堆垛机任务(s, decompositionTaskContainer); var 等待堆垛机完成任务 = new 等待堆垛机完成任务(s, decompositionTaskContainer); var 将完成结果更新至数据库 = new 将完成结果更新至数据库(s, decompositionTaskContainer); 获取当前的堆垛机任务.NextHandler = 等待堆垛机完成任务; 等待堆垛机完成任务.NextHandler = 将完成结果更新至数据库; while (true) { 获取当前的堆垛机任务.Handle(); Thread.Sleep(500); } } private void FinishRgvTaskAuto(object obj) { var s = (RgvEntity)obj; var decompositionTaskContainer = new PartTaskContainer(); var 获取当前的Rgv任务 = new 获取当前的Rgv任务(s, decompositionTaskContainer); var 等待Rgv完成任务 = new 等待Rgv完成任务(s, decompositionTaskContainer); var 将Rgv完成结果更新至数据库 = new 将Rgv完成结果更新至数据库(s, decompositionTaskContainer); 获取当前的Rgv任务.NextHandler = 等待Rgv完成任务; 等待Rgv完成任务.NextHandler = 将Rgv完成结果更新至数据库; while (true) { 获取当前的Rgv任务.Handle(); Thread.Sleep(300); } } private void FinishConveyorTaskAuto(object obj) { var s = (ConveyorEntity)obj; var decompositionTaskContainer = new PartTaskContainer(); var 获取当前的输送线任务 = new 获取当前的输送线任务(decompositionTaskContainer); var 等待输送线完成任务 = new 等待输送线完成任务(decompositionTaskContainer); var 将输送线完成结果更新至数据库 = new 将输送线完成结果更新至数据库(decompositionTaskContainer); 获取当前的输送线任务.NextHandler = 等待输送线完成任务; 等待输送线完成任务.NextHandler = 将输送线完成结果更新至数据库; while (true) { 获取当前的输送线任务.Handle(); Thread.Sleep(300); } } private void FinishChaiDieTaskAuto(object obj) { var s = (ChaiDieEntity)obj; var decompositionTaskContainer = new PartTaskContainer(); var 获取当前的拆叠机任务 = new 获取当前的拆叠机任务(s, decompositionTaskContainer); var 等待拆叠机完成任务 = new 等待拆叠机完成任务(s, decompositionTaskContainer); var 将拆叠机完成结果更新至数据库 = new 将拆叠机完成结果更新至数据库(s, decompositionTaskContainer); 获取当前的拆叠机任务.NextHandler = 等待拆叠机完成任务; 等待拆叠机完成任务.NextHandler = 将拆叠机完成结果更新至数据库; while (true) { 获取当前的拆叠机任务.Handle(); Thread.Sleep(500); } } #endregion #region 分解处理任务线程 /// /// 分解任务 /// private void DecomposeTask() { var mainTaskContainer = new MainTaskContainer(); var partTaskContainer = new PartTaskContainer(); var resultContainer = new ResultContainer(); var 按策略获取一个待分解任务 = new 按策略获取一个待分解任务(mainTaskContainer); var 根据任务类型生成分解任务 = new 根据任务类型生成分解任务(resultContainer, mainTaskContainer, partTaskContainer); var 保存分解任务 = new 保存分解任务(mainTaskContainer, partTaskContainer); 按策略获取一个待分解任务.NextHandler = 根据任务类型生成分解任务; 根据任务类型生成分解任务.NextHandler = 保存分解任务; while (true) { mainTaskContainer.DecompositionMainTask = null; partTaskContainer.DecompositionTask = null; resultContainer.Msg = ""; 按策略获取一个待分解任务.Handle(); Thread.Sleep(500); } } /// /// 处理任务的线程 /// private void HandleTask() { var resultContainer = new ResultContainer(); var handleTaskContainer = new PartTaskContainer(); var nextTaskContainer = new PartTaskContainer(); var 获取一个已完成但未处理的分解任务 = new 获取一个已完成但未处理的分解任务(handleTaskContainer); var 根据任务类型获取下一阶段任务 = new 根据任务类型获取下一阶段任务(handleTaskContainer, nextTaskContainer, resultContainer); var 保存处理信息 = new 保存处理信息(handleTaskContainer, nextTaskContainer); 获取一个已完成但未处理的分解任务.NextHandler = 根据任务类型获取下一阶段任务; 根据任务类型获取下一阶段任务.NextHandler = 保存处理信息; while (true) { resultContainer.Msg = ""; handleTaskContainer.DecompositionTask = null; nextTaskContainer.DecompositionTask = null; 获取一个已完成但未处理的分解任务.Handle(); Thread.Sleep(500); } } #endregion #region 开启关闭线程 /// /// 开启线程 /// private void StartThread(Thread thread) { if (thread != null) { thread.IsBackground = true; thread.Start(); } LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name); } /// /// 开启带参数的线程 /// private void StartThread(Thread thread, object obj) { if (thread != null) { thread.IsBackground = true; thread.Start(obj); } LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name); } /// ///关闭WCF /// ///需要关闭的WCF private void CloseWcf(ServiceHost host) { if (host != null) { host.Close(); } } /// /// 关闭线程 /// /// 需要关闭的线程 private void CloseThread(Thread thread) { if (thread != null) { thread.Abort(); } LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已关闭", thread.Name); } #endregion } }