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
|
{
|
/// <summary>
|
/// 过去已经生成过的任务号集合 【EditBy shaocx,2022-09-18】
|
/// </summary>
|
public static List<ExistTaskCodeListModel> existTaskCodeList = new List<ExistTaskCodeListModel>();
|
Thread AutoClearTaskOlderThey7Day;
|
private bool COnline = false;
|
private int COffLineTimes = 0;
|
private int CHandShake = 0;
|
private int CLastHandShake = 0;
|
|
#region 外形检测是否通过
|
/// <summary>
|
/// 获取外行检测线程
|
/// </summary>
|
private Thread GetCheckShapeThreads;
|
|
#endregion
|
|
#region WCF服务
|
/// <summary>
|
/// ControlCenterWcf服务
|
/// </summary>
|
private ServiceHost ControlCenterWcfHost = null;
|
#endregion
|
|
#region 发送WCS心跳
|
/// <summary>
|
/// 发送堆垛机的心跳
|
/// </summary>
|
private List<Thread> SendStackerHeartThreads = new List<Thread>();
|
/// <summary>
|
/// 发送RGV的心跳
|
/// </summary>
|
private List<Thread> SendRGVHeartThreads = new List<Thread>();
|
/// <summary>
|
/// 发送输送线与RGV的心跳
|
/// </summary>
|
private Thread SendConveyorAndChaiDeiHeartThread;
|
#endregion
|
|
#region 设备状态
|
/// <summary>
|
/// 获取每台堆垛机状态的线程
|
/// </summary>
|
private List<Thread> GetStackerStateThreads = new List<Thread>();
|
#region 获取每种类型输送线信息
|
/// <summary>
|
/// 获取每条输送线的状态线程
|
/// </summary>
|
private List<Thread> GetConveyors1StateThreads = new List<Thread>();
|
/// <summary>
|
/// 获取每条输送线的状态线程
|
/// </summary>
|
private List<Thread> GetConveyors2StateThreads = new List<Thread>();
|
/// <summary>
|
/// 获取每条输送线的状态线程
|
/// </summary>
|
private List<Thread> GetConveyors3StateThreads = new List<Thread>();
|
/// <summary>
|
/// 获取每条输送线的状态线程
|
/// </summary>
|
private List<Thread> GetConveyors4StateThreads = new List<Thread>();
|
/// <summary>
|
/// 获取每条输送线的状态线程
|
/// </summary>
|
private List<Thread> GetConveyors5StateThreads = new List<Thread>();
|
#endregion
|
/// <summary>
|
/// 获取每台Rgv的状态线程
|
/// </summary>
|
private List<Thread> GetRgvStateThreads = new List<Thread>();
|
/// <summary>
|
/// 获取每台拆叠机的状态线程
|
/// </summary>
|
private List<Thread> GetChaiDieStateThreads = new List<Thread>();
|
#endregion
|
|
#region 检查设备是否在线
|
/// <summary>
|
/// 检测拆叠机是否在线
|
/// </summary>
|
private List<Thread> CheckChaiDieIsOnLineThreads = new List<Thread>();
|
/// <summary>
|
/// 检测RGV是否在线
|
/// </summary>
|
private List<Thread> CheckRgvIsOnLineThreads = new List<Thread>();
|
/// <summary>
|
/// 检测输送线是否在线
|
/// </summary>
|
private List<Thread> CheckConveyorIsOnLineThreads = new List<Thread>();
|
/// <summary>
|
/// 检测输送线是否在线
|
/// </summary>
|
private List<Thread> CheckStackerIsOnLineThreads = new List<Thread>();
|
|
private Thread CheckConveyorAndChaiDieIsOnLineThread;
|
#endregion
|
|
#region 设备离线次数
|
/// <summary>
|
/// 添加拆叠机离线次数
|
/// </summary>
|
private List<Thread> AddChaiDieOffLineTimesThreads = new List<Thread>();
|
/// <summary>
|
/// 添加RGV离线次数
|
/// </summary>
|
private List<Thread> AddRgvOffLineTimesThreads = new List<Thread>();
|
/// <summary>
|
/// 添加输送线离线次数
|
/// </summary>
|
private List<Thread> AddConveyorOffLineTimesThreads = new List<Thread>();
|
/// <summary>
|
/// 添加堆垛机离线次数
|
/// </summary>
|
private List<Thread> AddStackerOffLineTimesThreads = new List<Thread>();
|
#endregion
|
|
#region 发送设备报警信息
|
/// <summary>
|
/// 发送拆叠机告警状态的线程
|
/// </summary>
|
private List<Thread> SendChaiDieAlertThreads = new List<Thread>();
|
/// <summary>
|
/// 发送RGV告警状态的线程
|
/// </summary>
|
private List<Thread> SendRgvAlertThreads = new List<Thread>();
|
/// <summary>
|
/// 发送输送线告警状态的线程
|
/// </summary>
|
private List<Thread> SendConveyorAlertThreads = new List<Thread>();
|
/// <summary>
|
/// 发送堆垛机告警状态的线程
|
/// </summary>
|
private List<Thread> SendStackerAlertThreads = new List<Thread>();
|
#endregion
|
|
#region 分解处理任务
|
/// <summary>
|
/// 分解任务的线程
|
/// </summary>
|
private Thread DecomposeTaskThread = null;
|
|
/// <summary>
|
/// 处理任务的线程
|
/// </summary>
|
private Thread HandleTaskThread = null;
|
#endregion
|
|
#region 给设备自动发送任务
|
/// <summary>
|
/// 自动执行堆垛机任务
|
/// </summary>
|
private Thread DoStackerTaskAutoThreads;
|
/// <summary>
|
/// 自动执行RGV任务
|
/// </summary>
|
private Thread DoRgvTaskAutoThreads;
|
/// <summary>
|
/// 自动执行输送线任务
|
/// </summary>
|
private Thread DoConveyorTaskAutoThreads;
|
/// <summary>
|
/// 自动执行拆盘机任务
|
/// </summary>
|
private Thread DoChaiDieTaskAutoThreads;
|
#endregion
|
|
#region 设备完成任务反馈
|
/// <summary>
|
/// 自动完成堆垛机任务
|
/// </summary>
|
private List<Thread> FinishStackerTaskAutoThreads = new List<Thread>();
|
/// <summary>
|
/// 自动完成RGV任务
|
/// </summary>
|
private List<Thread> FinishRgvTaskAutoThreads = new List<Thread>();
|
/// <summary>
|
/// 自动完成输送线任务
|
/// </summary>
|
private Thread FinishConveyorTaskAutoThreads;
|
/// <summary>
|
/// 自动完成拆盘机任务
|
/// </summary>
|
private List<Thread> FinishChaiDieTaskAutoThreads = new List<Thread>();
|
#endregion
|
|
#region STP置位
|
private List<Thread> RsetConveyorStpThreads = new List<Thread>();
|
private List<Thread> RsetRgvStpThreads = new List<Thread>();
|
private List<Thread> RsetChaiDieStpThreads = new List<Thread>();
|
#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<DevAlert>();
|
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<DevAlert>();
|
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<DevAlert>();
|
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<DevAlert>();
|
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 设备状态信息
|
/// <summary>
|
/// 获取每台拆叠机的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
/// <summary>
|
/// 获取每台RGV的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
/// <summary>
|
/// 获取每条输送线的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
|
/// <summary>
|
/// 获取每条输送线的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
|
/// <summary>
|
/// 获取每条输送线的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
|
/// <summary>
|
/// 获取每条输送线的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
|
/// <summary>
|
/// 获取每条输送线的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
/// <summary>
|
/// 获取每台堆垛机的状态信息
|
/// </summary>
|
/// <param name="obj"></param>
|
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 设备自动任务执行
|
/// <summary>
|
/// 自动执行拆叠机任务
|
/// </summary>
|
/// <param name="obj"></param>
|
private void DoChaiDieTaskAuto(object obj)
|
{
|
var decompositionTaskContainer = new PartTaskContainer();
|
var 选择一个未执行的堆垛机的任务 = new 选择一个未执行的拆叠机的任务(decompositionTaskContainer);
|
var 发送拆叠机任务 = new 发送拆叠机任务(decompositionTaskContainer);
|
选择一个未执行的堆垛机的任务.NextHandler = 发送拆叠机任务;
|
while (true)
|
{
|
选择一个未执行的堆垛机的任务.Handle();
|
Thread.Sleep(500);
|
}
|
}
|
/// <summary>
|
/// 自动执行输送线任务
|
/// </summary>
|
/// <param name="obj"></param>
|
private void DoConveyorTaskAuto(object obj)
|
{
|
|
var decompositionTaskContainer = new PartTaskContainer();
|
var 选择一个未执行的输送线的任务 = new 选择一个未执行的输送线的任务(decompositionTaskContainer);
|
var 发送输送线任务 = new 发送输送线任务(decompositionTaskContainer);
|
选择一个未执行的输送线的任务.NextHandler = 发送输送线任务;
|
while (true)
|
{
|
选择一个未执行的输送线的任务.Handle();
|
Thread.Sleep(200);
|
}
|
}
|
/// <summary>
|
/// 自动执行RGV任务
|
/// </summary>
|
/// <param name="obj"></param>
|
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);
|
}
|
}
|
/// <summary>
|
/// 自动执行堆垛机任务
|
/// </summary>
|
/// <param name="obj"></param>
|
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 分解处理任务线程
|
/// <summary>
|
/// 分解任务
|
/// </summary>
|
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);
|
}
|
}
|
/// <summary>
|
/// 处理任务的线程
|
/// </summary>
|
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 开启关闭线程
|
/// <summary>
|
/// 开启线程
|
/// </summary>
|
private void StartThread(Thread thread)
|
{
|
if (thread != null)
|
{
|
thread.IsBackground = true;
|
thread.Start();
|
}
|
LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name);
|
}
|
|
/// <summary>
|
/// 开启带参数的线程
|
/// </summary>
|
private void StartThread(Thread thread, object obj)
|
{
|
if (thread != null)
|
{
|
thread.IsBackground = true;
|
thread.Start(obj);
|
}
|
LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name);
|
}
|
|
///<summary>
|
///关闭WCF
|
///</summary>
|
///<param name="host">需要关闭的WCF</param>
|
private void CloseWcf(ServiceHost host)
|
{
|
if (host != null)
|
{
|
host.Close();
|
}
|
}
|
|
/// <summary>
|
/// 关闭线程
|
/// </summary>
|
/// <param name="thread">需要关闭的线程</param>
|
private void CloseThread(Thread thread)
|
{
|
if (thread != null)
|
{
|
thread.Abort();
|
}
|
LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已关闭", thread.Name);
|
}
|
#endregion
|
|
}
|
}
|
