icewint/wcs_server_kate_suzhou
5
2
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

<fix>[normal]修改部分函数为主构造函数

Browse Source
This commit is contained in:
葛林强 2024-06-19 16:51:35 +08:00
parent e1d3acd92a
commit acd744e046
27 changed files with 233 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
WcsMain/Business/CirculationTask/CommonCirculation/ConnectPlcWithCirculation.cs
View File

@ -10,7 +10,6 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation]
public class ConnectPlcWithCirculation(ConnectPLCs connectPLCs)
{
private readonly ConnectPLCs _connectPLCs = connectPLCs;
/// <summary>
/// 当plc断开时重新连接 PLC
@ -23,7 +22,7 @@ public class ConnectPlcWithCirculation(ConnectPLCs connectPLCs)
{
// 如果处于未连接的状态则需要连接
/* 连接 PLC */
bool isContinue = _connectPLCs.ConnectPlc();
bool isContinue = connectPLCs.ConnectPlc();
if (!isContinue)
{
return false; // 没有需要连接PLC可能，不需要接着继续检测了

15
WcsMain/Business/CirculationTask/CommonCirculation/DataClear.cs
View File

@ -9,7 +9,6 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation("数据清理")]
public class DataClear(ClearData clearData)
{
private readonly ClearData _clearData = clearData;
/// <summary>
/// 定时清理无用数据, ---- 每隔10分钟清理一次
@ -21,31 +20,31 @@ public class DataClear(ClearData clearData)
try
{
// 清理接口接收记录表 -- 保留多少天
int apiAcceptCount = _clearData.ClearApiAcceptData(30);
int apiAcceptCount = clearData.ClearApiAcceptData(30);
ConsoleLog.Tip(apiAcceptCount > 0, $"[数据清理]接口接收记录：{apiAcceptCount}");
// 清理日志文件 -- 清理多少天之前
int logCount = _clearData.ClearLogFile(60);
int logCount = clearData.ClearLogFile(60);
ConsoleLog.Tip(logCount > 0, $"[数据清理]日志文件：{logCount}");
// 清理接口请求记录表 -- 保留多少天
int apiRequestCount = _clearData.ClearApiRequestData(30);
int apiRequestCount = clearData.ClearApiRequestData(30);
ConsoleLog.Tip(apiRequestCount > 0, $"[数据清理]接口请求记录：{apiRequestCount}");
// 清理WCS任务备份表 -- 保留多少天
int apiWcsTaskCount = _clearData.ClearWcsTaskData(30);
int apiWcsTaskCount = clearData.ClearWcsTaskData(30);
ConsoleLog.Tip(apiWcsTaskCount > 0, $"[数据清理]WCS任务备份记录：{apiWcsTaskCount}");
// 清理WMS任务表 -- 保留多少天
int apiWmsTaskCount = _clearData.ClearWmsTaskData(30);
int apiWmsTaskCount = clearData.ClearWmsTaskData(30);
ConsoleLog.Tip(apiWmsTaskCount > 0, $"[数据清理]WMS任务记录：{apiWmsTaskCount}");
// 清理电子标签任务
int clearElTagCount = _clearData.ClearElTagTaskData(30);
int clearElTagCount = clearData.ClearElTagTaskData(30);
ConsoleLog.Tip(clearElTagCount > 0, $"[数据清理]电子标签任务记录：{apiWmsTaskCount}");
int clearConveyTaskCount = _clearData.ClearConveyTaskData(30);
int clearConveyTaskCount = clearData.ClearConveyTaskData(30);
ConsoleLog.Tip(clearConveyTaskCount > 0, $"[数据清理]箱式线任务记录：{apiWmsTaskCount}");
}

3
WcsMain/Business/CirculationTask/CommonCirculation/HeartBeat.cs
View File

@ -6,12 +6,11 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation]
public class HeartBeat(ConveyOperation conveyOperation)
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
[Circulation("输送机心跳", 1000)]
public bool ConveyHeartBeat()
{
_conveyOperation.WriteHeartBeat();
conveyOperation.WriteHeartBeat();
return true;
}

14
WcsMain/Business/CirculationTask/ElTag/LightElTag.cs
View File

@ -16,10 +16,6 @@ namespace WcsMain.Business.CirculationTask.ElTag;
public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation, AppElTagLocationDao elTagBaseDao)
{
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly AtopOperation _atopOperation = atopOperation;
private readonly AppElTagLocationDao _elTagBaseDao = elTagBaseDao;
/// <summary>
/// 点亮电子标签
/// </summary>
@ -27,7 +23,7 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
[Circulation("点亮电子标签")]
public bool Light()
{
List<AppElTagTask>? tasks = _tagTaskDao.Query(new AppElTagTask { TaskStatus = (int)ElTagTaskStatusEnum.NeedLight });
List<AppElTagTask>? tasks = tagTaskDao.Query(new AppElTagTask { TaskStatus = (int)ElTagTaskStatusEnum.NeedLight });
if (tasks == default)
{
ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常");
@ -49,7 +45,7 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
if(tagInfo == default)
{
ConsoleLog.Warning($"【警告】电子标签：{tagTask.Location} 不存在，无法点亮");
_tagTaskDao.Update(new AppElTagTask
tagTaskDao.Update(new AppElTagTask
{
TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Error,
@ -71,17 +67,17 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
return LedColor.Red;
};
}).Invoke();
var resultException = _atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum, lEDColor);
var resultException = atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum, lEDColor);
if(resultException == default )
{
ConsoleLog.Success($"点亮电子标签成功，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}");
_tagTaskDao.Update(new AppElTagTask
tagTaskDao.Update(new AppElTagTask
{
TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Lighting,
LightTime = DateTime.Now,
}); // 更新任务状态
_elTagBaseDao.Update(new AppElTagLocation { Location = tagTask.Location, TaskId = tagTask.TaskId, LastLightTime = DateTime.Now }); // 更新点位状态，绑定任务
elTagBaseDao.Update(new AppElTagLocation { Location = tagTask.Location, TaskId = tagTask.TaskId, LastLightTime = DateTime.Now }); // 更新点位状态，绑定任务
return;
}
ConsoleLog.Warning($"【警告】点亮电子标签失败，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}，异常信息：{resultException.Message}");

8
WcsMain/Business/CirculationTask/ElTag/OffElTag.cs
View File

@ -21,10 +21,6 @@ namespace WcsMain.Business.CirculationTask.ElTag;
//[Circulation]
public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
{
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly AtopOperation _atopOperation = atopOperation;
/// <summary>
/// 检验任务组内任务是否全部确认，若全部确认则熄灭所有标签
@ -34,7 +30,7 @@ public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
public bool CheckTaskIsConfirmAll()
{
/* 查询已经确认的任务的任务组 */
List<AppElTagTask>? tasks = _tagTaskDao.QueryRunningTask();
List<AppElTagTask>? tasks = tagTaskDao.QueryRunningTask();
if (tasks == default)
{
ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常");
@ -77,7 +73,7 @@ public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
}
}
if (offTasks.Count < 1) return;
_tagTaskDao.Update([.. offTasks]); // 更新状态为熄灭
tagTaskDao.Update([.. offTasks]); // 更新状态为熄灭
}

1
WcsMain/Business/CirculationTask/ScanMethod.cs
View File

@ -8,7 +8,6 @@ namespace WcsMain.Business.CirculationTask;
//[Circulation]
public class ScanMethod(DataBaseData dataBaseData)
{
private readonly DataBaseData _dataBaseData = dataBaseData;
//private static string[]? _scanId;

28
WcsMain/Business/CirculationTask/Stacker/CheckAccount.cs
View File

@ -16,10 +16,6 @@ namespace WcsMain.Business.CirculationTask.Stacker;
[Circulation()]
public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent)
{
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
/// <summary>
/// PLC过账
/// </summary>
@ -28,7 +24,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
public bool CheckAccountTask()
{
var openStackers = CommonData.AppStackers.Open(); // 只获取开放的堆垛机
List<TaskFeedBackEntity>? taskFeedBackEntities = _stackerOperation.GetTaskFeedBackData(20, openStackers);
List<TaskFeedBackEntity>? taskFeedBackEntities = stackerOperation.GetTaskFeedBackData(20, openStackers);
if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1)
{
return true;
@ -36,7 +32,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities)
{
if (taskFeedBackEntity.PlcId == 0) { continue; }
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】堆垛机过账查询任务数据失败，和数据库服务器连接中断");
@ -46,7 +42,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
if (wcsTasks.Count < 1)
{
ConsoleLog.Warning($"【提示】堆垛机过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务");
_stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
continue; // 任务无数据
}
var wcsTask = wcsTasks[0];
@ -80,13 +76,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Warning($"【提示】过账区反馈：PlcId：{taskFeedBackEntity.PlcId} 已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
string? cleanAccountErr = stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"【警告】取消任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务异常动作 */
_wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
}
@ -98,13 +94,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Tip($"【提示】过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}");
var cleanAccountErr = _stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
var cleanAccountErr = stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"【警告】完成任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务完成动作 */
_wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
}
@ -117,13 +113,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void DoubleInFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Warning($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，卸货位置有货，任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
string? cleanAccountErr = stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务异常动作 */
_wcsTaskEvent.DoubleInTaskEvent(wcsTask, "卸货位置有货");
wcsTaskEvent.DoubleInTaskEvent(wcsTask, "卸货位置有货");
}
/// <summary>
@ -134,13 +130,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void EmptyOutFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，取货位置无货，任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
string? cleanAccountErr = stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务异常动作 */
_wcsTaskEvent.EmptyOutTaskEvent(wcsTask, "取货位置无货");
wcsTaskEvent.EmptyOutTaskEvent(wcsTask, "取货位置无货");
}
@ -152,7 +148,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity)
{
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}");
_stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
}

94
WcsMain/Business/CirculationTask/Stacker/ExeTaskDoubleFork.cs
View File

@ -2,7 +2,6 @@
using WcsMain.Business.CommonAction;
using WcsMain.Common;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.MixDao;
using WcsMain.DataBase.TableEntity;
using WcsMain.DataService;
using WcsMain.Enum.Stacker;
@ -10,7 +9,6 @@ using WcsMain.EquipOperation.Convey;
using WcsMain.EquipOperation.Entity.Stacker;
using WcsMain.EquipOperation.Stacker;
using WcsMain.ExtendMethod;
using static Dm.net.buffer.ByteArrayBuffer;
namespace WcsMain.Business.CirculationTask.Stacker;
@ -23,12 +21,6 @@ public class ExeTaskDoubleFork(
StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent,
ConveyOperation conveyOperation, DataBaseData dataBaseData)
{
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
/// <summary>
/// 执行堆垛机任务
/// </summary>
@ -41,7 +33,7 @@ public class ExeTaskDoubleFork(
{
tasks.Add(Task.Factory.StartNew(() =>
{
var stackerUseStatus = _stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int spare1);
var stackerUseStatus = stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int spare1);
if (stackerUseStatus == StackerUseStatusEnum.Free)
{
/* 空闲时正常执行任务 */
@ -82,10 +74,10 @@ public class ExeTaskDoubleFork(
{
if (stackerId == default) return false;
/* 检查入库站台是否允许取货 */
bool allowGetGoods = _conveyOperation.AllGetVehicle(stackerId.ToString());
bool allowGetGoods = conveyOperation.AllGetVehicle(stackerId.ToString());
if(!allowGetGoods) return false; // 入库站台不允许取货
/* 读取入库站台的条码 */
var codes = _conveyOperation.ReadConveyCode(stackerId.ToString());
var codes = conveyOperation.ReadConveyCode(stackerId.ToString());
if(codes == default || codes.Count != 2) return false;
/* 构造任务数据 */
bool isWriteTask = false; // 指示是否写入任务
@ -100,13 +92,13 @@ public class ExeTaskDoubleFork(
if (code == "NoRead") // 检查条码是否为 NoRead
{
/* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString());
bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if(plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1);
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1);
string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if(string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
@ -118,7 +110,7 @@ public class ExeTaskDoubleFork(
}
continue;
}
var wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
var wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if(wcsTasks == default) // 查询任务失败
{
ConsoleLog.Exception($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 查找任务失败，和数据库服务器连接中断");
@ -127,14 +119,14 @@ public class ExeTaskDoubleFork(
if(wcsTasks.Count < 1) // 没有任务
{
/* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString());
bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 没有找到对应任务");
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo());
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1);
string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
@ -152,18 +144,18 @@ public class ExeTaskDoubleFork(
if(destinationLocationInfo == default) // 任务终点错误，理论上此处不应该出现异常
{
/* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString());
bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 无法识别的入库库位");
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo());
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1);
string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "入库库位不正确");
wcsTaskEvent.ErrTaskEvent(wcsTask, "入库库位不正确");
isWriteTask = true;
}
else
@ -173,16 +165,16 @@ public class ExeTaskDoubleFork(
continue;
}
/* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败
if(runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerInTask((int)stackerId!, i + 1, destinationLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1);
string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
isWriteTask = true;
}
else
@ -192,7 +184,7 @@ public class ExeTaskDoubleFork(
}
if (isWriteTask)
{
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机入库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000);
}
@ -208,9 +200,9 @@ public class ExeTaskDoubleFork(
{
if (stackerId == default) return false;
/* 检查出库站台是否可以卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString());
bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) return false; // 出库站台不允许取货
var wcsTasks = _wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Exception(string.Format("【异常】{0} 号堆垛机出库任务查询失败，与数据库连接异常", stackerId));
@ -236,20 +228,20 @@ public class ExeTaskDoubleFork(
if (originLocationInfo == default) // 任务起点错误，理论上此处不应该出现异常
{
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，出库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的出库库位");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "出库的库位不正确");
wcsTaskEvent.ErrTaskEvent(wcsTask, "出库的库位不正确");
continue;
}
/* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(originLocationInfo.InterveneLocation);
var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(originLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败
if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerOutTask((int)stackerId!, i + 1, originLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1);
string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，出库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
writeTaskCount++;
isWriteTask = true;
}
@ -260,7 +252,7 @@ public class ExeTaskDoubleFork(
}
if (isWriteTask)
{
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机出库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000);
}
@ -275,7 +267,7 @@ public class ExeTaskDoubleFork(
public bool ExecutePickTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常");
@ -293,7 +285,7 @@ public class ExeTaskDoubleFork(
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -317,17 +309,17 @@ public class ExeTaskDoubleFork(
Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask);
wcsTaskEvent.StartTaskEvent(wcsTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
@ -341,7 +333,7 @@ public class ExeTaskDoubleFork(
public bool ExecuteMoveTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常");
@ -368,20 +360,20 @@ public class ExeTaskDoubleFork(
if (originLocationInfo == default || destinationLocationInfo == default) // 任务起点终点错误，理论上此处不应该出现异常
{
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，移库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的库位");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "移库的库位不正确");
wcsTaskEvent.ErrTaskEvent(wcsTask, "移库的库位不正确");
continue;
}
/* 判断冲突货位是否有任务，起点终点都要判断 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation, originLocationInfo.InterveneLocation);
var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation, originLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败
if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerMoveTask((int)stackerId!, originLocationInfo, destinationLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1);
string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{
ConsoleLog.Success($"{stackerId} 号堆垛机，移库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
writeTaskCount++;
isWriteTask = true;
}
@ -392,7 +384,7 @@ public class ExeTaskDoubleFork(
}
if (isWriteTask)
{
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机移库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000);
}
@ -411,7 +403,7 @@ public class ExeTaskDoubleFork(
{
if (stackerId == default || plcId == 0) return false;
/* 查找这个PlcId对应的wms任务 */
List<AppWcsTask>? doubleInTasks = _wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
List<AppWcsTask>? doubleInTasks = wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
if (doubleInTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常");
@ -423,7 +415,7 @@ public class ExeTaskDoubleFork(
/* 判断这个任务是否出现卸货位置有货 */
if(doubleTask.TaskStatus != (int)WcsTaskStatusEnum.doubleIn) { return false; } // 没有重复入库不执行下面方法
/* 查找这个任务的新任务 */
List<AppWcsTask>? newTasks = _wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)WcsTaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WcsTaskStatusEnum.create });
List<AppWcsTask>? newTasks = wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)WcsTaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WcsTaskStatusEnum.create });
if (newTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常");
@ -437,26 +429,26 @@ public class ExeTaskDoubleFork(
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常");
_wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
return false;
}
/* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
if (runningWcsTasks == default) return false; // 查询失败
if (runningWcsTasks.Count > 0) return false; // 存在冲突点位，等待
/* 下发任务 */
StackerPlcTask stackerTask = newTask.ToStackerInTask((int)stackerId!, forkId, destinationLocationInfo);
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}");
_wcsTaskEvent.StartTaskEvent(newTask);
wcsTaskEvent.StartTaskEvent(newTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
}

58
WcsMain/Business/CirculationTask/Stacker/ExecuteWcsTask.cs
View File

@ -17,10 +17,6 @@ namespace WcsMain.Business.CirculationTask.Stacker;
//[Circulation(tags: ["stacker"])]
public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent)
{
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
/// <summary>
/// 执行堆垛机任务
/// </summary>
@ -30,7 +26,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
foreach (var stacker in CommonData.AppStackers.Open())
{
var stackerUseStatus = _stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int _);
var stackerUseStatus = stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int _);
if (stackerUseStatus == StackerUseStatusEnum.Free)
{
/* 空闲时正常执行任务 */
@ -69,7 +65,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
private bool ExecuteInTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectInTaskWithStacker((int)stackerId!); // 此处方法内已经判断状态
var wcsTasks = wcsTaskDao.SelectInTaskWithStacker((int)stackerId!); // 此处方法内已经判断状态
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机入库任务查询失败，与数据库连接异常");
@ -87,7 +83,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -111,17 +107,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入入库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask);
wcsTaskEvent.StartTaskEvent(wcsTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入入库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
}
@ -134,7 +130,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecuteOutTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机出库任务查询失败，与数据库连接异常");
@ -152,7 +148,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -176,17 +172,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入出库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask);
wcsTaskEvent.StartTaskEvent(wcsTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入出库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
@ -200,7 +196,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecutePickTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常");
@ -218,7 +214,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -242,17 +238,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask);
wcsTaskEvent.StartTaskEvent(wcsTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
@ -266,7 +262,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecuteMoveTask(int? stackerId)
{
if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
var wcsTasks = wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常");
@ -282,7 +278,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -306,17 +302,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入移库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask);
wcsTaskEvent.StartTaskEvent(wcsTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入移库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
@ -332,7 +328,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
if (stackerId == default || plcId == 0) return false;
/* 查找这个PlcId对应的wms任务 */
List<AppWcsTask>? doubleInTasks = _wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
List<AppWcsTask>? doubleInTasks = wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
if (doubleInTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常");
@ -342,7 +338,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
if (doubleInTasks.Count == 0) return false; // 找不到对应的PlcId的任务
var doubleTask = doubleInTasks[0];
/* 查找这个任务的新任务 */
List<AppWcsTask>? newTasks = _wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)TaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WmsTaskStatusEnum.create });
List<AppWcsTask>? newTasks = wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)TaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WmsTaskStatusEnum.create });
if (newTasks == default)
{
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常");
@ -356,7 +352,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常");
_wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
return false;
}
StackerPlcTask stackerTask = new()
@ -380,17 +376,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(newTask.Weight),
Code = newTask.PlcVehicleNo ?? 0,
};
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask);
var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText))
{
ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}");
_wcsTaskEvent.StartTaskEvent(newTask);
wcsTaskEvent.StartTaskEvent(newTask);
return true;
}
else
{
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
}
return false;
}

19
WcsMain/Business/CirculationTask/StackerConvey/CheckAccount.cs
View File

@ -14,9 +14,6 @@ namespace WcsMain.Business.CirculationTask.StackerConvey;
[Circulation]
public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stackerConveyOperation, WCSTaskExecuteEvent wcsTaskEvent)
{
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly StackerConveyOperation _stackerConveyOperation = stackerConveyOperation;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary>
/// PLC过账
@ -25,12 +22,12 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
[Circulation("监控PLC地址，过账", 1000)]
public bool CheckAccountTask()
{
List<TaskFeedBackEntity>? taskFeedBackEntities = _stackerConveyOperation.GetConveyTaskFeedBackData(20);
List<TaskFeedBackEntity>? taskFeedBackEntities = stackerConveyOperation.GetConveyTaskFeedBackData(20);
if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1) {return true; }
foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities)
{
if (taskFeedBackEntity.PlcId == 0) { continue; }
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
if (wcsTasks == default)
{
ConsoleLog.Error($"【异常】库前输送过账查询任务数据失败，和数据库服务器连接中断");
@ -40,7 +37,7 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
if (wcsTasks.Count < 1)
{
ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务");
_stackerConveyOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
stackerConveyOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
continue; // 任务无数据
}
var wcsTask = wcsTasks[0];
@ -67,13 +64,13 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
string? cleanAccountErr = stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务异常动作 */
_wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
}
@ -84,13 +81,13 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{
ConsoleLog.Tip($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
string? cleanAccountErr = stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr))
{
ConsoleLog.Warning($"[警告]完成任务清除过账区发生异常，信息：{cleanAccountErr}");
}
/* 执行 WMS 任务完成动作 */
_wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
}
@ -102,7 +99,7 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity)
{
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}");
_stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
}
}

27
WcsMain/Business/CirculationTask/TaskData/ResolveWmsTask.cs
View File

@ -18,11 +18,6 @@ namespace WcsMain.Business.CirculationTask.TaskData;
[Circulation()]
public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus, DataBaseData dataBaseData, TaskDao taskDao)
{
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
private readonly TaskDao _taskDao = taskDao;
/// <summary>
/// 解析WMS任务
/// </summary>
@ -30,7 +25,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
[Circulation("解析WMS任务，转换为WCS任务")]
public bool ResolveTask()
{
List<AppWmsTask>? needResolveTask = _wmsTaskDao.Select(new AppWmsTask() { TaskStatus = (int)WmsTaskStatusEnum.create });
List<AppWmsTask>? needResolveTask = wmsTaskDao.Select(new AppWmsTask() { TaskStatus = (int)WmsTaskStatusEnum.create });
if (needResolveTask == default)
{
ConsoleLog.Error("【异常】解析Wms任务时拉取任务列表失败，与数据库连接中断");
@ -52,7 +47,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
bool checkResult = CommonData.AppLocations.ExistWmsLocation(wmsTask.Origin, wmsTask.Destination);
if(!checkResult)
{
_wmsTaskDao.Update(new()
wmsTaskDao.Update(new()
{
TaskId = wmsTask.TaskId,
TaskStatus = (int)WmsTaskStatusEnum.err,
@ -61,7 +56,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
});
if(wmsTask.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskErr(wmsTask.TaskId, "不受支持的起点或终点");
sendWmsTaskStatus.SendTaskErr(wmsTask.TaskId, "不受支持的起点或终点");
}
return;
}
@ -108,7 +103,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if(plcId == default) { return; }
AppWcsTask wcsTask = new()
{
@ -129,7 +124,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now,
};
/* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask);
string? errMessage = taskDao.CreateWcsTask(wcsTask);
if(string.IsNullOrWhiteSpace(errMessage))
{
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -149,7 +144,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; }
AppWcsTask wcsTask = new()
{
@ -169,7 +164,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now,
};
/* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask);
string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage))
{
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -189,7 +184,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; }
AppWcsTask wcsTask = new()
{
@ -209,7 +204,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now,
};
/* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask);
string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage))
{
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -229,7 +224,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId();
int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; }
AppWcsTask wcsTask = new()
{
@ -250,7 +245,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now,
};
/* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask);
string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage))
{
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");

20
WcsMain/Business/CommonAction/ClearData.cs
View File

@ -12,55 +12,47 @@ public class ClearData(AppWmsTaskDao wmsTaskDao, AppWcsTaskDao wcsTaskDao, AppAp
AppApiAcceptDao apiAcceptDao, AppElTagTaskDao elTagTaskDao, AppConveyTaskDao conveyTaskDao)
{
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly AppApiRequestDao _apiRequestDao = apiRequestDao;
private readonly AppApiAcceptDao _apiAcceptDao = apiAcceptDao;
private readonly AppElTagTaskDao _elTagTaskDao = elTagTaskDao;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/* 定时清除 WMS 任务表 */
/// <summary>
/// 清理超过一定时间的 WMS 任务表数据
/// </summary>
/// <param name="days"></param>
public int ClearWmsTaskData(int days) => _wmsTaskDao.ClearData(days);
public int ClearWmsTaskData(int days) => wmsTaskDao.ClearData(days);
/* 定时清除 WCS 任务备份表 */
/// <summary>
/// 清理超过一定天数的 WCS 任务备份表数据
/// </summary>
/// <param name="days"></param>
public int ClearWcsTaskData(int days) => _wcsTaskDao.ClearData(days);
public int ClearWcsTaskData(int days) => wcsTaskDao.ClearData(days);
/* 定时清除接口请求表 */
/// <summary>
/// 清理接口发送信息表
/// </summary>
/// <param name="days"></param>
public int ClearApiRequestData(int days) => _apiRequestDao.ClearData(days);
public int ClearApiRequestData(int days) => apiRequestDao.ClearData(days);
/* 定时清除接口接收表 */
/// <summary>
/// 清理接口接收信息表
/// </summary>
/// <param name="days"></param>
public int ClearApiAcceptData(int days) => _apiAcceptDao.ClearData(days);
public int ClearApiAcceptData(int days) => apiAcceptDao.ClearData(days);
/// <summary>
/// 清理多少天之前的电子标签任务
/// </summary>
/// <param name="days"></param>
/// <returns></returns>
public int ClearElTagTaskData(int days) => _elTagTaskDao.ClearData(days);
public int ClearElTagTaskData(int days) => elTagTaskDao.ClearData(days);
/// <summary>
/// 清理输送线任务
/// </summary>
/// <param name="days"></param>
/// <returns></returns>
public int ClearConveyTaskData(int days) => _conveyTaskDao.ClearData(days);
public int ClearConveyTaskData(int days) => conveyTaskDao.ClearData(days);
/* 定时清除 日志文件 */

22
WcsMain/Business/CommonAction/SendWmsTaskStatus.cs
View File

@ -14,8 +14,6 @@ namespace WcsMain.Business.CommonAction;
[Component]
public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApiPost)
{
private readonly WmsWebApiPost _wmsWebApiPost = wmsWebApiPost;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
/// <summary>
/// 发送 WMS 任务异常
@ -29,7 +27,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++)
{
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default)
{
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -54,7 +52,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
};
for (int i = 1; i <= count; i++)
{
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend)
{
ConsoleLog.Error($"【异常】发送WMS[任务异常]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -87,7 +85,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++)
{
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default)
{
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -112,7 +110,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
};
for (int i = 1; i <= count; i++)
{
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend)
{
ConsoleLog.Error($"【异常】发送WMS[取货位置无货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -145,7 +143,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++)
{
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default)
{
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -170,7 +168,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
};
for (int i = 1; i <= count; i++)
{
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend)
{
ConsoleLog.Error($"【异常】发送WMS[卸货位置有货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -204,7 +202,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++)
{
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default)
{
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -229,7 +227,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
};
for (int i = 1; i <= count; i++)
{
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend)
{
ConsoleLog.Error($"【异常】发送WMS[开始执行]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -262,7 +260,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++)
{
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default)
{
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -287,7 +285,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
};
for (int i = 1; i <= count; i++)
{
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend)
{
ConsoleLog.Error($"【异常】发送WMS[任务完成]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");

28
WcsMain/Business/CommonAction/WCSTaskExecuteEvent.cs
View File

@ -14,10 +14,6 @@ namespace WcsMain.Business.CommonAction;
[Component]
public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskStatus, AppLocationDao locationDao)
{
private readonly AppLocationDao _locationDao = locationDao;
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly TaskDao _taskDao = taskDao;
/// <summary>
/// 任务执行异常触发事件
/// </summary>
@ -25,14 +21,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param>
public void ErrTaskEvent(AppWcsTask task, string errText)
{
string errMsg = _taskDao.TaskErrAndCancelOtherTask(task, errText);
string errMsg = taskDao.TaskErrAndCancelOtherTask(task, errText);
if (!string.IsNullOrEmpty(errMsg))
{
ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
}
if (task.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskErr(task.TaskId, errText);
sendWmsTaskStatus.SendTaskErr(task.TaskId, errText);
}
}
@ -44,14 +40,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param>
public void EmptyOutTaskEvent(AppWcsTask task, string errText)
{
string errMsg = _taskDao.TaskErr(task, errText);
string errMsg = taskDao.TaskErr(task, errText);
if (!string.IsNullOrEmpty(errMsg))
{
ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
}
if (task.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskEmptyOut(task.TaskId);
sendWmsTaskStatus.SendTaskEmptyOut(task.TaskId);
}
}
@ -62,14 +58,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param>
public void DoubleInTaskEvent(AppWcsTask task, string errText)
{
string errMsg = _taskDao.TaskErr(task, errText);
string errMsg = taskDao.TaskErr(task, errText);
if (!string.IsNullOrEmpty(errMsg))
{
ConsoleLog.Error($"【异常】卸货位置有货更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
}
if (task.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskDoubleIn(task.TaskId);
sendWmsTaskStatus.SendTaskDoubleIn(task.TaskId);
}
}
@ -82,14 +78,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="task"></param>
public void StartTaskEvent(AppWcsTask task)
{
string errMsg = _taskDao.StartTask(task);
string errMsg = taskDao.StartTask(task);
if (!string.IsNullOrEmpty(errMsg))
{
ConsoleLog.Error($"【异常】任务开始更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
}
if (task.IsFirstTask() && task.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskStart(task.TaskId);
sendWmsTaskStatus.SendTaskStart(task.TaskId);
}
}
@ -110,7 +106,7 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
private void HandleTaskData(AppWcsTask task, string msg)
{
string errMsg = _taskDao.ComlpeteTask(task, msg);
string errMsg = taskDao.ComlpeteTask(task, msg);
if(!string.IsNullOrEmpty(errMsg))
{
ConsoleLog.Error($"【异常】PlcId：{task.PlcId} 任务完成失败，异常信息：{errMsg}");
@ -130,13 +126,13 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
switch (task.TaskType)
{
case (int)TaskTypeEnum.inTask: // 入库任务
_locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo));
locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo));
break;
case (int)TaskTypeEnum.outTask: // 出库任务
_locationDao.Update(AppLocation.CreateEmptyInstance(task.Origin));
locationDao.Update(AppLocation.CreateEmptyInstance(task.Origin));
break;
case (int)TaskTypeEnum.moveTask: // 移库任务
_locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo), AppLocation.CreateEmptyInstance(task.Origin));
locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo), AppLocation.CreateEmptyInstance(task.Origin));
break;
}
}

7
WcsMain/Business/CommonAction/WMSApiResponseAction.cs
View File

@ -14,9 +14,6 @@ namespace WcsMain.Business.CommonAction;
public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao apiRequestDao)
{
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppApiRequestDao _apiRequestDao = apiRequestDao;
/// <summary>
/// 当请求其他系统时触发本方法
/// </summary>
@ -30,7 +27,7 @@ public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao ap
// 存库
AppApiRequest insertData = new()
{
RequestId = _dataBaseData.GetNewUUID(),
RequestId = dataBaseData.GetNewUUID(),
RequestUrl = responseInfo.RequestUrl,
RequestMethod = responseInfo.RequestMethod,
IsSuccess = responseInfo.IsSend ? 1 : 0,
@ -41,7 +38,7 @@ public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao ap
UseTime = responseInfo.UseTime,
ErrMsg = responseInfo.RequestException?.Message,
};
_apiRequestDao.Insert(insertData);
apiRequestDao.Insert(insertData);
}
catch (Exception ex)
{

16
WcsMain/Business/CommonAction/WmsTaskAction.cs
View File

@ -8,8 +8,6 @@ namespace WcsMain.Business.CommonAction;
[Component]
public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus)
{
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
/// <summary>
/// 重置WMS任务
@ -20,7 +18,7 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns>
public string ResetWmsTaskStatus(string? taskId, string? newDestination, string systemName)
{
string resetErrMessage = _wmsTaskDao.ResetTaskWithTaskId(taskId, newDestination, $"任务被{systemName}重置");
string resetErrMessage = wmsTaskDao.ResetTaskWithTaskId(taskId, newDestination, $"任务被{systemName}重置");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 重置成功
// 重置失败，返回错误信息
return $"重置状态失败：任务号：{taskId}，参考异常信息：{resetErrMessage}";
@ -34,16 +32,16 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns>
public string CompleteWmsTaskStatus(string? taskId, string sysName)
{
List<AppWmsTask>? wmsTasks = _wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
List<AppWmsTask>? wmsTasks = wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
if (wmsTasks != default && wmsTasks.Count > 0)
{
AppWmsTask wmsTask = wmsTasks[0];
if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskComplete(taskId);
sendWmsTaskStatus.SendTaskComplete(taskId);
}
}
string resetErrMessage = _wmsTaskDao.CompleteTaskWithTaskId(taskId, $"【{sysName}】完成");
string resetErrMessage = wmsTaskDao.CompleteTaskWithTaskId(taskId, $"【{sysName}】完成");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 完成成功
return $"完成任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}";
}
@ -56,16 +54,16 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns>
public string DeleteWmsTaskStatus(string? taskId, string sysName)
{
List<AppWmsTask>? wmsTasks = _wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
List<AppWmsTask>? wmsTasks = wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
if (wmsTasks != default && wmsTasks.Count > 0)
{
AppWmsTask wmsTask = wmsTasks[0];
if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS)
{
_sendWmsTaskStatus.SendTaskErr(taskId, $"{sysName} 删除/取消");
sendWmsTaskStatus.SendTaskErr(taskId, $"{sysName} 删除/取消");
}
}
string resetErrMessage = _wmsTaskDao.DeleteTaskWithTaskId(taskId, $"【{sysName}】删除/取消");
string resetErrMessage = wmsTaskDao.DeleteTaskWithTaskId(taskId, $"【{sysName}】删除/取消");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 删除成功
return $"删除/取消任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}";
}

7
WcsMain/Business/Convey/ConnectPlcServe.cs
View File

@ -17,9 +17,6 @@ namespace WcsMain.Business.Convey;
[Component]
public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataHandler)
{
private readonly AppTcpDao _tcpDao = tcpDao;
private readonly BaseConveyDataHandler _conveyDataHandler = conveyDataHandler;
public void SetBaseAction()
{
@ -41,7 +38,7 @@ public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataH
List<AppTcp>? tcps = default;
while (true)
{
tcps = _tcpDao.Query(new AppTcp { TcpStatus = (int)TrueFalseEnum.TRUE, TcpType = (int)TcpType.PLC });
tcps = tcpDao.Query(new AppTcp { TcpStatus = (int)TrueFalseEnum.TRUE, TcpType = (int)TcpType.PLC });
if (tcps != default) break;
Thread.Sleep(5000);
continue;
@ -89,7 +86,7 @@ public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataH
switch(header.MsgTag)
{
case "GTROUTER": // plc向WCS请求路向 ---- 箱式线
_conveyDataHandler.GetRouter(tcpServe.DisplayName, msg);
conveyDataHandler.GetRouter(tcpServe.DisplayName, msg);
return;

4
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/LoginGetData.cs
View File

@ -13,8 +13,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class LoginGetData(WmsWebApiPost wmsWebApiPost) : IBaseGetData
{
private readonly WmsWebApiPost _wmsWebApiPost = wmsWebApiPost;
/// <summary>
/// 读码失败
/// </summary>
@ -50,7 +48,7 @@ public class LoginGetData(WmsWebApiPost wmsWebApiPost) : IBaseGetData
}
/* 发送 WMS 请求入库 */
ApplyInRequest applyInRequest = new(area, code, msg);
var postResult = _wmsWebApiPost.HttpPost<ApplyInRequest, WmsResponse>(applyInRequest, CommonData.AppConfig.ApplyEnterApiAddress ?? "");
var postResult = wmsWebApiPost.HttpPost<ApplyInRequest, WmsResponse>(applyInRequest, CommonData.AppConfig.ApplyEnterApiAddress ?? "");
if(!postResult.IsSend || postResult.ResponseEntity == default)
{
ConsoleLog.Exception($"【异常】注册口：{area} 箱码:{msg} 请求入库发生异常，异常信息：{postResult.RequestException}");

22
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/Pick1StandOutC3.cs
View File

@ -18,10 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary>
/// 读码失败
/// </summary>
@ -31,9 +27,9 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +48,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +59,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +70,12 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
}
}
/* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default)
{
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断一区环线运行
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +88,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -107,7 +103,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 不存在一号台任务，环线运行");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在一号台任务
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -120,7 +116,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Info($"一区出口：{area} 箱码：{msg} 存在一号台任务，移栽 1 号站台");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在一号台任务
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/Pick2StandOutC4.cs
View File

@ -18,9 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// <param name="conveyTaskDao"></param>
public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary>
/// 扫码失败
@ -31,9 +28,9 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 读码失败，环线继续，进入拣选一区
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +49,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +60,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +71,12 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
}
}
/* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default)
{
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选区 1
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +89,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); // 没有任务直接回库，走上层
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -117,7 +114,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在 1~5 站台任务，前往拣选一区");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -134,7 +131,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 不存在6号台任务，环线运行");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在6号台任务
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -147,7 +144,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在6号台任务，移栽 6 号站台");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在6号台任务
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/PickStandGetData.cs
View File

@ -20,11 +20,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks>
public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary>
/// 读码失败
/// </summary>
@ -34,9 +29,9 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}");
@ -55,7 +50,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -66,7 +61,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -77,12 +72,12 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
}
}
/* 判断条码有没有这个拣选站台的拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create, Location = area });
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create, Location = area });
if (conveyTasks == default)
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -95,7 +90,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -108,11 +103,11 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
// 有拣选任务
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk);
string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");
int updateResult = _conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
int updateResult = conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
if (updateResult < 1)
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败");

26
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/PickStandP5.cs
View File

@ -18,10 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// <param name="conveyTaskDao"></param>
public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary>
/// 读码失败
/// </summary>
@ -31,9 +27,9 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进站台
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +48,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +59,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +70,12 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
}
}
/* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create});
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create});
if (conveyTasks == default)
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +88,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -107,11 +103,11 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk);
string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");
int updateResult = _conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
int updateResult = conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
if (updateResult < 1)
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败");
@ -141,7 +137,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{
ConsoleLog.Info($"拣选站台：{area} 箱码：{msg} 存在pick2区域的任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -154,7 +150,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无 pick2 区域拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerInErr.cs
View File

@ -16,11 +16,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </summary>
public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary>
/// 读码失败
/// </summary>
@ -30,9 +25,9 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库异常口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -51,7 +46,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -62,7 +57,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
{
ConsoleLog.Warning($"【警告】入库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -73,13 +68,13 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
}
}
/* 查询任务 */
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if (wcsTasks == default)
{
// 数据库服务器连接失败
ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 查询任务失败，请检查服务器网络");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -93,7 +88,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
// 不存在任务
ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 不存在入库任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -111,7 +106,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
// 点位不存在
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -123,7 +118,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0);
ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}");
ConveyPLCTask plcTaskOk = new(plcId, (short)router);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk);
string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

21
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerInSpliter.cs
View File

@ -19,9 +19,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks>
public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary>
/// 读码失败
@ -32,9 +29,9 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.NoRead);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if(string.IsNullOrEmpty(errText) )
{
ConsoleLog.Success($"入库分流：{area} 读码失败，写入PLC成功，{plcTask}");
@ -53,7 +50,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -64,7 +61,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
{
ConsoleLog.Warning($"【警告】入库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -75,13 +72,13 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
}
}
/* 查询任务 */
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if(wcsTasks == default)
{
// 数据库服务器连接失败
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 查询任务失败，请检查服务器网络");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -95,7 +92,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
// 不存在任务
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 不存在入库任务，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -111,7 +108,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
// 点位不存在
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -123,7 +120,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0);
ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}");
ConveyPLCTask plcTaskOk = new(plcId, (short)router);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk);
string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk))
{
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerOutC1.cs
View File

@ -18,11 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks>
public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary>
/// 读码失败
/// </summary>
@ -32,9 +27,9 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 读码失败，写入PLC成功，{plcTask}");
@ -53,7 +48,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -64,7 +59,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -75,12 +70,12 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
}
}
/* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if(conveyTasks == default)
{
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -93,7 +88,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -118,7 +113,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{
ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 存在 1~5 站台任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -131,7 +126,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{
ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 不存在 1~5 站台任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

20
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerOutErrC2.cs
View File

@ -18,15 +18,11 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库异常口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -38,7 +34,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection;
@ -49,7 +45,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -60,12 +56,12 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
}
}
/* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default)
{
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -78,7 +74,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
{
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask);
string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText))
{
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -90,7 +86,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
// 存在拣选任务
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.Go);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk);
string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk))
{
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

7
WcsMain/Business/Convey/HistoryDataHandler/HistoryConveyDataHander.cs
View File

@ -17,9 +17,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler;
[Component]
public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, IComponentContext componentContext)
{
private readonly IComponentContext _componentContext = componentContext;
private readonly AppRouterMethodDao _routerMethodDao = routerMethodDao;
private Dictionary<string, IBaseGetData?>? methodConfig;
private Dictionary<string, AppRouterMethod?>? areaBaseData;
@ -70,7 +67,7 @@ public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, ICompon
lock (loadLock)
{
if (methodConfig != default && areaBaseData != default) return;
List<AppRouterMethod>? appRouters = _routerMethodDao.Query();
List<AppRouterMethod>? appRouters = routerMethodDao.Query();
if (appRouters == default) return;
methodConfig = [];
areaBaseData = [];
@ -120,7 +117,7 @@ public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, ICompon
List<object> arguments = [];
foreach (var parameter in parameters)
{
object par = _componentContext.Resolve(parameter.ParameterType);
object par = componentContext.Resolve(parameter.ParameterType);
arguments.Add(par);
}
return Activator.CreateInstance(type, [.. arguments]);