//using iWareCommon;
|
//using iWareCommon.Utils;
|
//using iWareSql;
|
//using System;
|
//using System.Collections.Generic;
|
//using System.Threading;
|
|
//using System.Linq;
|
//using iWareSql.Orm;
|
//using iWareCC.RgvService;
|
//using System.Threading.Tasks;
|
//using iWareSql.Entity.ParamModel;
|
//using iWareCC.BLL;
|
//using iWareSql.DataAccess;
|
|
//using Newtonsoft.Json;
|
//using iWareModel;
|
//using iWareSql.DBModel;
|
//using iWareCommon.Common.Globle;
|
//using XiGang.Core.Model;
|
//using iWareCC.Common.Helper;
|
|
//namespace iWareCC
|
//{
|
// /// <summary>
|
// /// RGV任务服务线程类
|
// /// </summary>
|
// public class RgvTaskThreadService : DeviceThreadServiceHandle
|
// {
|
|
// private static string _namespace = "iWareCC.RgvThreadService";
|
|
// private RgvTaskThreadService() { }
|
// public RgvTaskThreadService(LogType logType)
|
// {
|
// base.currentLogType = logType;
|
// }
|
// public override void StartService()
|
// {
|
// Task.Run(() =>
|
// {
|
// try
|
// {
|
// //自动执行Rgv任务线程
|
// Log4NetHelper.WriteInfoLog(base.currentLogType, "[自动执行Rgv任务线程] 启动了");
|
|
// base.IssueTaskThread(EDevice.RGV);
|
// base.ConfirmFinishTaskThread(EDevice.RGV);
|
// }
|
// catch (Exception ex)
|
// {
|
// Log4NetHelper.WriteErrorLog(base.currentLogType, "RgvThreadService线程启动出现异常", ex);
|
// }
|
// });
|
// }
|
|
// #region 线程处理
|
|
// #region 自动执行Rgv任务线程
|
|
// /// <summary>
|
// /// 自动执行Rgv任务
|
// /// </summary>
|
// /// <param name="srmName"></param>
|
// public override void IssueTask(object deviceId)
|
// {
|
// var errMsg = "";
|
// int i_deviceId = (int)deviceId;
|
// while (true)
|
// {
|
// if (SystemValue.isAllowRuning_RgvThreadService && SystemValue.isStartedModel)
|
// {
|
// IssueTaskHandle(i_deviceId, out errMsg);
|
// }
|
// SystemWarningMsg._lbl_Alert_RgvRelease = errMsg;
|
// Thread.Sleep(2000);//2秒一次
|
// }
|
|
// }
|
|
// /// <summary>
|
// /// 自动执行Rgv任务（线程）
|
// /// </summary>
|
// /// <param name="srmName"></param>
|
// public override void IssueTaskHandle(int deviceId, out string errMsg)
|
// {
|
// errMsg = "";
|
// string logHeader = "方法：DoRgvTaskByThead，参数deviceId：" + deviceId.ToString() + "===";
|
// #region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
// IDictionary<string, object> logDict = new Dictionary<string, object>();
|
// logDict.Add("deviceId", deviceId);
|
// iWareSql.Orm.Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DoRgvTaskByThead", logDict);
|
// #endregion
|
// try
|
// {
|
// /*
|
// * 执行发送给Rgv的指令任务
|
// * 1、验证根据设备号是否找到Rgv
|
// * 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
|
// * 3、判断数据库中是否有可要下发的任务，如果有就下发+验证起始点和目标点是否正确
|
// * 4、下发成功后，更新任务状态
|
// */
|
|
|
// //2、判断设备是否属于空闲，如果属于空闲，就继续走2
|
// bool isOk = ValidateDeviceIsAllowSendTask((int)EDevice.RGV, out errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// return;
|
// }
|
// var newErrMsg = "";
|
// using (DbModel dbModel = new DbModel())
|
// {
|
// var partList = GetPartListByDevice(dbModel, deviceId, TaskExcuteTypeEnum.执行任务);
|
// if (partList != null && partList.Count > 0)
|
// {
|
// //首先处理模拟完成的任务
|
// foreach (var item in partList)
|
// {
|
// if (item.IsAllowSimulateExecute == true)
|
// {
|
// Single_IssueTaskHandle(false, item, dbModel, deviceId, exception, false, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// return;
|
// }
|
// }
|
// //foreach (var currentTask in partList)
|
// //{
|
// // Single_IssueTaskHandle(currentTask, dbModel, deviceId, exception, out errMsg);
|
// // Thread.Sleep(2000);//休眠2秒 【EditBy shaocx,2022-05-04】
|
// //}
|
// //*/
|
// //分隔任务 RGV任务和输送线任务 [EditBy shaocx,2022-04-29]
|
// var q_taskType_出库 = (int)DeviceTaskTypeEnum.出库;
|
// var rgvOutTaskList_出库 = partList.Where(x => x.TaskType == q_taskType_出库).ToList();//rgv出库任务
|
|
// var q_taskType_立库空托到拆盘机入口 = (int)DeviceTaskTypeEnum.立库空托到拆盘机入口;
|
// var rgvOutTaskList_立库空托到拆盘机入口 = partList.Where(x => x.TaskType == q_taskType_立库空托到拆盘机入口).ToList();//rgv 立库空托到拆盘机入口任务
|
|
// var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
|
// var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;
|
// var rgvInTaskList = partList.Where(x => x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库).ToList();//rgv入库任务
|
|
|
// var q_taskType_空托转运到拆盘机入口 = (int)DeviceTaskTypeEnum.空托转运到拆盘机入口;
|
// var rgvTaskList_空托转运到拆盘机入口 = partList.Where(x => x.TaskType == q_taskType_空托转运到拆盘机入口).ToList();//rgv 空托转运到拆盘机入口 任务
|
|
// //纯输送线任务
|
// var q_taskType_拆盘机入口到拆盘机 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
|
// var q_taskType_空托缓存位转运 = (int)DeviceTaskTypeEnum.空托缓存位转运;
|
// var lineTaskList = partList.Where(x => x.TaskType == q_taskType_拆盘机入口到拆盘机 || x.TaskType == q_taskType_空托缓存位转运).ToList();//纯输送线任务
|
|
|
// /*
|
// * 策略：
|
// * 1、优先做发动机出库任务
|
// * 2、如果发动机出库任务下发不成功，则做 立库空托到拆盘机入口 任务
|
// * 3、其次做 组盘入库+空托转运到立体库任务，按顺序执行
|
// * 4、其次做 空托转运到拆盘机入口 任务
|
// * 5、其他纯输送线任务不受上述策略影响
|
// */
|
// if (lineTaskList != null && lineTaskList.Count > 0)
|
// {//纯输送线任务
|
// foreach (var currentTask in lineTaskList)
|
// {
|
// Single_IssueTaskHandle(false, currentTask, dbModel, deviceId, exception, false, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// }
|
// }
|
|
// if (rgvOutTaskList_出库 != null && rgvOutTaskList_出库.Count > 0)
|
// {
|
// //注意：出库任务下发就不要以CreateTime了，而是按照MainTaskSequence，因为在出库任务分解的时候，会出现那种 【EditBy shaocx,2022-05-19】
|
// // 二号堆垛机、二号堆垛机、三号堆垛机出库情况，如果按照CreateTime，排序会变为 二号堆垛机、三号堆垛机、二号堆垛机
|
// //var _partTask = rgvOutTaskList_出库.OrderBy(x => x.CreateTime).First();
|
// var _partTask = rgvOutTaskList_出库.OrderBy(x => x.MainTaskSequence).ThenBy(x => x.CreateTime).First();
|
// var validateLastSameToPlaceIsFinished = ValidateLastSameToPlaceIsFinished(dbModel, _partTask, true, ref newErrMsg);
|
// //var vaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE = VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE(dbModel, _partTask, ref newErrMsg);
|
// if (validateLastSameToPlaceIsFinished == true)
|
// {
|
// //每次只下发第一个出库任务
|
// Single_IssueTaskHandle(true, _partTask, dbModel, deviceId, exception, true, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// if (string.IsNullOrEmpty(errMsg))
|
// {//说明下发任务成功
|
// return;//结束此次循环
|
// }
|
// }
|
// else
|
// {
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// }
|
// }
|
// //如果发动机出库任务下发不成功，则做 立库空托到拆盘机入口 任务
|
// if (rgvOutTaskList_立库空托到拆盘机入口 != null && rgvOutTaskList_立库空托到拆盘机入口.Count > 0)
|
// {
|
// Single_IssueTaskHandle(true, rgvOutTaskList_立库空托到拆盘机入口.OrderBy(x => x.CreateTime).First(), dbModel, deviceId, exception, true, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// if (string.IsNullOrEmpty(errMsg))
|
// {//说明下发任务成功
|
// return;//结束此次循环
|
// }
|
// }
|
// //其次做 组盘入库+空托转运到立体库任务，按顺序执行
|
// if (rgvInTaskList != null && rgvInTaskList.Count > 0)
|
// {
|
// var _partTask = rgvInTaskList.OrderBy(x => x.CreateTime).First();
|
// var validateLastSameToPlaceIsFinished = ValidateLastSameToPlaceIsFinished(dbModel, _partTask, false, ref newErrMsg);
|
// //var vaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE = VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE22(dbModel, _partTask, ref newErrMsg);
|
// if (validateLastSameToPlaceIsFinished == true)
|
// {
|
// //按顺序下发
|
// Single_IssueTaskHandle(true, _partTask, dbModel, deviceId, exception, false, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// if (string.IsNullOrEmpty(errMsg))
|
// {//说明下发任务成功
|
// return;//结束此次循环
|
// }
|
// }
|
// else
|
// {
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// }
|
// }
|
// //其次做 空托转运到拆盘机入口 任务
|
// if (rgvTaskList_空托转运到拆盘机入口 != null && rgvTaskList_空托转运到拆盘机入口.Count > 0)
|
// {
|
// Single_IssueTaskHandle(true, rgvTaskList_空托转运到拆盘机入口.OrderBy(x => x.CreateTime).First(), dbModel, deviceId, exception, false, out newErrMsg);
|
// errMsg += newErrMsg + SysGloble.SPLIT_STR;
|
// if (string.IsNullOrEmpty(errMsg))
|
// {//说明下发任务成功
|
// return;//结束此次循环
|
// }
|
// }
|
// //*/
|
// /*
|
// //分隔任务 RGV任务和输送线任务 [EditBy shaocx,2022-04-29]
|
// var q_taskType1 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
|
// var q_taskType2 = (int)DeviceTaskTypeEnum.空托缓存位转运;
|
// var lineTaskList = partList.Where(x => x.TaskType == q_taskType1 || x.TaskType == q_taskType2).ToList();//输送线任务
|
// var rgvTaskList = partList.Where(x => x.TaskType != q_taskType1 && x.TaskType != q_taskType2).ToList();//rgv任务
|
|
// if (rgvTaskList != null && rgvTaskList.Count > 0)
|
// {
|
// Single_IssueTaskHandle(true, rgvTaskList.First(), dbModel, deviceId, exception, out errMsg);
|
// Thread.Sleep(2000);//休眠2秒 【EditBy shaocx,2022-05-04】
|
// }
|
|
// if (lineTaskList != null && lineTaskList.Count > 0)
|
// {
|
// foreach (var currentTask in lineTaskList)
|
// {
|
// Single_IssueTaskHandle(false, currentTask, dbModel, deviceId, exception, out errMsg);
|
// }
|
// }
|
// //*/
|
// }
|
// else
|
// {
|
// errMsg = "没有任务要发送给Rgv";
|
// }
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// errMsg = "出现异常：" + ex.Message;
|
// SysExceptionInfoHandler.GetExceptionInfoForError("自动执行Rgv任务（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
// SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
// }
|
// }
|
|
// /// <summary>
|
// ///
|
// /// </summary>
|
// /// <param name="isRgvTask"></param>
|
// /// <param name="currentTask"></param>
|
// /// <param name="dbModel"></param>
|
// /// <param name="deviceId"></param>
|
// /// <param name="exception"></param>
|
// /// <param name="isOutStoreTask">是否是出库任务</param>
|
// /// <param name="errMsg"></param>
|
// private void Single_IssueTaskHandle(bool isRgvTask, Task_Part currentTask, DbModel dbModel, int deviceId, iWareSql.Orm.Base_SysExceptionInfo exception,
|
// bool isOutStoreTask,
|
// out string errMsg)
|
// {
|
// errMsg = "";
|
|
// if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
|
// {//如果是模拟完成
|
|
// }
|
// else
|
// {//非模拟完成
|
// #region //3、判断数据库中是否有可要下发的任务，如果有就下发
|
// //验证起始点和目标点是否正确
|
// RealPlaceEntity realPlaceEntity = null;
|
// //if (!ValdiatePalceIsRight(dbModel, (int)currentTask.SourcePlace, (int)currentTask.ToPlace, ref realPlaceEntity))
|
// //{
|
// // errMsg = "验证起始点和目标点是否正确失败";
|
// // PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// // return;
|
// //}
|
|
// //验证是否可以下发任务
|
// var isOk = ValidateDeviceIsAllowSendTask(isRgvTask, (int)EDevice.RGV, currentTask, out errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
// //要判断起点是否有库存，如果起点没有库存，则报错 【EditBy shaocx,2022-05-15】
|
// var sourcePlaceStore = dbModel.V_AllStore.Where(x => x.StationId == currentTask.SourcePlace).FirstOrDefault();
|
// if (sourcePlaceStore == null)
|
// {
|
// errMsg = "不允许下发新任务," + string.Format("起点{0},{1}没有找到库存信息，无法下发RGV任务!", currentTask.SourcePlace.ToString(), currentTask.RealSourcePlace);
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
// //验证目标点是否已经有库存 【EditBy shaocx,2022-04-15】
|
// isOk = ValidateIsHasStoreForToPlace((int)EDevice.RGV, currentTask.ToPlace, currentTask.RealToPlace, out errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
|
// //if (isRgvTask)
|
// if (currentTask.TaskType == (int)DeviceTaskTypeEnum.出库) //修改为只对出库任务的判断，因为我发现有次出现过，下发了去1012的任务，但当时1012竟然有货，导致rgv不执行任务，然后导致rgv不执行其他入库任务的情况 【EditBy shaocx,2022-05-21】
|
// {
|
// isOk = ValidateIsExistNoFinished(dbModel, currentTask, ref errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
// }
|
|
// //增加验证 【EditBy shaocx,2022-05-07】
|
// var vaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012 = VaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012(dbModel, currentTask, ref errMsg);
|
// if (vaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012)
|
// {
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
// var vaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation = VaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation(dbModel, currentTask, ref errMsg);
|
// if (vaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation)
|
// {
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
|
// //验证起点光电是否有货存在 【EditBy shaocx,2022-05-11】
|
// //var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealSourcePlace);
|
// //if (isGD_HasCatogryForRgvStattion == false)
|
// //{
|
// // errMsg = "不允许下发新任务,起点位置" + currentTask.RealSourcePlace + "有光电显示无货存在";
|
// // //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// // return;
|
// //}
|
|
|
// //如果目标位置有光电显示有货存在，则不允许下发任务，是为了防止1014到1020的任务的，如果1020上有货，就不发任务 【EditBy shaocx,2022-04-30】
|
// //全部任务都要验证目标点是否有货 【EditBy shaocx,2022-05-08】
|
// //isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealToPlace);
|
// //if (isGD_HasCatogryForRgvStattion)
|
// //{
|
// // errMsg = "不允许下发新任务,目标位置" + currentTask.RealToPlace + "有光电显示有货存在";
|
// // //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// // return;
|
// //}
|
|
|
// if (isOutStoreTask)
|
// {//如果是出库任务，则需要检测立体库出库口上面有货才可以下发任务 [EditBy shaocx,2022-05-11]
|
// //休眠1秒
|
// Thread.Sleep(3000);//增加休眠3秒的判断
|
// //var isGD_HasCatogryForSoruceRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealSourcePlace);
|
// //if (!isGD_HasCatogryForSoruceRgvStattion)
|
// //{
|
// // errMsg = "不允许下发新任务,起始位置" + currentTask.RealSourcePlace + "有光电显示没有货存在！！";
|
// // //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// // return;
|
// //}
|
// //再次判断出库任务，目标位置是否有发动机
|
// //因为我发现有次出现过，下发了去1012的任务，但当时1012竟然有货，导致rgv不执行任务，然后导致rgv不执行其他入库任务的情况 【EditBy shaocx,2022-07-24】
|
// //isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealToPlace);
|
// //if (isGD_HasCatogryForRgvStattion)
|
// //{
|
// // errMsg = "不允许下发新任务,目标位置" + currentTask.RealToPlace + "有光电显示有货存在";
|
// // //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// // return;
|
// //}
|
// }
|
|
|
// //验证是否存在 同一个起点，同一个目标点，并且是 未完成的的任务
|
// isOk = ValidateIsHasNoFinishedSameTask((int)EDevice.RGV, currentTask, out errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
// //同一个关联任务的其他设备任务
|
// //判断和堆垛机的连接任务是不是已经完成了
|
// var queryTaskState1 = (int)SubTaskStateEnum.未开始;
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == currentTask.MainTaskId && x.TaskSequence < currentTask.TaskSequence && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)).FirstOrDefault();
|
// if (relevanceTask != null)
|
// {
|
// errMsg = string.Format("关联{0}任务未完成，所以RGV任务不允许下发！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
|
// #region 增加验证 【EditBy shaocx,2022-05-15】
|
// //来源位置的库位状态
|
// var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
|
// if (sourcePlace == null)
|
// {
|
// throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.SourcePlace.ToString()));
|
// }
|
// var toPlace = dbModel.Base_Station.Where(o => o.Id == currentTask.ToPlace).FirstOrDefault();
|
// if (toPlace == null)
|
// {
|
// throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.ToPlace.ToString()));
|
// }
|
|
// DeviceTaskTypeEnum _DeviceTaskTypeEnum;
|
// if (EnumberHelper.GetEnumObject<DeviceTaskTypeEnum>(currentTask.TaskType.ToString(), out _DeviceTaskTypeEnum) == false)
|
// {
|
// throw new Exception("枚举值不正确!");
|
// }
|
|
// #endregion
|
|
|
// //下发
|
// SdaResEntity sdaResult = new SdaResEntity();
|
// var log = TaskRequestLogHandler.GetTask(currentTask.Id,
|
// (int)currentTask.DeviceId, currentTask.PlcTaskId, currentTask.RealSourcePlace.ToString(),
|
// currentTask.RealToPlace.ToString(), "给RGV发送任务指令", "sys");
|
// try
|
// {
|
// if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
|
// {
|
// sdaResult.result = true;
|
// }
|
// else
|
// {
|
// sdaResult = new RgvService.RgvServiceClient().SendRgvTask(deviceId, Convert.ToInt32(currentTask.PlcTaskId), Convert.ToString(currentTask.RealSourcePlace), Convert.ToString(currentTask.RealToPlace));
|
// }
|
// if (sdaResult.result == false)
|
// {//给Rgv下发指令失败
|
// errMsg = sdaResult.resMsg;
|
// exception.exceptionMsg = string.Format("发送指令给Rgv失败,设备号{0},任务ID{1},起始位{2}，目标位{3},errMsg{4}", deviceId, currentTask.Id, currentTask.SourcePlace.ToString(), currentTask.ToPlace.ToString(), errMsg);
|
// SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
|
// return;
|
// }
|
// else
|
// {
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// errMsg = "出现异常:" + ex.Message;
|
// SysExceptionInfoHandler.GetExceptionInfoForError("给RGV发送任务指令出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
// SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, ex);
|
// return;
|
// }
|
|
// #endregion
|
// }
|
|
// TranferStoreForRgv(currentTask, deviceId, dbModel, "RGV任务下发后", out errMsg);
|
// if (!string.IsNullOrEmpty(errMsg))
|
// {
|
// //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
|
// return;
|
// }
|
|
// //4、下发成功后，更新任务状态
|
// currentTask.IsReleased = true;
|
// currentTask.ModifyBy = SysGloble.WCSSystem;
|
// currentTask.ModifyTime = DateTime.Now;
|
// var changeState = SubTaskStateEnum.已下发;
|
// currentTask.TaskState = (int)changeState;
|
// currentTask.TaskStateName = changeState.ToString();
|
// currentTask.OperationRemark = "任务已下发给设备";
|
// currentTask.IssueTime = DateTime.Now;//下发时间
|
// //修改Task_Main的状态
|
// UpdateMainTaskStatus(dbModel, currentTask.MainTaskId, currentTask.TaskType, "下发任务给RGV");
|
|
|
// //推送MES
|
// var mainTask = MainTaskHandler.GetMainTaskById(dbModel, currentTask.MainTaskId);
|
// MesService.UpdateIsNeedOnLineForMainTask(mainTask);
|
|
// int i = dbModel.SaveChanges();
|
// if (i <= 0)
|
// {
|
// errMsg = "更新数据库失败,更新条数:" + i;
|
// }
|
// else
|
// {
|
|
// }
|
// }
|
|
// #endregion
|
|
// #region 自动结束Rgv任务线程
|
|
// /// <summary>
|
// /// 自动结束Rgv任务线程
|
// /// </summary>
|
// /// <param name="srmName"></param>
|
// public override void ConfirmFinishTask(object deviceId)
|
// {
|
// string errMsg = "";
|
// int i_deviceId = (int)deviceId;
|
// while (true)
|
// {
|
// if (SystemValue.isAllowRuning_RgvThreadService_Finish && SystemValue.isStartedModel)
|
// {
|
// ConfirmFinishTaskHandle(i_deviceId, out errMsg);
|
// }
|
// SystemWarningMsg._lbl_Alert_RgvReleaseFinish = errMsg;
|
// Thread.Sleep(2000);
|
// }
|
|
// }
|
|
// /// <summary>
|
// /// 自动结束Rgv任务线程（线程）
|
// /// </summary>
|
// /// <param name="srmName"></param>
|
// public override void ConfirmFinishTaskHandle(int deviceId, out string errMsg)
|
// {
|
// errMsg = "";
|
// var remark = "自动结束Rgv任务线程（线程）";
|
// #region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
// IDictionary<string, object> logDict = new Dictionary<string, object>();
|
// logDict.Add("deviceId", deviceId);
|
// iWareSql.Orm.Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "FinishRgvTaskByThead", logDict);
|
// #endregion
|
// try
|
// {
|
// /*
|
// * 执行发送给Rgv的指令任务
|
// * 1、验证根据设备号是否找到Rgv
|
// * 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
|
// * 3、判断数据库中是否有可要完成的任务，如果有判断是否跟Rgv中的完成任务相符，如果相符就处理
|
// * 4、更新任务状态
|
// */
|
|
// int int_deviceId = (int)deviceId;
|
|
|
// //*/
|
// using (DbModel dbModel = new DbModel())
|
// {
|
// var partList = GetPartListByDevice(dbModel, deviceId, TaskExcuteTypeEnum.结束任务);
|
// if (partList != null && partList.Count > 0)
|
// {
|
// foreach (var currentTask in partList)
|
// {
|
// SingleConfirmFinishTaskHandle(currentTask, int_deviceId, dbModel, remark, out errMsg);
|
// }
|
// }
|
// else
|
// {
|
// errMsg = "没有RGV任务要处理";
|
// return;
|
// }
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// errMsg = "出现异常:" + ex.Message;
|
// SysExceptionInfoHandler.GetExceptionInfoForError("自动结束Rgv任务线程（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
// SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
// }
|
// }
|
|
|
// private void SingleConfirmFinishTaskHandle(Task_Part currentTask, int int_deviceId, DbModel dbModel, string remark, out string errMsg)
|
// {
|
// #region //3、判断数据库中是否有可要完成的任务，如果有判断是否跟Rgv中的完成任务相符，如果相符就处理
|
|
// DeviceTaskTypeEnum rgvTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), currentTask.TaskType.ToString());
|
|
// //同一个关联任务的其他设备任务
|
// //判断和堆垛机的连接任务是不是已经完成了
|
// var queryTaskState1 = (int)SubTaskStateEnum.未开始;
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == currentTask.MainTaskId && x.TaskSequence < currentTask.TaskSequence && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)).FirstOrDefault();
|
// if (relevanceTask != null)
|
// {
|
// errMsg = string.Format("关联{0}任务未完成，所以RGV任务不允许完成！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
|
// return;
|
// }
|
|
// #endregion
|
|
// //注意：这里不需要判断设备是否完成，直接就结束任务
|
// //2、判断设备是否属于任务完成，如果属于任务完成，就继续走2
|
// var isTaskFinished = ValidateDeviceTaskIsFinsished(int_deviceId, currentTask, Convert.ToInt32(currentTask.PlcTaskId), currentTask.IsAllowSimulateExecute, out errMsg);
|
// if (!isTaskFinished) return;
|
|
// //4、更新任务状态
|
// currentTask.FinishTime = DateTime.Now;//完成时间
|
// currentTask.IsFinished = true;
|
// currentTask.TaskState = (int)SubTaskStateEnum.已完成;
|
// currentTask.TaskStateName = SubTaskStateEnum.已完成.ToString();
|
// currentTask.OperationRemark = "已完成";
|
// currentTask.ModifyBy = SysGloble.WCSSystem;
|
// currentTask.ModifyTime = DateTime.Now;
|
|
|
// using (var trans = dbModel.Database.BeginTransaction())
|
// {
|
// try
|
// {
|
// //推送MES
|
// var mainTask = MainTaskHandler.GetMainTaskById(dbModel, currentTask.MainTaskId);
|
// MesService.UpdateIsNeedOnLineForMainTask(mainTask);
|
|
// //注意：一定是先要保存数据库，才再跟plc交互！！！！！
|
// var i = dbModel.SaveChanges();
|
// if (i <= 0)
|
// {
|
// throw new Exception("修改条数为0");
|
// }
|
|
// var isRgvTask = IsRgvTask(currentTask);
|
// if (isRgvTask)
|
// {//如果是RGV任务，则需要去给RGV任务确认
|
// SdaResEntity confirmTaskFinish = null;
|
// var log = TaskRequestLogHandler.GetTask(currentTask.Id,
|
// (int)currentTask.DeviceId, currentTask.PlcTaskId, currentTask.RealSourcePlace.ToString(),
|
// currentTask.RealToPlace.ToString(), "给RGV发送任务完成确认指令", "sys");
|
// try
|
// {
|
// //任务完成处理成功，需要再给RGV发送任务完成确认信号
|
// if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
|
// {
|
// confirmTaskFinish = new SdaResEntity()
|
// {
|
// result = true
|
// };
|
// }
|
// else
|
// {
|
// confirmTaskFinish = new RgvService.RgvServiceClient().WriteRGV_FinishACK((int)EDevice.RGV, true, Convert.ToInt32(currentTask.PlcTaskId));
|
// }
|
// if (!confirmTaskFinish.result)
|
// {
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(confirmTaskFinish), log, null);
|
// trans.Rollback();
|
// return;
|
// }
|
// else
|
// {
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(confirmTaskFinish), log, null);
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// errMsg = "出现异常:" + ex.Message;
|
// Log4NetHelper.WriteErrorLog(LogType.RgvThreadService, errMsg, ex);
|
// TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(confirmTaskFinish), log, ex);
|
// trans.Rollback();
|
// return;
|
// }
|
|
// //*/
|
// }
|
|
|
|
// trans.Commit();
|
|
|
// }
|
// catch (Exception)
|
// {
|
// trans.Rollback();
|
// throw;
|
// }
|
// }
|
// }
|
|
|
// #endregion
|
|
// #endregion
|
|
// #region 库存处理
|
|
// /// <summary>
|
// /// 库存转移
|
// /// </summary>
|
// /// <param name="currentTask"></param>
|
// /// <param name="int_deviceId"></param>
|
// /// <param name="dbModel"></param>
|
// /// <param name="remark"></param>
|
// /// <param name="errMsg"></param>
|
// private void TranferStoreForRgv(Task_Part currentTask, int int_deviceId, DbModel dbModel, string remark, out string errMsg)
|
// {
|
|
// //来源位置的库位状态
|
// var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
|
// if (sourcePlace == null)
|
// {
|
// throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.SourcePlace.ToString()));
|
// }
|
// var toPlace = dbModel.Base_Station.Where(o => o.Id == currentTask.ToPlace).FirstOrDefault();
|
// if (toPlace == null)
|
// {
|
// throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.ToPlace.ToString()));
|
// }
|
|
// //验证目标点是否已经有库存 【EditBy shaocx,2022-04-15】
|
// var isOk = ValidateIsHasStoreForToPlace((int)EDevice.RGV, currentTask.ToPlace, currentTask.RealToPlace, out errMsg);
|
// if (!isOk)
|
// {
|
// errMsg = "不允许下发新任务," + errMsg;
|
// return;
|
// }
|
|
// #region 3、变更库位状态(任务占用、锁定)
|
|
// UpdateStationLockInfoWhenFinished(dbModel, sourcePlace, toPlace, currentTask.Id, "RGV任务完成，出库任务处理");
|
|
// #endregion
|
|
// toPlace.IsFull = true;
|
|
|
// sourcePlace.IsFull = false;
|
|
// DeviceTaskTypeEnum _DeviceTaskTypeEnum;
|
// if (EnumberHelper.GetEnumObject<DeviceTaskTypeEnum>(currentTask.TaskType.ToString(), out _DeviceTaskTypeEnum) == false)
|
// {
|
// throw new Exception("枚举值不正确!");
|
// }
|
// //修改来源和目标的CVP关系，更新库存
|
// UpdateStore(dbModel, sourcePlace, toPlace, _DeviceTaskTypeEnum, currentTask);
|
|
|
// //5、如果是出库任务，则需要更新计划出库明细表和计划出库主表的信息
|
// if (currentTask.TaskType == (int)DeviceTaskTypeEnum.出库)
|
// {
|
// PlanOutTaskHandler.UpdatePlanStateToFinished(dbModel, currentTask.MainTaskId, remark);
|
// }
|
// }
|
|
// #endregion
|
|
// #region 公共处理
|
|
// /// <summary>
|
// /// 是否是RGV任务
|
// /// </summary>
|
// /// <param name="_task"></param>
|
// /// <returns></returns>
|
// private bool IsRgvTask(Task_Part _task)
|
// {
|
// var isRgvTask = true;
|
// if (_task.TaskType == (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机 || _task.TaskType == (int)DeviceTaskTypeEnum.空托缓存位转运)
|
// {
|
// isRgvTask = false;
|
// }
|
// return isRgvTask;
|
// }
|
|
// /// <summary>
|
// /// 判断相同目的地的RGV任务，上一个是否完成了
|
// /// </summary>
|
// /// <param name="dbModel"></param>
|
// /// <param name="currentTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool ValidateLastSameToPlaceIsFinished(DbModel dbModel, Task_Part currentTask, bool isOutStoreForFDJ, ref string errMsg)
|
// {
|
// ////判断和堆垛机(或RGV)的连接任务是不是已经完成了
|
// var queryTaskState1 = (int)SubTaskStateEnum.未开始;
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var queryDeviceId = (int)EDevice.RGV;
|
// //同一个RGV的，并且是同种类型的（即相同目的地的）
|
// Task_Part otherSrmTask = null;
|
// if (isOutStoreForFDJ)
|
// {//是发动机出库
|
// otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
|
// && x.Id != currentTask.Id
|
// && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
|
// && x.MainTaskSequence <= currentTask.MainTaskSequence
|
// && x.RealToPlace == currentTask.RealToPlace
|
// ).FirstOrDefault();
|
// }
|
// else
|
// {//非发动机出库
|
// otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
|
// && x.Id != currentTask.Id
|
// && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
|
// && x.CreateTime < currentTask.CreateTime
|
// && x.RealToPlace == currentTask.RealToPlace
|
// ).FirstOrDefault();
|
// }
|
// if (otherSrmTask != null)
|
// {
|
// errMsg = "上一个RGV任务(即相同目的地的" + currentTask.RealToPlace + ")未完成，所以本次任务不允许下发！上一个RGV任务号:" + otherSrmTask.PlcTaskId + "，本次RGV任务号:" + currentTask.PlcTaskId;
|
// return false;
|
// }
|
// return true;
|
// }
|
|
|
// /// <summary>
|
// /// 判断RGV任务，上一个RGV存在已下发的任务
|
// /// </summary>
|
// /// <param name="dbModel"></param>
|
// /// <param name="currentTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool ValidateIsExistNoFinished(DbModel dbModel, Task_Part currentTask, ref string errMsg)
|
// {
|
// ////判断和堆垛机(或RGV)的连接任务是不是已经完成了
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var queryDeviceId = (int)EDevice.RGV;
|
|
// var q_taskType_拆盘机入口到拆盘机 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
|
// var q_taskType_空托缓存位转运 = (int)DeviceTaskTypeEnum.空托缓存位转运;
|
|
// //判断都是RGV任务，前面是否有 已下发 的任务，如果有，就报错
|
// var otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
|
// && x.Id != currentTask.Id
|
// && (x.TaskState == queryTaskState2)
|
// //&& x.CreateTime < currentTask.CreateTime
|
// && (x.TaskType != q_taskType_拆盘机入口到拆盘机 && x.TaskType != q_taskType_空托缓存位转运)
|
// ).FirstOrDefault();
|
// if (otherSrmTask != null)
|
// {
|
// errMsg = "上一个RGV任务是已下发状态，所以本次任务不允许下发！上一个RGV任务号:" + otherSrmTask.PlcTaskId + "，本次RGV任务号:" + currentTask.PlcTaskId;
|
// return false;
|
// }
|
// return true;
|
// }
|
|
// /// <summary>
|
// /// 是否 距离上一次出库任务的下发时间小于设定的值
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="partTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE(DbModel edm, Task_Part partTask, ref string errMsg)
|
// {
|
// var queryToPlace = ((int)EDevice.出库口1012).ToString();
|
|
// var queryTaskState1 = (int)SubTaskStateEnum.已完成;
|
|
// var queryDeviceId = (int)EDevice.RGV;
|
|
// var task = edm.Task_Part.Where(x =>
|
// x.DeviceId == queryDeviceId
|
// && x.RealToPlace == queryToPlace
|
// && x.TaskState == queryTaskState1).OrderByDescending(x => x.IssueTime).FirstOrDefault();//获取最新下发完成的出库任务
|
// if (task != null)
|
// {
|
// //得到下发时间
|
// var issueTime = (DateTime)task.IssueTime;
|
// var nowTime = DateTime.Now;
|
// TimeSpan ts = nowTime - issueTime;
|
// if (ts.Seconds <= SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE)
|
// {
|
// errMsg = "距离上一次出库任务的下发时间小于设定的" + SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE + "秒";
|
// return false;
|
// }
|
// }
|
// return true;
|
// }
|
|
// /// <summary>
|
// /// 是否 距离上一次出库任务的下发时间小于设定的值
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="partTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE22(DbModel edm, Task_Part partTask, ref string errMsg)
|
// {
|
// var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
|
// var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;
|
|
// var queryTaskState1 = (int)SubTaskStateEnum.已完成;
|
|
// var queryDeviceId = (int)EDevice.RGV;
|
|
// var task = edm.Task_Part.Where(x =>
|
// x.DeviceId == queryDeviceId
|
// && x.RealToPlace == partTask.RealToPlace
|
// && (x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库)
|
// && x.TaskState == queryTaskState1).OrderByDescending(x => x.IssueTime).FirstOrDefault();//获取上一次入库，并且是同一个目标点的任务
|
// if (task != null)
|
// {
|
// //得到下发时间
|
// var issueTime = (DateTime)task.IssueTime;
|
// var nowTime = DateTime.Now;
|
// TimeSpan ts = nowTime - issueTime;
|
// if (ts.Seconds <= SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE)
|
// {
|
// errMsg = "距离上一次组盘入库/空托转运到立体库的任务下发时间小于设定的" + SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE + "秒";
|
// return false;
|
// }
|
// }
|
// return true;
|
// }
|
|
|
// /// <summary>
|
// /// 是否存在 创建时间早于当前的任务的未结束的任务,去1012的任务
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="partTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool VaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012(DbModel edm, Task_Part partTask, ref string errMsg)
|
// {
|
// var queryDeviceId = (int)EDevice.RGV;
|
// var queryToPlace = ((int)EDevice.出库口1012).ToString();
|
// if (partTask.RealToPlace == queryToPlace)
|
// {
|
// //判断创建时间早于当前的任务是否下发了，如果没下发，就也不允许下发
|
// var queryTaskState1 = (int)SubTaskStateEnum.未开始;
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var list = edm.Task_Part.Where(x => x.RealToPlace == queryToPlace
|
// && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
|
// && x.DeviceId == queryDeviceId
|
// // && x.CreateTime < partTask.CreateTime
|
// && x.Id != partTask.Id
|
// && x.MainTaskSequence <= partTask.MainTaskSequence
|
// ).FirstOrDefault();
|
// if (list != null)
|
// {
|
// errMsg = "存在都是去向1012的任务，创建时间早于当前任务，但是未开始或已下发的任务" + list.PlcTaskId + "，因为要严格控制出库顺序,不允许下发当前任务：" + partTask.PlcTaskId;
|
// return true;
|
// }
|
// }
|
// return false;
|
// }
|
|
// /// <summary>
|
// /// 是否存在 创建时间早于当前的任务的未结束的任务
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="partTask"></param>
|
// /// <param name="errMsg"></param>
|
// /// <returns></returns>
|
// public bool VaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation(DbModel edm, Task_Part partTask, ref string errMsg)
|
// {
|
// var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
|
// var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;
|
// var queryDeviceId = (int)EDevice.RGV;
|
|
|
// //判断创建时间早于当前的任务是否下发了，如果没下发，就也不允许下发
|
// var queryTaskState1 = (int)SubTaskStateEnum.未开始;
|
// var queryTaskState2 = (int)SubTaskStateEnum.已下发;
|
// var list = edm.Task_Part.Where(x =>
|
// x.RealToPlace == partTask.RealToPlace
|
// && (x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库)
|
// && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
|
// && x.DeviceId == queryDeviceId
|
// && x.CreateTime < partTask.CreateTime).FirstOrDefault();
|
// if (list != null)
|
// {
|
// errMsg = "存在都是去向相同" + partTask.RealToPlace + "的入库任务，创建时间早于当前任务，但是未开始或已下发的任务" + list.PlcTaskId + "，因为要严格控制入库顺序,不允许下发当前任务：" + partTask.PlcTaskId;
|
// return true;
|
// }
|
|
// return false;
|
// }
|
|
|
// /// <summary>
|
// /// 更新主任务的状态
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="mainTaskId"></param>
|
// /// <param name="rgvTaskTypeValue"></param>
|
// /// <param name="remark"></param>
|
// private void UpdateMainTaskStatus(DbModel edm, int mainTaskId, int rgvTaskTypeValue, string remark)
|
// {
|
// DeviceTaskTypeEnum rgvTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), rgvTaskTypeValue.ToString());
|
// MainTaskStatusEnum changeTaskStatus = default(MainTaskStatusEnum);
|
// switch (rgvTaskTypeEnum)
|
// {
|
// case DeviceTaskTypeEnum.组盘入库:
|
// changeTaskStatus = MainTaskStatusEnum.入库中;
|
// MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
|
// break;
|
// case DeviceTaskTypeEnum.出库:
|
// changeTaskStatus = MainTaskStatusEnum.已完成;
|
// MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
|
|
// //如果是有计划的，需要处理下计划表的状态
|
// UpdatePlanOut(edm, mainTaskId);
|
// break;
|
// case DeviceTaskTypeEnum.空托缓存位转运:
|
// case DeviceTaskTypeEnum.空托转运到拆盘机入口:
|
// case DeviceTaskTypeEnum.立库空托到拆盘机入口:
|
// case DeviceTaskTypeEnum.拆盘机入口到拆盘机:
|
// changeTaskStatus = MainTaskStatusEnum.已完成;
|
// MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
|
// break;
|
// default:
|
// return;//其他状态不予处理
|
// }
|
|
// }
|
|
// private void UpdatePlanOut(DbModel edm, int mainTaskId)
|
// {
|
// var planDetail = edm.Plan_OutTaskDetail.FirstOrDefault(x => x.MainTaskId == mainTaskId);
|
// if (planDetail != null)
|
// {
|
// planDetail.OutTaskDetailState = (int)OutTaskDetailStateEnum.完成;
|
// planDetail.OutTaskDetailStateName = OutTaskDetailStateEnum.完成.ToString();
|
// planDetail.FinishTime = DateTime.Now;//增加计划子表完成时间 【EditBy shaocx,2022-06-20】
|
// planDetail.OperationRemark = "RGV任务完成，修改状态为完成";
|
// //查找Main表
|
// var outTask = edm.Plan_OutTask.FirstOrDefault(x => x.Id == planDetail.M_PlanId);
|
// if (outTask != null)
|
// {
|
// var queryOutTaskDetailState1 = (int)OutTaskDetailStateEnum.完成;
|
// var queryOutTaskDetailState2 = (int)OutTaskDetailStateEnum.已取消;
|
// var allCount = edm.Plan_OutTaskDetail.Where(x => x.M_PlanId == outTask.Id).Count();//所有计划
|
// outTask.Qty = allCount;//重新赋值总数量
|
|
// var count = edm.Plan_OutTaskDetail.Where(x => x.M_PlanId == outTask.Id && (x.OutTaskDetailState == queryOutTaskDetailState1 || x.OutTaskDetailState == queryOutTaskDetailState2)).Count();//已下发的计划
|
// var finishedCount = count + 1;
|
// var changeOutPlanStateEnum = default(OutPlanStateEnum);
|
// if (finishedCount >= allCount)
|
// {
|
// changeOutPlanStateEnum = OutPlanStateEnum.全部下发;
|
// outTask.PlanState = (int)changeOutPlanStateEnum;
|
// outTask.PlanStateName = changeOutPlanStateEnum.ToString();
|
// outTask.OperationRemark = "RGV任务完成，全部下发";
|
|
// outTask.Qty_Finish = outTask.Qty;
|
// outTask.Qty_NoFinish = 0;
|
// //修改齐套性为已齐套 [EditBy shaocx,2022-05-16]
|
// outTask.IsPickFinished = true;
|
// //更新计划进度
|
// outTask.PlanRate = 100;
|
// }
|
// else
|
// {
|
// changeOutPlanStateEnum = OutPlanStateEnum.部分下发;
|
// outTask.PlanState = (int)changeOutPlanStateEnum;
|
// outTask.PlanStateName = changeOutPlanStateEnum.ToString();
|
// outTask.OperationRemark = "RGV任务完成，部分下发";
|
// outTask.Qty_Finish = finishedCount;
|
// outTask.Qty_NoFinish = outTask.Qty - finishedCount;
|
// //更新计划进度
|
// outTask.PlanRate = CSharpHelper.ExecPercentRetInt(finishedCount, allCount);
|
// }
|
// }
|
// }
|
// }
|
|
// /// <summary>
|
// /// 修改CVP的数据
|
// /// </summary>
|
// /// <param name="edm"></param>
|
// /// <param name="rgvTaskTypeEnum"></param>
|
// /// <param name="rgvTask"></param>
|
// private void UpdateStore(DbModel dbModel, Base_Station sourcePlace, Base_Station toPlace, DeviceTaskTypeEnum rgvTaskTypeEnum, Task_Part rgvTask)
|
// {
|
// switch (rgvTaskTypeEnum)
|
// {
|
// case DeviceTaskTypeEnum.组盘入库:
|
// default://其他
|
|
// TransferStoreWhenFinished(rgvTask, dbModel, rgvTask.SalverId, toPlace, "RGV任务被下发,重新绑定新的CVP关系", rgvTaskTypeEnum, EDeviceType.RGV);
|
// break;
|
// case DeviceTaskTypeEnum.拆盘机入口到拆盘机:
|
// case DeviceTaskTypeEnum.出库://注意：RGV出库的时候，目前是将库存删除掉！！！！
|
// StoreHandler.ClearStockByPlaceId(dbModel, sourcePlace, "RGV出库任务被下发,删除库存");
|
// //记录主表的出库时间
|
// var mainTask = dbModel.Task_Main.Where(x => x.TaskNo == rgvTask.MainTaskNo).First();
|
// mainTask.OutStoreTime = DateTime.Now;
|
// break;
|
// }
|
// }
|
|
|
// public bool ValidateDeviceIsAllowSendTask(bool isRgvTask, int int_deviceId, Task_Part task, out string errMsg)
|
// {
|
// errMsg = "";
|
// if (FormCC.IsSimulationPLC)
|
// {
|
// return true;
|
// }
|
// if (!base.ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg))
|
// {
|
// return false;
|
// }
|
// bool isNeedValidateRealSourceAndToPlace = true;
|
// if (task.RealSourcePlace == ((int)EDevice.堆垛机1出库口1001).ToString()
|
// || task.RealSourcePlace == ((int)EDevice.堆垛机2出库口1003).ToString()
|
// || task.RealSourcePlace == ((int)EDevice.堆垛机3出库口1005).ToString()
|
// || task.RealSourcePlace == ((int)EDevice.堆垛机4出库口1008).ToString()
|
// )
|
// {//如果是立体库出库口，则不需要校验起点和终点是否是自动模式啊，运行模式啊
|
// isNeedValidateRealSourceAndToPlace = false;
|
// }
|
// using (var rgvServie = new RgvService.RgvServiceClient())
|
// {
|
// SdaResEntity sdaResult = rgvServie.IsAllowSendTask(isNeedValidateRealSourceAndToPlace, int_deviceId, task.RealSourcePlace, task.RealToPlace, isRgvTask);
|
// if (sdaResult.result == false)
|
// {
|
// errMsg = sdaResult.resMsg;
|
// Log4NetHelper.WriteErrorLog(currentLogType, "验证RGV不可以下发新任务,int_deviceId:" + int_deviceId + ",sdaResultStr:" + JsonConvert.SerializeObject(sdaResult));
|
// }
|
// return sdaResult.result;
|
// }
|
// }
|
|
// /// <summary>
|
// /// 验证Rgv是否可以接受任务
|
// /// </summary>
|
// /// <param name="int_deviceId">设备号，不需要</param>
|
// /// <param name="taskId">任务号，需要</param>
|
// /// <returns></returns>
|
// public override bool ValidateDeviceIsOK(int int_deviceId, Task_Part _task, int taskId, out string errMsg)
|
// {
|
// errMsg = "";
|
// // Rgv没有所谓的空闲状态，有任务直接发即可
|
// if (Wms_EquipmentSituationHandler.IsEquipmentBreakdown(int_deviceId).result)
|
// {//如果设备已经设定为 故障状态，不允许下发任务！！！ [EditBy shaocx,2020-12-07]
|
// return false;
|
// }
|
// return true;
|
// }
|
|
// /// <summary>
|
// /// 验证Rgv是否任务完成
|
// /// </summary>
|
// /// <param name="int_deviceId"></param>
|
// /// <returns>0表示没有任务完成，其他表示任务完成，并返回任务号</returns>
|
// public override bool ValidateDeviceTaskIsFinsished(int int_deviceId, Task_Part _task, int taskId, bool? isAllowSimulateExecute, out string errMsg)
|
// {
|
// errMsg = "";
|
// if (FormCC.IsSimulationPLC)
|
// {
|
// return true;
|
// }
|
// if (MyExtendHelper.IsAllowSimulatorHandle(_task))
|
// {//模拟代码！发布时移除该代码
|
// errMsg = "任务要求强制模拟完成";
|
// return true;
|
// }
|
// var isRgvTask = IsRgvTask(_task);
|
|
// if (isRgvTask == false)
|
// {
|
// //注意：这里不需要跟rgv确认完成，发送任务就自动完成任务了 【EditBy shaocx,2022-04-13】
|
// return true;
|
// }
|
// else
|
// {
|
// var result = new RgvService.RgvServiceClient().IsTaskFinish(int_deviceId, taskId);
|
// if (result.result) return true;
|
// else
|
// {
|
// errMsg = result.resMsg;
|
// return false;
|
// }
|
// }
|
// }
|
// #endregion
|
// }
|
//}
|
