using iWareCommon;
|
using iWareCommon.Utils;
|
using iWareSql;
|
using System;
|
using System.Collections.Generic;
|
using System.Threading;
|
|
using iWareCC.SrmService;
|
using System.Linq;
|
using iWareSql.Orm;
|
using System.Threading.Tasks;
|
using iWareSql.Entity.ParamModel;
|
using Newtonsoft.Json;
|
using iWareCC.BLL;
|
using iWareCC.Common;
|
|
using iWareModel;
|
using iWareCommon.Common.Globle;
|
using XiGang.Core.Model;
|
using iWareCC.Common.Helper;
|
using iWareModel.EnumType.AoSinPublicCommon;
|
using Admin.NET.Core.TaskModule.Enum;
|
using iWareSql.DbOrm;
|
using iWareSql.DataAccess;
|
using static WZ.Useful.Commons.DGVPrinter;
|
using System.Runtime.Remoting.Contexts;
|
|
namespace iWareCC
|
{
|
/// <summary>
|
/// 堆垛机任务服务线程类
|
/// </summary>
|
public class SrmTaskThreadService : DeviceThreadServiceHandle
|
{
|
private static string _namespace = "iWareCC.SrmTaskThreadService";
|
|
private SrmTaskThreadService() { }
|
public SrmTaskThreadService(iWareCommon.Utils.LogType logType)
|
{
|
base.currentLogType = logType;
|
}
|
public override void StartService()
|
{
|
Task.Run(() =>
|
{
|
try
|
{
|
//自动执行堆垛机任务线程
|
Log4NetHelper.WriteInfoLog(base.currentLogType, "自动执行堆垛机任务线程启动了");
|
//var srmList = new SrmService.SrmServiceClient().GetSrm_CacheEntity();
|
var srmList = FormCC.SrmDeviceList;
|
foreach (var x in srmList)
|
{
|
IssueTaskThread(x);
|
ConfirmFinishTaskThread(x);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(base.currentLogType, "SrmTaskThreadService线程启动出现异常", ex);
|
}
|
});
|
}
|
|
|
#region 线程处理
|
|
#region 自动执行堆垛机任务线程
|
|
/// <summary>
|
/// 自动执行堆垛机任务
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void IssueTask(object deviceId)
|
{
|
string errMsg1 = "", errMsg2 = "", errMsg3 = "", errMsg4 = "";
|
int i_deviceId = (int)deviceId;
|
while (true)
|
{
|
if ((int)deviceId == (int)EDevice.堆垛机 && SystemValue.isStartedModel)
|
{
|
IssueTaskHandle(i_deviceId, out errMsg1);
|
}
|
//else if ((int)deviceId == (int)EDevice.二号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_2 && SystemValue.isStartedModel)
|
//{
|
// IssueTaskHandle(i_deviceId, out errMsg2);
|
//}
|
|
SystemWarningMsg._lbl_Alert_Srm1Release = errMsg1;
|
SystemWarningMsg._lbl_Alert_Srm2Release = errMsg2;
|
|
Thread.Sleep(500);//2秒一次
|
}
|
}
|
|
/// <summary>
|
/// 自动执行堆垛机任务（线程）
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void IssueTaskHandle(int deviceId, out string errMsg)
|
{
|
errMsg = "";
|
try
|
{
|
int int_deviceId = (int)deviceId;
|
var vs = new SrmServiceClient();
|
//2、判断堆垛机是否可以下发新任务
|
SdaResEntity sdaResult = vs.IsAllowSendTask(int_deviceId, out errMsg);
|
if (sdaResult.result == false)
|
{
|
errMsg = $"非自动、有任务未确认或有报警，{errMsg}";
|
return;
|
}
|
//bool isOk = ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg);
|
//if (!isOk)
|
//{
|
// errMsg = "不允许下发新任务," + errMsg;
|
// return;
|
//}
|
|
using (DbOrm dbOrm = new DbOrm())
|
{
|
var srmTaskList = ValidateIsExistTaskToDisposeForIssued(dbOrm, int_deviceId, out errMsg);
|
if (srmTaskList == null || srmTaskList.Count == 0)
|
{
|
//表示DB中没有任务要发送给堆垛机
|
errMsg = $"没有要执行的堆垛机任务";
|
return;
|
}
|
foreach (var item in srmTaskList)
|
{
|
SingleIssueTaskHandle(item, dbOrm, int_deviceId, vs, out errMsg);
|
if (!string.IsNullOrEmpty(errMsg))
|
{//说明报错了,继续走下一个循环
|
continue;
|
}
|
else
|
{//说明执行成功了，跳出循环
|
//修改下发的堆垛机任务状态，0->1
|
item.TaskState = (int)SubTaskStateEnum.已下发;
|
dbOrm.SaveChanges();
|
break;
|
}
|
}
|
}
|
vs.Close();
|
}
|
catch (Exception ex)
|
{
|
errMsg = "异常,请联系管理员:" + ex.Message;
|
//SysExceptionInfoHandler.GetExceptionInfoForError("自动执行堆垛机任务（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
//SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
}
|
}
|
|
private string GetRealLocatiomCodeOut(string sourcePlace)
|
{
|
switch (sourcePlace)
|
{
|
case "102":
|
return "1-00-901-00";
|
//case "202":
|
// return "1-00-902-00";
|
//case "203":
|
// return "2-00-901-00";
|
//case "204":
|
// return "2-00-902-00";
|
default:
|
return "ERROR";
|
}
|
}
|
|
private string GetRealLocatiomCodeIn(string sourcePlace)
|
{
|
switch (sourcePlace)
|
{
|
case "102":
|
return "1-00-801-00";
|
//case "202":
|
// return "1-00-802-00";
|
//case "203":
|
// return "2-00-801-00";
|
//case "204":
|
// return "2-00-802-00";
|
default:
|
return "ERROR";
|
}
|
}
|
|
/// <summary>
|
/// 单个堆垛机任务下发处理
|
/// </summary>
|
/// <param name="srmTask"></param>
|
/// <param name="exception"></param>
|
/// <param name="dbOrm"></param>
|
/// <param name="int_deviceId"></param>
|
/// <param name="errMsg"></param>
|
private void SingleIssueTaskHandle(ware_task_sub srmTask, DbOrm dbOrm, int int_deviceId, SrmServiceClient vs, out string errMsg)
|
{
|
#region //3、判断数据库中是否有可要下发的任务，如果有就下发
|
|
DeviceTaskTypeEnum _DeviceTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), srmTask.TaskType.ToString());
|
EDevice device = (EDevice)Enum.Parse(typeof(EDevice), int_deviceId.ToString());
|
string realSourcePlace = "";
|
string realToPlace = "";
|
bool isOk;
|
if (srmTask.TaskType == (int)TaskCategoryEnum.InStock)
|
{
|
realSourcePlace = GetRealLocatiomCodeIn(srmTask.SourcePlace);
|
realToPlace = srmTask.ToPlace;
|
|
if (realToPlace.Substring(2).StartsWith("02"))
|
{
|
//查看该1排是否有货
|
var arr = realToPlace.Split('-');
|
string newstr = arr[0] + "-" + "01" + "-" + arr[2] + "-" + arr[3];
|
//看1排是否有货，无货放1排
|
var lvc = dbOrm.ware_location_vs_container.AsNoTracking().Any(u => u.WareLocationCode == newstr);
|
if (!lvc)
|
{
|
var container1 = dbOrm.wms_container.Where(u => u.RealLocationCode == newstr).FirstOrDefault();
|
if (container1 != null)
|
{
|
container1.RealLocationCode = realToPlace;
|
}
|
//查看是否有指向1排原绑定库位的任务
|
var newtask = dbOrm.ware_task.Where(u => u.ToLocationCode == newstr).FirstOrDefault();
|
if (newtask != null)
|
{
|
newtask.ToLocationCode = realToPlace;
|
var newtasksub = dbOrm.ware_task_sub.Where(u => u.TaskId == newtask.Id && u.DeviceId == int_deviceId && u.ToPlace == newstr).FirstOrDefault();
|
if (newtasksub != null)
|
{
|
newtasksub.ToPlace = realToPlace;
|
}
|
}
|
|
//目标库位修改为1排
|
realToPlace = newstr;
|
|
var container = dbOrm.wms_container.Where(u => u.ContainerCode == srmTask.ContainerCode).FirstOrDefault();
|
container.RealLocationCode = newstr;
|
|
srmTask.ToPlace = realToPlace;
|
|
//主任务也修改
|
var maintask = dbOrm.ware_task.Where(u => u.Id == srmTask.TaskId).FirstOrDefault();
|
maintask.ToLocationCode = realToPlace;
|
}
|
}
|
//else if (realToPlace.Substring(2).StartsWith("01"))
|
//{
|
// //查看该1排是否有货
|
// var arr = realToPlace.Split('-');
|
// string newstr = arr[0] + "-" + "02" + "-" + arr[2] + "-" + arr[3];
|
// var lvc = dbOrm.ware_location_vs_container.AsNoTracking().Any(u => u.WareLocationCode == realToPlace);
|
// if (lvc)//有货就换到2排
|
// {
|
// //目标库位修改为1排
|
// realToPlace = newstr;
|
|
// var container = dbOrm.wms_container.Where(u => u.ContainerCode == srmTask.ContainerCode).FirstOrDefault();
|
// container.RealLocationCode = realToPlace;
|
|
// srmTask.ToPlace = realToPlace;
|
|
// //主任务也修改
|
// var maintask = dbOrm.ware_task.Where(u => u.Id == srmTask.TaskId).FirstOrDefault();
|
// maintask.ToLocationCode = realToPlace;
|
// }
|
//}
|
isOk = dbOrm.ware_location_vs_container.Any(x => x.WareLocationCode == realToPlace && x.WareContainerCode != srmTask.ContainerCode && x.IsDeleted == false);
|
if (isOk)
|
{
|
errMsg = device.ToString() + "不允许下发新任务,目标库位" + realToPlace + "系统显示有库存";
|
return;
|
}
|
}
|
else if (srmTask.TaskType == (int)TaskCategoryEnum.OutStock)
|
{
|
realSourcePlace = srmTask.SourcePlace;
|
realToPlace = GetRealLocatiomCodeOut(srmTask.ToPlace);
|
|
//判断是否存在指向放货站台的执行中的任务
|
isOk = dbOrm.ware_task_sub.Any(x => x.ToPlace == srmTask.ToPlace && x.TaskState == (int)SubTaskStateEnum.已下发);
|
if (isOk)
|
{
|
errMsg = "存在指向目标点" + srmTask.ToPlace + "的任务，不能下发同一目标点的任务";
|
return;
|
}
|
}
|
else
|
{
|
realSourcePlace = srmTask.SourcePlace;
|
realToPlace = srmTask.ToPlace;
|
|
if (realToPlace.Substring(2).StartsWith("02") && realToPlace != "1-02-06-04")
|
{
|
//查看该1排是否有货
|
var arr = realToPlace.Split('-');
|
string newstr = arr[0] + "-" + "01" + "-" + arr[2] + "-" + arr[3];
|
//看1排是否有货，无货放1排
|
var lvc = dbOrm.ware_location_vs_container.AsNoTracking().Any(u => u.WareLocationCode == newstr);
|
if (!lvc)
|
{
|
var container1 = dbOrm.wms_container.Where(u => u.RealLocationCode == newstr).FirstOrDefault();
|
if (container1 != null)
|
{
|
container1.RealLocationCode = realToPlace;
|
}
|
//查看是否有指向1排原绑定库位的任务
|
var newtask = dbOrm.ware_task.Where(u => u.ToLocationCode == newstr).FirstOrDefault();
|
if (newtask != null)
|
{
|
newtask.ToLocationCode = realToPlace;
|
var newtasksub = dbOrm.ware_task_sub.Where(u => u.TaskId == newtask.Id && u.DeviceId == int_deviceId && u.ToPlace == newstr).FirstOrDefault();
|
if (newtasksub != null)
|
{
|
newtasksub.ToPlace = realToPlace;
|
}
|
}
|
|
//目标库位修改为1排
|
realToPlace = newstr;
|
|
var container = dbOrm.wms_container.Where(u => u.ContainerCode == srmTask.ContainerCode).FirstOrDefault();
|
container.RealLocationCode = newstr;
|
|
srmTask.ToPlace = realToPlace;
|
|
//主任务也修改
|
var maintask = dbOrm.ware_task.Where(u => u.Id == srmTask.TaskId).FirstOrDefault();
|
maintask.ToLocationCode = realToPlace;
|
}
|
}
|
|
//判断是否存在指向放货站台的执行中的任务
|
isOk = dbOrm.ware_task_sub.Any(x => x.ToPlace == srmTask.ToPlace && x.TaskState == (int)SubTaskStateEnum.已下发);
|
if (isOk)
|
{
|
errMsg = "存在指向目标点" + srmTask.SourcePlace + "的任务，不能下发同一目标点的任务";
|
return;
|
}
|
}
|
|
//判断堆垛机是否有执行中的任务任务 【EditBy kejj,2022-09-22】
|
isOk = dbOrm.ware_task_sub.Any(u => u.DeviceId == int_deviceId && u.TaskState == (int)SubTaskStateEnum.执行中);
|
if (isOk)
|
{
|
errMsg = "不允许下发新任务,当前堆垛机存在执行中的任务";
|
return;
|
}
|
|
//同一个关联任务的其他设备任务
|
var relevanceTask = dbOrm.ware_task_sub.Where(x => x.TaskId == srmTask.TaskId && x.TaskSequence < srmTask.TaskSequence && x.TaskState == (int)SubTaskStateEnum.未开始).FirstOrDefault();
|
if (relevanceTask != null)
|
{
|
errMsg = string.Format("关联{0}任务未开始，所以堆垛机任务不允许下发！关联任务号:{1}", Enum.Parse(typeof(EDevice), relevanceTask.DeviceId.ToString()).ToString(), relevanceTask.TaskNo);
|
return;
|
}
|
|
ESrmCmd eSrmCmd;
|
if (srmTask.TaskType == (int)TaskCategoryEnum.InStock)
|
{
|
eSrmCmd = ESrmCmd.入库;
|
}
|
else if (srmTask.TaskType == (int)TaskCategoryEnum.OutStock)
|
{
|
eSrmCmd = ESrmCmd.出库;
|
}
|
else
|
{
|
eSrmCmd = ESrmCmd.库内搬运;
|
}
|
SdaResEntity sdaResult = new SdaResEntity();
|
try
|
{
|
if (WCSConfigHelper.GetConfig_IsSimulationPLC())
|
{
|
sdaResult.result = true;
|
}
|
else
|
{
|
if (Convert.ToInt32(srmTask.TaskNo) <= 0)
|
{
|
throw new Exception("任务号不能小于等于0，PlcTaskId：" + srmTask.TaskNo);
|
}
|
//short pallettype = GetSrmContainerType(srmTask.ContainerType);
|
short pallettype = Convert.ToInt16(srmTask.ContainerType);
|
if (pallettype == 0)
|
{
|
throw new Exception("托盘类型不能等于0，PlcTaskId：" + srmTask.TaskNo);
|
}
|
|
sdaResult = vs.SendSrmTask(int_deviceId, Convert.ToInt32(srmTask.TaskNo), realSourcePlace, realToPlace, (short)eSrmCmd, /*GetSrmContainerType(*/Convert.ToInt16(srmTask.ContainerType)/*)*/);
|
}
|
if (sdaResult.result == false)
|
{//给堆垛机下发指令失败
|
//exception.exceptionMsg = string.Format("发送指令给堆垛机失败,设备号{0},任务ID{1},起始位{2}，目标位{3},ContainerId{4}", int_deviceId,
|
// Convert.ToInt32(srmTask.TaskNo), realSourcePlace, realToPlace, srmTask.ContainerCode);
|
//SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
errMsg = string.Format("发送指令给堆垛机失败,设备号{0},任务ID{1},起始位{2}，目标位{3},ContainerId{4}", int_deviceId,
|
Convert.ToInt32(srmTask.TaskNo), realSourcePlace, realToPlace, srmTask.ContainerCode);
|
return;
|
}
|
else
|
{
|
//SystemValueUtil.DelayExcuteForSrmTaskThreadService(int_deviceId, ThreadDirectionEnum.任务开始下发线程);
|
errMsg = "";
|
}
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
#endregion
|
}
|
|
public short GetSrmContainerType(int? conveyorContainerType)
|
{
|
if (conveyorContainerType == 1)
|
{
|
return 2;
|
}
|
else if (conveyorContainerType == 3)
|
{
|
return 1;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
#endregion
|
|
#region 自动结束堆垛机任务线程
|
|
/// <summary>
|
/// 自动结束堆垛机任务线程
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void ConfirmFinishTask(object deviceId)
|
{
|
string errMsg1 = "", errMsg2 = "", errMsg3 = "", errMsg4 = "";
|
int i_deviceId = (int)deviceId;
|
while (true)
|
{
|
if ((int)deviceId == (int)EDevice.堆垛机 && SystemValue.isStartedModel)
|
{
|
ConfirmFinishTaskHandle(i_deviceId, out errMsg1);
|
}
|
//else if ((int)deviceId == (int)EDevice.二号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_2_Finish && SystemValue.isStartedModel)
|
//{
|
// ConfirmFinishTaskHandle(i_deviceId, out errMsg2);
|
//}
|
|
SystemWarningMsg._lbl_Alert_Srm1ReleaseFinish = errMsg1;
|
SystemWarningMsg._lbl_Alert_Srm2ReleaseFinish = errMsg2;
|
|
Thread.Sleep(500);//设置2秒一次
|
}
|
}
|
|
/// <summary>
|
/// 自动结束堆垛机任务线程（线程）
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void ConfirmFinishTaskHandle(int deviceId, out string errMsg)
|
{
|
errMsg = "";
|
try
|
{
|
/*
|
* 执行发送给堆垛机的指令任务
|
* 1、验证根据设备号是否找到堆垛机
|
* 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
|
* 3、判断数据库中是否有可要完成的任务，如果有判断是否跟堆垛机中的完成任务相符，如果相符就处理
|
* 4、更新任务状态
|
*/
|
int int_deviceId = (int)deviceId;
|
var vs = new SrmService.SrmServiceClient();
|
using (DbOrm dbOrm = new DbOrm())
|
{
|
#region //3、判断数据库中是否有可要完成的任务，如果有判断是否跟堆垛机中的完成任务相符，如果相符就处理
|
var currentTask = ValidateIsExistTaskToDispose(dbOrm, int_deviceId, out errMsg, SubTaskStateEnum.已完成);
|
if (currentTask == null)
|
{//表示DB中没有任务要发送给堆垛机
|
errMsg = "没有堆垛机任务数据要处理";
|
return;
|
}
|
|
#endregion
|
|
//2、判断设备是否任务完成
|
//var isFinished = ValidateDeviceTaskIsFinsished(int_deviceId, currentTask, Convert.ToInt32(currentTask.TaskNo), (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), currentTask.TaskType.ToString()), true, out errMsg);
|
//if (!isFinished) return;
|
|
SdaResEntity sdaResult = vs.IsTaskFinish(int_deviceId, Convert.ToInt32(currentTask.TaskNo));
|
if (sdaResult.result != true)
|
{
|
errMsg = $"验证堆垛机是否任务完成 失败:{sdaResult.resMsg}";
|
return;
|
}
|
|
//同一个关联任务的其他设备任务
|
var relevanceTask = dbOrm.ware_task_sub.Where(x => x.TaskId == currentTask.TaskId && x.TaskSequence < currentTask.TaskSequence
|
&& (x.TaskState != (int)SubTaskStateEnum.已完成)).FirstOrDefault();
|
if (relevanceTask != null)
|
{
|
errMsg = string.Format("关联{0}任务未完成，所以堆垛机任务不允许完成！关联任务号:{1}", Enum.Parse(typeof(EDevice), relevanceTask.DeviceId.ToString()).ToString(), relevanceTask.TaskNo);
|
return;
|
}
|
|
//4、处理任务完成状态
|
//var isOk = ConfirmTaskFinishToSrm(currentTask, "堆垛机任务完成");
|
|
sdaResult = vs.ConfirmTaskFinish((int)currentTask.DeviceId, Convert.ToInt32(currentTask.TaskNo));
|
if (sdaResult.result)
|
{
|
//using (var tran = dbOrm.Database.BeginTransaction())
|
//{
|
//try
|
//{
|
//堆垛机完成了当前任务后进行任务状态的修改
|
//ChangeTaskStateWhenTaskFinish(currentTask);
|
currentTask.FinishedTime = DateTime.Now;//完成时间
|
currentTask.TaskState = (int)SubTaskStateEnum.已完成;
|
var isExist = dbOrm.ware_task_sub.Any(u => u.TaskId == currentTask.TaskId && u.TaskState != (int)SubTaskStateEnum.已完成 && u.Id != currentTask.Id);
|
if (!isExist)
|
{
|
var maintask = dbOrm.ware_task.Where(u => u.Id == currentTask.TaskId).FirstOrDefault();
|
if (maintask != null)
|
{
|
maintask.TaskState = (int)TaskStateEnum.已完成;
|
}
|
}
|
dbOrm.SaveChanges();
|
|
//tran.Commit();
|
//}
|
//catch (Exception)
|
//{
|
//tran.Rollback();
|
// throw;
|
//}
|
//}
|
}
|
|
}
|
vs.Close();
|
}
|
catch (Exception ex)
|
{
|
errMsg = $"堆垛机任务完成异常:{ex.Message}";
|
//SysExceptionInfoHandler.GetExceptionInfoForError("自动结束堆垛机任务线程（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
//SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
}
|
}
|
|
|
|
/// <summary>
|
/// 判断是人工发送给任务，单独给堆垛机发送任务完成信号
|
/// </summary>
|
/// <param name="deviceId"></param>
|
/// <param name="taskId"></param>
|
/// <returns></returns>
|
private bool ConfirmTaskFinishToSda(int deviceId, int taskId)
|
{
|
//任务完成处理成功，需要再给堆垛机发送任务完成确认信号
|
SdaResEntity sdaResult = new SdaResEntity();
|
try
|
{
|
sdaResult = new SrmService.SrmServiceClient().ConfirmTaskFinish(deviceId, taskId);
|
|
if (!sdaResult.result)
|
{
|
Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.SrmTheadService, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【失败】，设备号:" + deviceId + ",任务号:" + taskId);
|
return false;
|
}
|
else
|
{
|
Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.SrmTheadService, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【成功】，设备号:" + deviceId + ",任务号:" + taskId);
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.SrmTheadService, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【异常】，设备号:" + deviceId + ",任务号:" + taskId + ",ex:" + ex.Message, ex);
|
throw ex;
|
}
|
}
|
|
#region 向堆垛机发送任务完成确认信号
|
|
|
/// <summary>
|
/// 向堆垛机发送任务完成确认信号
|
/// </summary>
|
/// <param name="currentTask"></param>
|
/// <param name="business"></param>
|
/// <param name="exception"></param>
|
/// <returns></returns>
|
private bool ConfirmTaskFinishToSrm(ware_task_sub currentTask, string business)
|
{
|
//任务完成处理成功，需要再给堆垛机发送任务完成确认信号
|
SdaResEntity sdaResult = new SdaResEntity();
|
string realSourcePlace = "";
|
string realToPlace = "";
|
if (currentTask.TaskType == (int)TaskCategoryEnum.InStock)
|
{
|
realSourcePlace = GetRealLocatiomCodeIn(currentTask.SourcePlace);
|
realToPlace = currentTask.ToPlace;
|
}
|
else if (currentTask.TaskType == (int)TaskCategoryEnum.OutStock)
|
{
|
realSourcePlace = currentTask.SourcePlace;
|
realToPlace = GetRealLocatiomCodeOut(currentTask.ToPlace);
|
}
|
try
|
{
|
if (WCSConfigHelper.GetConfig_IsSimulationPLC())
|
{
|
sdaResult.result = true;
|
}
|
else
|
{
|
sdaResult = new SrmService.SrmServiceClient().ConfirmTaskFinish((int)currentTask.DeviceId, Convert.ToInt32(currentTask.TaskNo));
|
}
|
if (!sdaResult.result)
|
{
|
//exception.exceptionMsg = string.Format(business + "，需要再给堆垛机发送任务完成确认信号失败，设备号{0} 任务号{1}", (int)currentTask.DeviceId, currentTask.TaskNo);
|
//SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
return false;
|
}
|
else
|
{
|
Log4NetHelper.WriteInfoLog(base.currentLogType, string.Format(business + "，再给堆垛机发送任务完成确认信号成功，设备号{0} 任务号{1}", (int)currentTask.DeviceId, currentTask.TaskNo));
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region 公共处理
|
|
|
///// <summary>
|
///// 验证RGV站点上是否允许下发堆垛机新任务
|
///// </summary>
|
///// <param name="model"></param>
|
///// <param name="_DeviceTaskTypeEnum"></param>
|
///// <param name="realToPlace"></param>
|
///// <param name="errMsg"></param>
|
///// <returns>true:允许，false：不允许</returns>
|
//private bool ValidateIsAllowNewTaskForRgvStattion(DbModel model, DeviceTaskTypeEnum _DeviceTaskTypeEnum, string realToPlace, ref string errMsg)
|
//{
|
// MainInOutFlagEnum _MainInOutFlagEnum = GetMainInOutFlagForSrm(_DeviceTaskTypeEnum);
|
// if (_MainInOutFlagEnum == MainInOutFlagEnum.出库)
|
// {
|
// //判断目标点是否有光电占用
|
// var rgv_stationCode = model.Base_Station.Where(x => x.SrmStationCode == realToPlace).First();
|
// var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(rgv_stationCode.RgvStationCode);
|
// if (isGD_HasCatogryForRgvStattion)
|
// {
|
// errMsg = "RGV出库口站点" + rgv_stationCode.RgvStationCode + "上面光电显示有货，不允许下发堆垛机的出库任务";
|
// return false;
|
// }
|
// }
|
// return true;
|
//}
|
|
/// <summary>
|
/// 根据堆垛机任务类型判断出是出库还是入库
|
/// </summary>
|
/// <param name="_DeviceTaskTypeEnum"></param>
|
/// <returns></returns>
|
private MainInOutFlagEnum GetMainInOutFlagForSrm(DeviceTaskTypeEnum _DeviceTaskTypeEnum)
|
{
|
switch (_DeviceTaskTypeEnum)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
case DeviceTaskTypeEnum.空托转运到立体库:
|
return MainInOutFlagEnum.入库;
|
case DeviceTaskTypeEnum.立库空托到拆盘机入口:
|
case DeviceTaskTypeEnum.出库:
|
return MainInOutFlagEnum.出库;
|
}
|
throw new Exception("堆垛机不支持的任务类型" + _DeviceTaskTypeEnum.ToString());
|
}
|
|
/// <summary>
|
/// 堆垛机任务完成后修改任务状态
|
/// </summary>
|
/// <param name="currentTask"></param>
|
private void ChangeTaskStateWhenTaskFinish(ware_task_sub currentTask)
|
{
|
//堆垛机完成了当前任务后进行任务状态的修改
|
currentTask.FinishedTime = DateTime.Now;//完成时间
|
//currentTask.IsFinished = true;
|
currentTask.TaskState = (int)SubTaskStateEnum.已完成;
|
//currentTask.TaskStateName = DeviceTaskStatusEnum.已完成.ToString();
|
//currentTask.OperationRemark = "已完成";
|
//currentTask.ModifyTime = DateTime.Now;
|
//currentTask.ModifyBy = SysGloble.WCSSystem;
|
//currentTask.IsLastTask = (int)EYesOrNo.否;//设置不是最新的任务
|
}
|
|
/// <summary>
|
/// 堆垛机任务完成后，根据堆垛机的任务类型去判断Base_Salver_V_Station 的State
|
/// </summary>
|
/// <param name="_DeviceTaskTypeEnum">堆垛机任务类型</param>
|
/// <param name="old_int_C_V_P_StateEnum">原先的Base_Salver_V_Station 的State</param>
|
/// <returns></returns>
|
private Salver_V_Station_StateEnum DeviceTaskTypeEnumToC_V_P_StateEnumWhenTaskFinish(DeviceTaskTypeEnum _DeviceTaskTypeEnum, int old_int_C_V_P_StateEnum)
|
{
|
Salver_V_Station_StateEnum old_C_V_P_StateEnum = (Salver_V_Station_StateEnum)Enum.Parse(typeof(Salver_V_Station_StateEnum), old_int_C_V_P_StateEnum.ToString());
|
Salver_V_Station_StateEnum _C_V_P_StateEnum = old_C_V_P_StateEnum;
|
switch (_DeviceTaskTypeEnum)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
_C_V_P_StateEnum = Salver_V_Station_StateEnum.在库物料;
|
break;
|
//case DeviceTaskTypeEnum22.线下其他垛入库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库其他料;
|
// break;
|
//case DeviceTaskTypeEnum22.线下垫板垛入库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库垫板;
|
// break;
|
//case DeviceTaskTypeEnum22.成品料配板完成回库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库成品料;
|
// break;
|
//case DeviceTaskTypeEnum22.待拆垛回库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库待拆垛;
|
// break;
|
//case DeviceTaskTypeEnum22.桁架垫板垛入立库垫板库位:
|
//case DeviceTaskTypeEnum22.锯切垫板垛入立体库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库垫板;
|
// break;
|
//case DeviceTaskTypeEnum22.移库://移库，状态不变
|
//case DeviceTaskTypeEnum22.成品料上锯切线出库://成品料出库，状态不变
|
//case DeviceTaskTypeEnum22.垫板上料出库://垫板出库，状态不变
|
// _C_V_P_StateEnum = old_C_V_P_StateEnum;
|
// break;
|
//case DeviceTaskTypeEnum22.配板原料出库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.原料配板中;
|
// break;
|
//case DeviceTaskTypeEnum22.人工出库://出库后会将表Base_Salver_V_Station 清掉
|
// break;
|
}
|
return _C_V_P_StateEnum;
|
}
|
|
public override bool ValidateDeviceIsAllowSendTask(int int_deviceId, out string errMsg)
|
{
|
if (FormCC.IsSimulationPLC)
|
{
|
errMsg = "模拟PLC";
|
return true;
|
}
|
//errMsg = "";
|
if (!base.ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg))
|
{
|
return false;
|
}
|
using (var srmService = new SrmService.SrmServiceClient())
|
{
|
SdaResEntity sdaResult = srmService.IsAllowSendTask(int_deviceId, out errMsg);
|
if (sdaResult.result == false)
|
{
|
errMsg = "非自动、有任务未确认或有报警，" + sdaResult.resMsg;
|
Log4NetHelper.WriteErrorLog(currentLogType, "验证堆垛机不可以下发新任务,int_deviceId:" + int_deviceId + ",sdaResultStr:" + JsonConvert.SerializeObject(sdaResult));
|
}
|
return sdaResult.result;
|
}
|
}
|
|
/// <summary>
|
/// 验证堆垛机是否任务完成
|
/// </summary>
|
/// <param name="int_deviceId"></param>
|
/// <returns></returns>
|
private bool ValidateDeviceTaskIsFinsished(int int_deviceId, ware_task_sub _task, int taskId, DeviceTaskTypeEnum _DeviceTaskTypeEnum, bool? isAllowSimulateExecute, out string errMsg)
|
{
|
errMsg = "";
|
if (WCSConfigHelper.GetConfig_IsSimulationPLC())
|
{
|
errMsg = "模拟PLC完成或任务要求强制模拟完成";
|
return true;
|
}
|
|
SdaResEntity sdaResult = new SrmService.SrmServiceClient().IsTaskFinish(int_deviceId, taskId);
|
if (sdaResult.result == false)
|
{
|
errMsg = "验证堆垛机是否任务完成 失败:" + JsonConvert.SerializeObject(sdaResult);
|
//Log4NetHelper.WriteErrorLog(currentLogType, "验证堆垛机是否任务完成 失败:" + JsonConvert.SerializeObject(sdaResult));
|
}
|
//switch (_DeviceTaskTypeEnum)
|
//{
|
// //涉及到最后到输送线的任务，都要再加上输送线的任务是否完成
|
// case DeviceTaskTypeEnum.组盘入库:
|
// //using (var srmConveyorService = new SrmConveyorService.SrmConveyorServiceClient())
|
// //{
|
// // sdaResultStr = srmConveyorService.IsTaskFinish(taskId);
|
// // sdaResult = JsonConvert.DeserializeObject<SdaResEntity>(sdaResultStr);
|
// // if (sdaResult.result == false)
|
// // {
|
// // errMsg = "验证输送线是否任务完成 失败:" + sdaResultStr;
|
// // Log4NetHelper.WriteErrorLog(currentLogType, "验证输送线是否任务完成 失败:" + sdaResultStr);
|
// // }
|
// //}
|
// break;
|
//}
|
|
return sdaResult.result;
|
}
|
|
#endregion
|
|
#region 私有方法
|
|
/// <summary>
|
/// 验证数据库中是否有任务要处理
|
/// </summary>
|
/// <typeparam name="Task_Part"></typeparam>
|
/// <param name="dbModel"></param>
|
/// <param name="int_deviceId">Rgv设备号</param>
|
/// <param name="errMsg"></param>
|
/// <param name="_TaskExcuteTypeEnum"></param>
|
/// <returns></returns>
|
private List<ware_task_sub> ValidateIsExistTaskToDisposeForIssued(DbOrm dbOrm, int int_deviceId, out string errMsg)
|
{
|
errMsg = "";
|
List<ware_task_sub> partList = new List<ware_task_sub>();
|
//看同一个设备，是否还有其他正在执行的任务
|
var partTask = dbOrm.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.已下发).
|
OrderBy(x => x.CreatedTime).FirstOrDefault();//按照主任务的顺序升序
|
if (partTask != null)
|
{
|
errMsg = string.Format("deviceId={0}的正在执行任务,任务ID:" + partTask.Id + ",主任务:" + partTask.TaskId + ",PLC任务号:" + partTask.TaskNo, int_deviceId);
|
return null;
|
}
|
|
//1、查询
|
var currTaskList = dbOrm.ware_task_sub.Where(x => x.DeviceId == int_deviceId && (x.TaskState == (int)SubTaskStateEnum.未开始 || x.TaskState == (int)SubTaskStateEnum.等待下发)).ToList().OrderBy(x => x.CreatedTime).ToList();//按照主任务优先级的升序排序
|
if (currTaskList == null || currTaskList.Count == 0)
|
{
|
errMsg = "没有需要处理的任务";
|
return null;
|
}
|
|
//查找所有AGV任务
|
var agvTaskList = dbOrm.ware_task_sub.AsNoTracking().Where(u => u.DeviceId == 1099).ToList();
|
var currentAgvTask = agvTaskList.Find(u => u.TaskState == (int)SubTaskStateEnum.已完成);
|
if (currentAgvTask == null)
|
{
|
//查找AGV执行步骤最高的
|
currentAgvTask = agvTaskList.OrderByDescending(u => u.TaskState).FirstOrDefault();
|
}
|
|
if (currentAgvTask != null)
|
{
|
//currentAgvTask是执行步骤最高的agv，优先下这个的关联任务
|
var vs = currTaskList.FindAll(u => u.TaskId == currentAgvTask.TaskId).OrderBy(u => u.TaskSequence).FirstOrDefault();
|
if (vs != null)
|
{
|
if (vs.TaskState == (int)SubTaskStateEnum.等待下发)
|
{
|
errMsg = $"目标点{vs.ToPlace}的堆垛机任务等待下发";
|
return null;
|
}
|
else
|
{
|
partList.Add(vs);
|
return partList;
|
}
|
}
|
else
|
{
|
//执行步骤最高的agv没有待处理的堆垛机任务
|
//查找另一个agv任务
|
var anotherAgvTask = agvTaskList.Find(u => u.TaskId != currentAgvTask.TaskId);
|
if (anotherAgvTask == null)
|
{
|
var temp = currTaskList.Find(u => u.TaskType == (int)TaskCategoryEnum.MoveStock && u.TaskSequence == 1);
|
if (temp != null)
|
{
|
partList.Add(temp);
|
return partList;
|
}
|
errMsg = "没有任务要执行";
|
return null;
|
}
|
else
|
{
|
var anthorSrmTask = currTaskList.FindAll(u => u.TaskId == anotherAgvTask.TaskId).OrderBy(u => u.TaskSequence).FirstOrDefault(); ;
|
if (anthorSrmTask != null)
|
{
|
if (anthorSrmTask.TaskState == (int)SubTaskStateEnum.等待下发)
|
{
|
errMsg = $"目标点{anthorSrmTask.ToPlace}的堆垛机任务等待下发";
|
return null;
|
}
|
else
|
{
|
partList.Add(vs);
|
return partList;
|
}
|
}
|
else
|
{
|
errMsg = "没有任务要执行";
|
return null;
|
}
|
}
|
}
|
}
|
else
|
{
|
var temp = currTaskList.Find(u => u.TaskType == (int)TaskCategoryEnum.MoveStock && u.TaskSequence == 1);
|
if (temp != null)
|
{
|
partList.Add(temp);
|
return partList;
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
|
|
//查找AGV执行步骤最高的
|
//var agvTask = dbOrm.ware_task_sub.AsNoTracking().Where(u => u.TaskState > 0 && u.DeviceId == 1099).OrderByDescending(u => u.TaskState).FirstOrDefault();
|
//ware_task_sub temp = null;
|
//if (agvTask == null)
|
//{
|
// temp = currTaskList.Find(u => u.TaskType == (int)TaskCategoryEnum.MoveStock);
|
// if (temp == null)
|
// {
|
// errMsg = "agv没有到达，等待下发";
|
// return null;
|
// }
|
// else
|
// {
|
// partList.Add(temp);
|
// return partList;
|
// }
|
//}
|
|
|
//var firstTask = currTaskList.First();//第一个待执行的任务
|
//var firstTask = currTaskList.Find(u => u.TaskId == agvTask.TaskId);
|
//partList.Add(firstTask);
|
/*
|
//判断如果这个任务是出库任务的话，就再查询第一个待执行的入库任务
|
DeviceTaskTypeEnum _DeviceTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), firstTask.TaskType.ToString());
|
//查询 出库和入库的两个任务，优先执行出库任务 【EditBy shaocx,2022-05-09】
|
MainInOutFlagEnum _MainInOutFlagEnum = GetMainInOutFlagForSrm(_DeviceTaskTypeEnum);
|
if (_MainInOutFlagEnum == MainInOutFlagEnum.出库)
|
{
|
//查询第一个待执行的入库任务
|
var queryInOutFlag = (int)MainInOutFlagEnum.入库;
|
var fisrtTaskForIn = currTaskList.Where(x => x.InOutFlag == queryInOutFlag).ToList().OrderBy(x => x.CreateTime).FirstOrDefault();
|
if (fisrtTaskForIn != null)
|
{
|
partList.Add(fisrtTaskForIn);
|
}
|
}
|
*/
|
//return partList;
|
}
|
|
#endregion
|
}
|
}
|
