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