lsy/FT479
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加项目文件。

Browse Source
This commit is contained in:
Administrator
2026-06-29 14:46:32 +08:00
parent 9a9c508618
commit d9e0324b1d
175 changed files with 17983 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

439
WPFWCSDemo/Schedules/CircleRGV/Check.cs Normal file
View File

@@ -0,0 +1,439 @@
using Serilog;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPFWCSDemo.Common;
using WPFWCSDemo.Data;
using WPFWCSDemo.Models.Devices.CircleRGV;
using WPFWCSDemo.Models.Tables;
using WPFWCSDemo.StateCode;
using WPFWCSDemo.Utilities;
using WPFWCSDemo.ViewModels;
namespace WPFWCSDemo.Schedules.CircleRGV
{
/// <summary>
/// 任务校验
/// </summary>
public class Check
{
static int deviceCount = RGVStation.RGVCount;
/// <summary>
/// 生成【空托】任务条件校验
/// </summary>
/// <param name="sourceLocation">源站点（可表示某条输送线）</param>
/// <param name="targetLocation">目标站点（可表示某条输送线）</param>
/// <param name="isNotException">输送口是否正常 true-系统正常 false-系统异常</param>
/// <returns>是否满足生成任务条件 true-可生成 false-禁止生成</returns>
public static bool CanTaskGenerated(int sourceLocation, int targetLocation, bool isNotException)
{
//校验---源站点请求
if (QueryForIsRequestReset(sourceLocation, 3)) return false;
//校验---目标站点请求
if (QueryForIsRequestReset(targetLocation, 3)) return false;
//校验---系统异常
if (!isNotException) return false;
//校验---同输送口相邻任务生成时间间隔过短
if (!CheckSendTaskTimeInterval(targetLocation, 999)) return false;
//校验---如果已经存在处于【取货阶段】的某个【空托】任务
//由于【空托任务】输送线的源站点唯一，因此必须等待该任务取货完成才能生成新的【空托】任务
if (!IsPalletConvHasGettingTask()) return false;
//校验---当前输送线存在【空托】任务
if (!GetRGVTaskForPalletsIsExist(targetLocation)) return false;
//校验5.当前同一【目标站点】是否已经生成任务
if (!CheckSendTaskIsRepeat(sourceLocation, TaskType.Pallet)) return false;
//校验---上位是否手动禁止生成
if (LineTaskForPermission(targetLocation) == 0) return false;
return true;
}
/// <summary>
/// 生成【实垛】任务校验条件
/// </summary>
/// <param name="sourceLocation">源站点（可表示某条输送线）</param>
/// <param name="isNotException">输送口是否正常 true-系统正常 false-系统异常</param>
/// <returns>是否满足生成任务条件 true-可生成 false-禁止生成</returns>
public static bool CanTaskGenerated(int sourceLocation, bool isNotException)
{
//校验0 放货口无允许
//2025.9新增
//1003-1009输送口校验
if (sourceLocation == RGVStation.LineM_Goods_In)
{
if (QueryForIsRequestReset(RGVStation.LineToWarehouse1_Out, 3)) return false;
}
//2025.9新增
//1005-1010输送口校验
if (sourceLocation == RGVStation.LineL_Goods_In)
{
if (QueryForIsRequestReset(RGVStation.LineToWarehouse2_Out, 3)) return false;
}
//校验1.输送口无请求
if (QueryForIsRequestReset(sourceLocation, 3)) return false;
//校验2.输送口系统异常
if (!isNotException) return false;
//校验3.同输送口相邻任务生成时间间隔过短
if (!CheckSendTaskTimeInterval(sourceLocation)) return false;
//校验4.当前输送线存在取货阶段的任务
if (!GetRGVTaskForGoodsIsExist(sourceLocation)) return false;
//校验5.当前同一【源站点】是否已经生成【取货阶段】任务
if (!CheckSendTaskIsRepeat(sourceLocation, TaskType.Goods)) return false;
return true;
}
/// <summary>
/// 防错机制【用于避免请求延迟的重复下发】--- 检测上一条【实垛】任务放货时间与当前时间是否相差x秒以上
/// </summary>
/// <param name="location">站点</param>
/// <returns> true-相差大于x秒 false-相差小于x秒</returns>
public static bool CheckSendTaskTimeInterval(int location)
{
int diff = -15;
using var context = new AppDbContext();
var loadedState = context
.Set<LoadedState>()
.Where(t => t.Station == location)
.FirstOrDefault();
if (DateTime.Now.AddSeconds(diff) >= loadedState!.LoadingTime)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 防错机制【用于避免请求延迟的重复下发】--- 检测上一条【空托】任务放货时间(完成时间)与当前时间是否相差x秒以上
/// </summary>
/// <param name="location">站点</param>
/// <returns> true-相差大于x秒 false-相差小于x秒</returns>
public static bool CheckSendTaskTimeInterval(int location, int num)
{
int diff = -30;
using var context = new AppDbContext();
var loadedState = context
.Set<LoadedState>()
.Where(t => t.Station == location)
.FirstOrDefault();
if (DateTime.Now.AddSeconds(diff) >= loadedState!.PuttingTime)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 防错机制【重复下发】--- 检测已经生成但未下发的任务是否存在
/// </summary>
/// <param name="sourceLocation">源站点</param>
/// <returns> true-同目标站点生成任务时间间隔合法 false-时间间隔过短</returns>
public static bool CheckSendTaskIsRepeat(int location, int type)
{
using var context = new AppDbContext();
//实垛
if (type == TaskType.Goods)
{
//生成的上一条【实垛】任务且同一个源站点 ---> 查找符合条件的记录
var count = context
.Set<TaskRT>()
.Where(t => t.SourceLocation == location.ToString() && (t.ScheduleState==ScheduleStateCode.Trans_CircleRGV_Ready || t.ScheduleState == ScheduleStateCode.Trans_CircleRGV_Picking))
.Count();
if (count < 1)
{
return true;
}
}
//空托
if (type == TaskType.Pallet)
{
//生成的上一条【空托】任务且同一个目标站点 ---> 查找符合条件的记录
var count1 = context
.Set<TaskRT>()
.Where(t => t.TargetLocation == location.ToString())
.Count();
if (count1 < 1)
{
return true;
}
}
return false;
}
/// <summary>
/// 计算某个输送口请求的值的和---用于确定该输送口在一定时间内请求是否已经复位
/// 用于避免信号也许存在的不稳定(跳变)的情况
/// </summary>
/// <param name="Location">源站点/目标站点---表示对应列</param>
/// <param name="count">计算的时间间隔（单位：秒）</param>
/// <returns>true-无请求---已复位 false-请求存在-未复位</returns>
public static bool QueryForIsRequestReset(int location, int count)
{
var context = new AppDbContext();
string s = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
var timeIsExist = context.ConvRequest
.Where(a => a.Time == s)
.Count();
if (timeIsExist == 0) { return false; }
string line = "";
switch (location)
{
case RGVStation.LineH_Goods_In:
line = "Conv_Goods_In_1001";
break;
case RGVStation.LineM_Goods_In:
line = "Conv_Goods_In_1003";
break;
case RGVStation.LineL_Goods_In:
line = "Conv_Goods_In_1005";
break;
case RGVStation.LineG1_Goods_In:
line = "Conv_Goods_In_1007";
break;
case RGVStation.LineG2_Goods_In:
line = "Conv_Goods_In_1008";
break;
case RGVStation.LineGH_Pallets_In:
line = "Conv_Pallets_In_1013";
break;
case RGVStation.LineH_Pallets_Out:
line = "Conv_Pallets_Out_1002";
break;
case RGVStation.LineG_Pallets_Out:
line = "Conv_Pallets_Out_1004";
break;
case RGVStation.LineLM_Pallets_Out:
line = "Conv_Pallets_Out_1006";
break;
case RGVStation.LineToWarehouse1_Out:
line = "Conv_Goods_Out_1009";
break;
case RGVStation.LineToWarehouse2_Out:
line = "Conv_Goods_Out_1010";
break;
}
if (string.IsNullOrEmpty(line))
{
return false;
}
//获取当前时间节点前x行请求记录值
using DataTable? dt = SqlHelper.ExecuteTable($"SELECT TOP {count} * FROM CONVREQUEST ORDER BY [time] DESC");
//无结果则返回
if (dt is null || dt.Rows.Count == 0)
{
return false;
}
int sum = 0;
//计算源站点对应某列3行请求（允许）值的和
for (int i = 0; i < dt.Rows.Count; i++)
{
sum += (int)dt.Rows[i][line];
}
if (sum == 0)
{
//为0---无请求
return true;
}
else
{
//不等于0，请求存在或存在值跳变情况
return false;
}
}
/// <summary>
/// 手动禁止某条输送线下发任务（根据名称）
/// </summary>
/// <param name="name">输送线名称</param>
/// <returns>0-禁止 1-允许</returns>
public static int LineTaskForPermission(string name)
{
using var context = new AppDbContext();
var lineState = context.LineState
.Where(p => p.Name == name)
.Select(p => p.IsEnable)
.FirstOrDefault();
return lineState;
}
/// <summary>
/// 手动禁止某条输送线下发任务（根据目标站）
/// </summary>
/// <param name="source">源站点</param>
/// <returns>0-禁止 1-允许</returns>
public static int LineTaskForPermission(int target)
{
using var context = new AppDbContext();
var lineState = context.LineState
.Where(p => p.Target == target)
.Select(p => p.IsEnable)
.FirstOrDefault();
return lineState;
}
/// <summary>
/// 遍历环穿是否有某条输送线正在执行的(栈板)任务---即只要有该输送口的任务则不能生成新任务
/// 判断条件 1.站点 2.执行阶段 3.允许下发
/// (该方法会直接读取小车参数)
/// </summary>
/// <param name="sourceLocation">源站点(1至2位编号)</param>
/// <returns>false-存在执行中的任务的设备 true-无在执行任务的设备</returns>
public static bool GetRGVTaskForPalletsIsExist(int targetLocation)
{
List<CircleRGVState>? states = CircleRGVsViewModel.GetAllCircleRGVState();
if (states is null) return false;
//检查是否有符合条件的小车，如果有则标
//【源站点】匹配
// 任务处于【取货阶段】
// 无【允许下发】---表示小车在工作中
var count = states
.Where(a => a.Read_TargetLocation == (targetLocation - 1000).ToString() && !a.Read_Permission)
.Count();
if (count > 0)
{
return false;
}
//无满足条件的小车则表示所有设备无此任务
return true;
}
/// <summary>
/// 遍历环穿是否有某条输送线正在执行的(实垛)任务---某站点输送线存在【取货阶段】任务时不能生成新任务
/// 判断条件：
/// 1.站点匹配
/// 2.执行阶段--->取货阶段
/// 3.允许下发
/// (该方法会直接从地面站读取小车参数)
/// </summary>
/// <param name="sourceLocation">源站点(1至2位编号)</param>
/// <returns>false-存在执行任务的设备（不能下发） true-无执行中的任务的设备（可下发）</returns>
public static bool GetRGVTaskForGoodsIsExist(int sourceLocation)
{
List<CircleRGVState> states = CircleRGVsViewModel.GetAllCircleRGVState();
if (states is null) return false;
//检查是否有符合条件的小车，如果有则标
//【源站点】匹配
// 任务处于【取货阶段】
// 无【允许下发】---表示小车在工作中
var count = states
.Where(a => a.Read_SourceLocation == (sourceLocation - 1000).ToString() && a.Read_Phase < 3 && a.Read_Phase > 0 && !a.Read_Permission)
.Count();
if (count > 0)
{
return false;
}
//无满足条件的小车则表示所有设备无此任务
return true;
}
/// <summary>
/// 检查是否存在已经生成的处于【取货阶段】的【栈板】任务 --- 源站点每次请求仅生成一条任务
/// </summary>
/// <returns>true-无符合条件的任务(即可生成新任务) false-存在符合条件的任务</returns>
public static bool IsPalletConvHasGettingTask()
{
var context = new AppDbContext();
var count =context.Tasks
.Where(a=>a.SourceLocation == RGVStation.LineGH_Pallets_In.ToString() &&
(a.ScheduleState == ScheduleStateCode.Trans_CircleRGV_Ready ||
a.ScheduleState == ScheduleStateCode.Trans_CircleRGV_PickOnTheWay ||
a.ScheduleState == ScheduleStateCode.Trans_CircleRGV_Picking))
.Count();
if (count > 0)
{
return false;
}
return true;
}
}
}

44
WPFWCSDemo/Schedules/CircleRGV/CircleRGVSchedule.cs Normal file
View File

@@ -0,0 +1,44 @@
using Quartz;
using Serilog;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using WPFWCSDemo.Utilities;
namespace WPFWCSDemo.Schedules.CircleRGV
{
[DisallowConcurrentExecution]
public class CircleRGVSchedule : IJob
{
public async Task Execute(IJobExecutionContext context)
{
//Application.Current.Dispatcher.InvokeAsync(() =>
//{
await Task.Run(async () =>
{
bool b = await CommonTask.Common.GetPingForRGVStation("192.168.6.100");
if (b)
{
await Update.UpdateDeviceNumber();
await Update.UpdateScheduleState();
Excute.ExecuteTask();
Generate.GenerateTask();
// //Log.Information($"-----------------设备调度-----------------");
}
});
//});
//return Task.CompletedTask;
}
}
}

110
WPFWCSDemo/Schedules/CircleRGV/Excute.cs Normal file
View File

@@ -0,0 +1,110 @@
using Newtonsoft.Json;
using Quartz;
using Serilog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPFWCSDemo.Data;
using WPFWCSDemo.Models.Devices.CircleRGVStation;
using WPFWCSDemo.Models.Tables;
using WPFWCSDemo.StateCode;
using WPFWCSDemo.ViewModels;
namespace WPFWCSDemo.Schedules.CircleRGV
{
/// <summary>
/// 执行任务调度
/// </summary>
[DisallowConcurrentExecution]
public class Excute
{
static int count1;
static int count2;
/// <summary>
/// 执行任务
/// </summary>
public static void ExecuteTask()
{
//获取所有输送口请求状态
CircleRGVStationState? circleRGVStationState = CircleRGVsViewModel.GetCircleRGVStaionState();
//地面站对象是否为空
if (circleRGVStationState is null)
{
count1 += 1;
if (count1 >= 15)
{
Log.Warning($"【WCS<下发任务>获取输送口参数失败】地面站参数对象:null({count1})！");
}
return;
}
//下发任务前判断地面站【允许下发】
if (circleRGVStationState.Read_Permission == 0)
{
count2 += 1;
if (count2 >= 15)
{
Log.Warning($"【WCS<下发任务>失败】地面站【禁止下发】({count2})！");
Log.Warning($"【WCS<下发任务>失败】地面站参数:({JsonConvert.SerializeObject(circleRGVStationState)})！");
//using SiemensS7Net siemens = new SiemensS7Net(SiemensPLCS.S1500, "192.168.6.100");
//siemens.ConnectServer();
//Log.Warning($"【WCS<下发任务>失败】地面站创建新对象测试读写是否成功：({siemens.ReadInt16("DB611.0").IsSuccess})！");
//Log.Warning($"【WCS<下发任务>失败】地面站创建新对象测试读写是否成功：({siemens.ReadInt16("DB611.0").Message})！");
//Log.Warning($"【WCS<下发任务>失败】地面站创建新对象测试读写值，允许下发：({siemens.ReadInt16("DB611.0").Content},AB供栈请求：{siemens.ReadInt16("DB2100.3.1").Content})！");
}
return;
}
count1 = 0;
count2 = 0;
using var context = new AppDbContext();
TaskRT? taskRT = context.Tasks
.OrderBy(t => t.CreateTime)
.FirstOrDefault(t => t.TaskState == TaskStateCode.Task_Ready && t.ScheduleState == ScheduleStateCode.Trans_CircleRGV_Ready);
if (taskRT == null) return;
CircleRGVStationCommand? circleRGVStationCommand = new CircleRGVStationCommand()
{
Write_DeviceNumber = 0,
Write_TaskType = int.Parse(taskRT.TaskType.ToString()[..1]),
Write_TaskNumber = int.Parse(taskRT.TaskId),
Write_SourceLocation = int.Parse(taskRT.SourceLocation!),
Write_TargetLocation = int.Parse(taskRT.TargetLocation!),
Write_SendFinish = 0,
};
//circleRGVStationCommand.Write_Checksum = Checksum.GetChecksum(circleRGVStationCommand);
bool b = CircleRGVsViewModel.SendRGVStationCommand(circleRGVStationCommand);
if (b)
{
taskRT.TaskState = TaskStateCode.Task_Running;
taskRT.ScheduleTime = DateTime.Now;
context.SaveChanges();
//Log.Information($"【WCS更新任务状态】任务号:{taskRT.TaskId}环穿下发完成，等待设备执行");
}
else
{
//Log.Warning($"【WCS更新任务状态】任务号:{taskRT.TaskId}环穿下发失败");
}
}
}
}

217
WPFWCSDemo/Schedules/CircleRGV/Generate.cs Normal file
View File

@@ -0,0 +1,217 @@
using Quartz;
using Serilog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPFWCSDemo.Common;
using WPFWCSDemo.Data;
using WPFWCSDemo.Models.Devices.CircleRGV;
using WPFWCSDemo.Models.Devices.CircleRGVStation;
using WPFWCSDemo.Models.Tables;
using WPFWCSDemo.StateCode;
using WPFWCSDemo.Utilities;
using WPFWCSDemo.ViewModels;
namespace WPFWCSDemo.Schedules.CircleRGV
{
/// <summary>
/// 生成任务
/// </summary>
[DisallowConcurrentExecution]
public class Generate
{
private static int count = 0;
public static void GenerateTask()
{
//获取所有输送口请求状态
CircleRGVStationState? circleRGVStationState = CircleRGVsViewModel.GetCircleRGVStaionState();
//地面站对象是否为空
if (circleRGVStationState is null)
{
count += 1;
if (count >= 30)
{
//Log.Warning($"【WCS<生成任务>获取输送口参数失败】地面站参数对象:null({count})！");
}
return;
}
count = 0;
//------------------------------------1001有出实垛请求------------------------------------
//------------------------------------1001有出实垛请求------------------------------------
if (Check.CanTaskGenerated(RGVStation.LineH_Goods_In, circleRGVStationState.Read_IsNotException_1001) && circleRGVStationState.Read_GetRequest_1001)
{
//检查该放货口是否由上位手动禁止生成任务
if (Check.LineTaskForPermission(RGVStation.LineH_Goods_Out) == 1)
{
InsertTask(RGVStation.LineH_Goods_In, RGVStation.LineH_Goods_Out, TaskType.Goods);
}
}
//****************************************************【2025.09修改】增加9#、10#立库入口****************************************************
//****************************************************【2025.09修改】增加9#、10#立库入口****************************************************
//****************************************************【2025.09修改】增加9#、10#立库入口****************************************************
//------------------------------------1003有出实垛请求------------------------------------
//------------------------------------1003有出实垛请求------------------------------------
if (circleRGVStationState.Read_GetRequest_1003 &&
circleRGVStationState.Read_PutRequest_1009 &&
Check.CanTaskGenerated(RGVStation.LineM_Goods_In, circleRGVStationState.Read_IsNotException_1003))
{
if (Check.LineTaskForPermission(RGVStation.LineToWarehouse1_Out) == 1)
{
InsertTask(RGVStation.LineM_Goods_In, RGVStation.LineToWarehouse1_Out, TaskType.Goods);
}
}
//------------------------------------1005有出实垛请求------------------------------------
//------------------------------------1005有出实垛请求------------------------------------
if (circleRGVStationState.Read_GetRequest_1005 &&
circleRGVStationState.Read_PutRequest_1010 &&
Check.CanTaskGenerated(RGVStation.LineL_Goods_In, circleRGVStationState.Read_IsNotException_1005))
{
if (Check.LineTaskForPermission(RGVStation.LineToWarehouse2_Out) == 1)
{
InsertTask(RGVStation.LineL_Goods_In, RGVStation.LineToWarehouse2_Out, TaskType.Goods);
}
}
//------------------------------------1007有出实垛请求------------------------------------
//------------------------------------1007有出实垛请求------------------------------------
if (Check.CanTaskGenerated(RGVStation.LineG1_Goods_In, circleRGVStationState.Read_IsNotException_1007) && circleRGVStationState.Read_GetRequest_1007)
{
//检查该放货口是否由上位手动禁止生成任务
if (Check.LineTaskForPermission(RGVStation.LineG_Goods_Out) == 1)
{
InsertTask(RGVStation.LineG1_Goods_In, RGVStation.LineG_Goods_Out, TaskType.Goods);
}
}
//------------------------------------1008有出实垛请求------------------------------------
//------------------------------------1008有出实垛请求------------------------------------
if (Check.CanTaskGenerated(RGVStation.LineG2_Goods_In, circleRGVStationState.Read_IsNotException_1008) && circleRGVStationState.Read_GetRequest_1008)
{
//检查该放货口是否由上位手动禁止生成任务
if (Check.LineTaskForPermission(RGVStation.LineG_Goods_Out) == 1)
{
InsertTask(RGVStation.LineG2_Goods_In, RGVStation.LineG_Goods_Out, TaskType.Goods);
}
}
//------------------------------------1006有回空托请求------------------------------------
if (circleRGVStationState.Read_PutRequest_1006 &&
circleRGVStationState.Read_GetRequest_1013 &&
Check.CanTaskGenerated(RGVStation.LineGH_Pallets_In, RGVStation.LineLM_Pallets_Out, circleRGVStationState.Read_IsNotException_1006))
{
InsertTask(RGVStation.LineGH_Pallets_In, RGVStation.LineLM_Pallets_Out, TaskType.Pallet);
}
//------------------------------------1004有回空托请求------------------------------------
if (circleRGVStationState.Read_PutRequest_1004 &&
circleRGVStationState.Read_GetRequest_1013 &&
Check.CanTaskGenerated(RGVStation.LineGH_Pallets_In, RGVStation.LineG_Pallets_Out, circleRGVStationState.Read_IsNotException_1004))
{
InsertTask(RGVStation.LineGH_Pallets_In, RGVStation.LineG_Pallets_Out, TaskType.Pallet);
}
//------------------------------------1002有空托请求------------------------------------
if (circleRGVStationState.Read_PutRequest_1002 &&
circleRGVStationState.Read_GetRequest_1013 &&
Check.CanTaskGenerated(RGVStation.LineGH_Pallets_In, RGVStation.LineH_Pallets_Out, circleRGVStationState.Read_IsNotException_1002))
{
InsertTask(RGVStation.LineGH_Pallets_In, RGVStation.LineH_Pallets_Out, TaskType.Pallet);
}
}
/// <summary>
/// 插入一条新任务
/// </summary>
/// <param name="sourceLocation">源站点</param>
/// <param name="taskType">任务类型 10-实垛 11-空托</param>
public static void InsertTask(int sourceLocation,int targetLocation, int taskType)
{
using var context = new AppDbContext();
int taskNumber = SqlHelper.GetTaskIdByAutoGeneration();
string type = "";
if (taskType == TaskType.Goods) type = "<实垛>";
if (taskType == TaskType.Pallet) type = "<空托>";
try
{
TaskRT taskRT = new TaskRT()
{
TaskId = taskNumber.ToString(),
TaskType = taskType,
TaskState = TaskStateCode.Task_Ready,
ScheduleState = ScheduleStateCode.Trans_CircleRGV_Ready,
SourceLocation = sourceLocation.ToString(),
TargetLocation = targetLocation.ToString(),
CreateTime = DateTime.Now,
};
context.Tasks.Add(taskRT);
if (sourceLocation == RGVStation.LineGH_Pallets_In)
{
//更新取货状态---计算【空托】线相同输送口前后任务的间隔时间---用于避免生成重复任务
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station == targetLocation);
loadedState.GenerationTime = DateTime.Now;
context.SaveChanges();
}
else
{
//更新取货状态---计算【实垛】线相同输送口前后任务的间隔时间---用于避免生成重复任务
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station == sourceLocation);
loadedState.GenerationTime = DateTime.Now;
context.SaveChanges();
}
}
catch (Exception e)
{
Log.Warning($"【WCS生成{type}任务异常】任务号:{taskNumber}，{e.Message}");
Log.Warning($"【WCS生成{type}任务异常】任务号:{taskNumber}，{e.InnerException}");
return;
}
Log.Information($"【WCS生成{type}任务】任务号:{taskNumber},取货站点:{sourceLocation},放货站点:{targetLocation}");
}
}
}

191
WPFWCSDemo/Schedules/CircleRGV/Update.cs Normal file
View File

@@ -0,0 +1,191 @@
using Quartz;
using Serilog;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reactive.Concurrency;
using System.Text;
using System.Threading.Tasks;
using WPFWCSDemo.Common;
using WPFWCSDemo.Data;
using WPFWCSDemo.Models.Devices.CircleRGV;
using WPFWCSDemo.Models.Tables;
using WPFWCSDemo.StateCode;
using WPFWCSDemo.ViewModels;
namespace WPFWCSDemo.Schedules.CircleRGV
{
/// <summary>
/// 更新任务调度
/// </summary>
public class Update
{
static int deviceCount = RGVStation.RGVCount;
/// <summary>
/// 根据任务号获取正在执行任务环穿的编号
/// </summary>
public static Task UpdateDeviceNumber()
{
//根据任务号获取正在执行任务环穿的编号
for (int j = 1; j <= deviceCount; j++)
{
using CircleRGVState? circleRGVState = CircleRGVsViewModel.GetCircleRGVState(j);
if (circleRGVState == null) continue;
//有【允许下发】则表示无任务小车---跳过
if (circleRGVState.Read_Permission) continue;
using var context = new AppDbContext();
TaskRT? taskRT = context.Tasks.
FirstOrDefault(t => t.TaskId == circleRGVState.Read_TaskNumber.ToString());
if (taskRT == null) continue;
taskRT.JobId = j.ToString();
context.SaveChanges();
}
return Task.CompletedTask;
}
/// <summary>
/// 根据【执行阶段】实时更新环穿【调度状态】
/// </summary>
public static Task UpdateScheduleState()
{
for (int i = 1; i <= deviceCount; i++)
{
using CircleRGVState? circleRGVState = CircleRGVsViewModel.GetCircleRGVState(i);
if (circleRGVState == null) continue;
using var context = new AppDbContext();
//获取执行中的任务
TaskRT? taskRT = context.Tasks
.FirstOrDefault(t => t.TaskId == circleRGVState.Read_TaskNumber.ToString() && t.TaskState == TaskStateCode.Task_Running);
if (taskRT is null) continue;
//有【允许下发】
//if (circleRGVState.Read_Permission) continue;
//无【允许下发】---表示小车有执行中的任务
switch (circleRGVState.Read_Phase)
{
case 1:
if (taskRT.ScheduleState == ScheduleStateCode.Trans_CircleRGV_Ready && !circleRGVState.Read_Permission)
{
taskRT.ScheduleState = ScheduleStateCode.Trans_CircleRGV_PickOnTheWay;
if (context.SaveChanges() == 1) Log.Information($"【WCS更新调度状态】任务号:{circleRGVState.Read_TaskNumber}--->取货途中");
}
continue;
case 2:
if (taskRT.ScheduleState != ScheduleStateCode.Trans_CircleRGV_Picking && !circleRGVState.Read_Permission)
{
taskRT.ScheduleState = ScheduleStateCode.Trans_CircleRGV_Picking;
if (context.SaveChanges() == 1) Log.Information($"【WCS更新调度状态】任务号:{circleRGVState.Read_TaskNumber}--->取货中");
//更新取货时间
if (taskRT.TaskType == TaskType.Goods)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.SourceLocation);
loadedState!.LoadingTime = DateTime.Now;
}
if (taskRT.TaskType == TaskType.Pallet)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.TargetLocation);
loadedState!.LoadingTime = DateTime.Now;
}
context.SaveChanges();
}
continue;
case 3:
if (taskRT.ScheduleState != ScheduleStateCode.Trans_CircleRGV_PutOnTheWay && !circleRGVState.Read_Permission)
{
taskRT.ScheduleState = ScheduleStateCode.Trans_CircleRGV_PutOnTheWay;
taskRT.JobId = i.ToString();
if (context.SaveChanges() == 1) Log.Information($"【WCS更新调度状态】任务号:{circleRGVState.Read_TaskNumber}--->放货途中");
//更新取货时间
if (taskRT.TaskType == TaskType.Goods)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.SourceLocation);
loadedState!.LoadedTime = DateTime.Now;
}
if (taskRT.TaskType == TaskType.Pallet)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.TargetLocation);
loadedState!.LoadedTime = DateTime.Now;
}
context.SaveChanges();
}
continue;
case 4:
if (taskRT.ScheduleState != ScheduleStateCode.Trans_CircleRGV_Putting && !circleRGVState.Read_Permission)
{
taskRT.ScheduleState = ScheduleStateCode.Trans_CircleRGV_Putting;
if (context.SaveChanges() == 1) Log.Information($"【WCS更新调度状态】任务号:{circleRGVState.Read_TaskNumber}--->放货中");
//更新取货时间
if (taskRT.TaskType == TaskType.Goods)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.SourceLocation);
loadedState!.PuttingTime = DateTime.Now;
}
if (taskRT.TaskType == TaskType.Pallet)
{
var loadedState = context.LoadedState
.FirstOrDefault(s => s.Station.ToString() == taskRT.TargetLocation);
loadedState!.PuttingTime = DateTime.Now;
}
context.SaveChanges();
}
continue;
case 5:
if (taskRT.ScheduleState != ScheduleStateCode.Trans_CircleRGV_Ready)
{
taskRT.ScheduleState = ScheduleStateCode.Trans_CircleRGV_Finish;
if (context.SaveChanges() == 1) Log.Information($"【WCS更新调度状态】任务号:{circleRGVState.Read_TaskNumber}--->放货完成");
}
continue;
}
}
return Task.CompletedTask;
}
}
}