using Autofac.Core;
|
using Microsoft.AspNetCore.Components.Routing;
|
using Microsoft.AspNetCore.Hosting;
|
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
|
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
|
using Quartz;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.ComponentModel.Design;
|
using System.Diagnostics.CodeAnalysis;
|
using System.Diagnostics.Eventing.Reader;
|
using System.Linq;
|
using System.Reflection.Metadata;
|
using System.Runtime.CompilerServices;
|
using System.Text;
|
using System.Threading.Tasks;
|
using WIDESEA_Common.Log;
|
using WIDESEAWCS_Common.TaskEnum;
|
using WIDESEAWCS_Core;
|
using WIDESEAWCS_Core.Enums;
|
using WIDESEAWCS_DTO.Enum;
|
using WIDESEAWCS_ISystemServices;
|
using WIDESEAWCS_ITaskInfoRepository;
|
using WIDESEAWCS_ITaskInfoService;
|
using WIDESEAWCS_Model.Models;
|
using WIDESEAWCS_Model.Models.System;
|
using WIDESEAWCS_QuartzJob;
|
using WIDESEAWCS_QuartzJob.DeviceBase;
|
using WIDESEAWCS_QuartzJob.DTO;
|
using WIDESEAWCS_QuartzJob.Models;
|
using WIDESEAWCS_QuartzJob.Service;
|
using WIDESEAWCS_QuartzJob.StackerCrane;
|
using WIDESEAWCS_QuartzJob.StackerCrane.Enum;
|
using WIDESEAWCS_TaskInfoService;
|
using WIDESEAWCS_Tasks.ConveyorLineJob;
|
using WIDESEAWCS_Tasks.StackerCraneJob;
|
|
namespace WIDESEAWCS_Tasks
|
{
|
[DisallowConcurrentExecution]
|
public class SpeStackerCraneJob : IJob
|
{
|
private readonly ITaskService _taskService;
|
private readonly ITaskExecuteDetailService _taskExecuteDetailService;
|
private readonly ITaskRepository _taskRepository;
|
private readonly IRouterService _routerService;
|
private readonly IAgvStationService _agvStationService;
|
|
|
public SpeStackerCraneJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, ITaskRepository taskRepository, IRouterService routerService, IAgvStationService agvStationService)
|
{
|
_taskService = taskService;
|
_taskExecuteDetailService = taskExecuteDetailService;
|
_taskRepository = taskRepository;
|
_routerService = routerService;
|
_agvStationService = agvStationService;
|
}
|
|
|
public Task Execute(IJobExecutionContext context)
|
{
|
try
|
{
|
SpeStackerCrane speStackerCrane = (SpeStackerCrane)context.JobDetail.JobDataMap.Get("JobParams");
|
if (speStackerCrane != null)
|
{
|
GetStackerObject getStackerObject = new GetStackerObject(speStackerCrane);
|
|
//读取设备完成信息
|
if (getStackerObject.StaclerkJobJobStatusValue == RgvJobCraneStatus.Completed && getStackerObject.CurrentRgvtaskid != 0)
|
{
|
_taskService.UpdateTaskStatus(getStackerObject.CurrentRgvtaskid,2);
|
}
|
|
|
if (getStackerObject.RgvCraneAutoStatusValue == RgvCraneAutoStatus.Automatic &&
|
getStackerObject.StaclerkJobJobStatusValue == RgvJobCraneStatus.Ready && getStackerObject.RgvCraneWorkStatusValue == RGVStepprocess.NoAction)
|
{
|
|
//下发RGV任务之前，先读取一下安全门状态
|
|
//查找RGV进行下发任务
|
Dt_Task task = GetTask(speStackerCrane.DeviceCode);
|
if (task != null)
|
{
|
//调取写入RGV小车任务
|
RgvCraneTaskCommand? stackerCraneTaskCommand = ConvertToStackerCraneTaskCommand(task);
|
bool sendFlag = getStackerObject.SendCommand(stackerCraneTaskCommand);
|
if (sendFlag)
|
{
|
//修改任务状态
|
_taskService.UpdateTaskStatusToNext(task);
|
}
|
}
|
else
|
{
|
int HCJGoodsplatform = 1170; //定义的放货站台
|
|
//判断母车是否需要进行移动
|
AGVStation GdZiche = _agvStationService.Corridorequipment(speStackerCrane.DeviceCode);
|
if(GdZiche.Station_Area == 1)
|
{
|
switch (getStackerObject.RGVCurrentlocation)
|
{
|
case int Whcjaddress when Whcjaddress == GdZiche.MotherCarDeviceCode: //在第一个母车上
|
RGVMovetask(HCJGoodsplatform, GdZiche.ChildPosiDeviceCode);
|
break;
|
case int Waddress when Waddress == GdZiche.MotherCardeputy: //在第二个母车上
|
OutNMotherCar(GdZiche.MotherCarDeviceCode);
|
break;
|
case int HCJaddress when HCJaddress == GdZiche.HCJStorageaddress: //在HCJ站台上
|
OutHCJMotherCar(GdZiche);
|
break;
|
default: return null;
|
}
|
}
|
else
|
{
|
switch (getStackerObject.RGVCurrentlocation)
|
{
|
case int Whcjaddress when Whcjaddress == GdZiche.MotherCarDeviceCode: //在第一个母车上，需要判断外侧子车是否在HCJ上
|
OutinnerSideNMotherCar(GdZiche);
|
break;
|
case int Waddress when Waddress == GdZiche.MotherCardeputy: //在第二个母车上，需要判断子车与外侧母车是否在过道上
|
OutNMotherCar(GdZiche.MotherCarDeviceCode);
|
break;
|
default: return null;
|
}
|
}
|
}
|
|
|
}
|
}
|
|
|
}
|
catch (Exception ex)
|
{
|
//Console.WriteLine(nameof(CommonStackerCraneJob) + ":" + ex.ToString());
|
}
|
return Task.CompletedTask;
|
}
|
|
private Dt_Task? GetTask(string DeviceCode)
|
{
|
Dt_Task task = _taskService.QueryStackerCraneTask(DeviceCode);
|
if (task == null) return null;
|
|
return task.TaskType switch
|
{
|
(int)TaskInboundTypeEnum.Inbound => HandleInboundTask(task),
|
(int)TaskOutboundTypeEnum.Outbound => HandleOutboundTask(task),
|
_ => null
|
};
|
}
|
|
private Dt_Task? HandleInboundTask(Dt_Task task)
|
{
|
return task.TaskState switch
|
{
|
(int)TaskInStatusEnum.RGV_InNew => task,
|
(int)TaskInStatusEnum.RGV_InPickupFinish => HandlePickupFinish(task),
|
(int)TaskInStatusEnum.RGV_InReleaseFinish => HandInneRouterSides(task),
|
(int)TaskInStatusEnum.RGV_InZicheFinish => HandleZicheFinish(task),
|
(int)TaskInStatusEnum.RGV_InZicheReleaseFinish => task,
|
(int)TaskInStatusEnum.RGV_InZichemoveFinish => HandleZicheMoveFinish(task),
|
_ => null
|
};
|
}
|
|
private Dt_Task? HandleOutboundTask(Dt_Task task)
|
{
|
// 出库任务的状态判断相对简单，可以直接返回
|
int[] validStates =
|
{
|
(int)TaskOutStatusEnum.OutNew,
|
(int)TaskOutStatusEnum.RGV_OutMothercarFinish,
|
(int)TaskOutStatusEnum.RGV_OutZicheFinish,
|
(int)TaskOutStatusEnum.RGV_OutZicheReleaseFinish,
|
(int)TaskOutStatusEnum.RGV_OutPickupFinish
|
};
|
|
return validStates.Contains(task.TaskState) ? task : null;
|
}
|
|
#region 入库方法
|
|
#region 入库口取货完成后，进行放货（HCJ,异常出库口）
|
private Dt_Task? HandlePickupFinish(Dt_Task task)
|
{
|
try
|
{
|
//获取需要区分是否去入库与去不合格载货台任务
|
IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "HCJ2000");
|
CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
|
DeviceProDTO? deviceProDTO = GetDeviceAddress.GetDeviceProDTO(Commonstacker, task.NextAddress, "HCJ_GoodsStatus");
|
int HCJGStatus = GetDeviceAddress.GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
|
if (HCJGStatus == 0) //为无货
|
{
|
return task;
|
}
|
}
|
catch (Exception ex)
|
{
|
//记录异常情况
|
_taskService.UpdateTaskExceptionMessage(task.TaskNum, $"判断HCJ站台是否有货信息出错，出错信息：{ex.Message}");
|
throw;
|
}
|
|
return null;
|
}
|
|
#endregion
|
|
#region 入库口放货完成后，进行取货内容
|
private Dt_Task? HandInneRouterSides(Dt_Task task)
|
{
|
// 根据设备名称，获取到设备相关数据
|
AGVStation currentStation = _agvStationService.Corridorequipment(task.Roadway);
|
|
// 获取子车位置
|
int zicheAddress = GetDeviceAddress.GetEquipmentlocation(currentStation.ChildPosiDeviceCode);
|
if (currentStation.Station_Area == 1)
|
{
|
// 根据子车位置处理不同情况
|
switch (zicheAddress)
|
{
|
case int Whcjaddress when Whcjaddress == int.Parse(task.CurrentAddress):
|
return task;
|
case int Waddress when Waddress == currentStation.MotherCarDeviceCode:
|
return task;
|
case int Naddress when Naddress == currentStation.MotherCardeputy:
|
return HandleMedialCase(task, currentStation.MotherCarDeviceCode);
|
case int HCJaddress when HCJaddress == currentStation.HCJStorageaddress:
|
return HandleMedialCase2(task, currentStation);
|
default: return null;
|
}
|
}
|
else
|
{
|
//取HCJ位的料判断
|
switch (zicheAddress)
|
{
|
case int Whcjaddress when Whcjaddress == int.Parse(task.CurrentAddress):
|
return task;
|
case int Waddress when Waddress == currentStation.MotherCarDeviceCode:
|
return task;
|
case int Naddress when Naddress == currentStation.MotherCardeputy:
|
return HandleMedialCase(task, currentStation.MotherCarDeviceCode);
|
default: return null;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 判断外侧母车是否在入口口
|
/// </summary>
|
/// <param name="task"></param>
|
/// <param name="currentStation"></param>
|
/// <returns></returns>
|
private Dt_Task? HandleMedialCase(Dt_Task task, int currentStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(currentStation);
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
if (motherCarAddress == Muche.Motherinlaw) return task;
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
return null;
|
}
|
/// <summary>
|
/// 判断内外侧母车是否在入库口
|
/// </summary>
|
/// <param name="task"></param>
|
/// <param name="currentStation"></param>
|
/// <returns></returns>
|
private Dt_Task? HandleMedialCase2(Dt_Task task, AGVStation currentStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(currentStation.MotherCarDeviceCode); //外侧母车
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(currentStation.MotherCardeputy); //内侧母车
|
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
if (motherCarAddress == 0 || motherCarAddress2 == 0) return null;
|
// 如果母车不在预期位置，下发移动任务
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress2 != Muche2.Motherinlaw)
|
{
|
RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.Motherinlaw) return task;
|
// 母车已在正确位置
|
return null;
|
}
|
|
#endregion
|
|
#region 取货完成后，进行放货操作
|
private Dt_Task? HandleZicheFinish(Dt_Task task)
|
{
|
// 根据设备名称，获取到设备相关数据
|
AGVStation GdaoRgvStation = _agvStationService.Corridorequipment(task.Roadway);
|
int nexaddres = int.Parse(task.NextAddress);
|
switch (nexaddres)
|
{
|
case int Whcjaddress when Whcjaddress == GdaoRgvStation.MotherCarDeviceCode: //放货点在第一个过道点
|
return MotherCarMoves(task, GdaoRgvStation);
|
case int Waddress when Waddress == GdaoRgvStation.MotherCardeputy: //放货点在第二个过道点
|
return MotherCarMovesinside(task, GdaoRgvStation);
|
case int HCJaddress when HCJaddress == GdaoRgvStation.HCJStorageaddress: //放货点在HCJ上
|
return HCJMotherCarMovesinside(task, GdaoRgvStation);
|
default: return null;
|
}
|
}
|
|
|
//区域一判断母车是否到位，可立即放货
|
private Dt_Task? MotherCarMoves(Dt_Task _Task, AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.ZicheMotherinlaw);
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
if (motherCarAddress == Muche.ZicheMotherinlaw) return _Task;
|
RGVMovetask(Muche.ZicheMotherinlaw, aGVStation.ChildPosiDeviceCode);
|
return null;
|
}
|
|
/// <summary>
|
/// 判断放第二个母车位置
|
/// </summary>
|
/// <param name="_Task"></param>
|
/// <param name="aGVStation"></param>
|
/// <returns></returns>
|
private Dt_Task? MotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode); //外侧母车
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
// 如果母车不在预期位置，下发移动任务
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress2 != Muche2.ZicheMotherinlaw)
|
{
|
RGVMovetask(Muche2.ZicheMotherinlaw, Muche2.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.ZicheMotherinlaw) return _Task;
|
// 母车已在正确位置
|
return null;
|
}
|
private Dt_Task? HCJMotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode); //外侧母车
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
|
AGVStation Ziche3 = _agvStationService.GetZicheDeep(aGVStation.HCJStorageaddress); //内侧子车
|
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
int ZiCarAddress3 = GetDeviceAddress.GetEquipmentlocation(Ziche3.ChildPosiDeviceCode);
|
// 如果母车不在预期位置，下发移动任务
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress2 != Muche2.Motherinlaw)
|
{
|
RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
|
}
|
if(ZiCarAddress3== Ziche3.HCJStorageaddress)
|
{
|
//判断目标站台是入库到几号堆垛机
|
if (_Task.TargetAddress == "3") //入库至3号堆垛机
|
{
|
//判断外侧母车位置（2区域）
|
AGVStation MucheN = _agvStationService.GetMothervehicle(Ziche3.MotherCarDeviceCode); //外侧母车
|
int motNCarAddress = GetDeviceAddress.GetEquipmentlocation(MucheN.ChildPosiDeviceCode); //获取到母车当前位置
|
if(MucheN.ZicheMotherinlaw== motNCarAddress)
|
{
|
RGVMovetask(Ziche3.MotherCarDeviceCode, Ziche3.ChildPosiDeviceCode);
|
}
|
else
|
{
|
RGVMovetask(MucheN.ZicheMotherinlaw, MucheN.ChildPosiDeviceCode);
|
}
|
}
|
else if (_Task.TargetAddress == "4") //入库至4号堆垛机
|
{
|
//判断外侧母车位置（2区域）
|
AGVStation MucheN = _agvStationService.GetMothervehicle(Ziche3.MotherCarDeviceCode); //外侧母车
|
int motNCarAddress = GetDeviceAddress.GetEquipmentlocation(MucheN.ChildPosiDeviceCode); //获取到母车当前位置
|
if (MucheN.Motherinlaw != motNCarAddress)
|
{
|
RGVMovetask(MucheN.Motherinlaw, MucheN.ChildPosiDeviceCode);
|
}
|
AGVStation MucheN2 = _agvStationService.GetMothervehicle(Ziche3.MotherCardeputy); //外侧母车
|
int motNCarAddress2 = GetDeviceAddress.GetEquipmentlocation(MucheN2.ChildPosiDeviceCode); //获取到母车当前位置
|
if (MucheN2.ZicheMotherinlaw != motNCarAddress2)
|
{
|
RGVMovetask(MucheN2.ZicheMotherinlaw, MucheN2.ChildPosiDeviceCode);
|
}
|
|
if(MucheN.Motherinlaw == motNCarAddress && MucheN2.ZicheMotherinlaw == motNCarAddress2)
|
{
|
RGVMovetask(Ziche3.MotherCardeputy, Ziche3.ChildPosiDeviceCode);
|
}
|
}
|
}
|
|
if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.Motherinlaw && ZiCarAddress3 != Ziche3.HCJStorageaddress) return _Task;
|
// 母车已在正确位置
|
return null;
|
}
|
#endregion
|
|
#region 母车移动至入库口
|
private Dt_Task? HandleZicheMoveFinish(Dt_Task task)
|
{
|
int curradder = int.Parse(task.CurrentAddress);
|
AGVStation GdZiche = _agvStationService.GetMotheaisle(curradder);
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(GdZiche.ChildPosiDeviceCode);
|
if (motherCarAddress != curradder) return task;
|
RGVMovetask(GdZiche.Motherinlaw, GdZiche.ChildPosiDeviceCode);
|
return null;
|
}
|
#endregion
|
|
#endregion
|
|
|
#region 出库方法
|
|
#region 外侧小车回归到起始点位
|
/// <summary>
|
/// 判断放第二个母车位置
|
/// </summary>
|
/// <param name="_Task"></param>
|
/// <param name="aGVStation"></param>
|
/// <returns></returns>
|
private void OutNMotherCar(int MotherCarDeviceCode)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(MotherCarDeviceCode); //外侧母车
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
}
|
private void OutHCJMotherCar(AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode); //外侧母车
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
// 如果母车不在预期位置，下发移动任务
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress2 != Muche2.Motherinlaw)
|
{
|
RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
|
}
|
}
|
#endregion
|
|
|
#region 外侧小车回归到起始点位
|
/// <summary>
|
/// 在第一个位置，则判断外侧子车是否在HCJ站台下面
|
/// </summary>
|
/// <param name="_Task"></param>
|
/// <param name="aGVStation"></param>
|
/// <returns></returns>
|
private void OutinnerSideNMotherCar(AGVStation aGVStation)
|
{
|
AGVStation Ziche3 = _agvStationService.GetZicheDeep(aGVStation.HCJStorageaddress); //内侧子车
|
int ZiCarAddress3 = GetDeviceAddress.GetEquipmentlocation(Ziche3.ChildPosiDeviceCode);
|
if (ZiCarAddress3 == Ziche3.HCJStorageaddress)
|
{
|
|
}
|
else
|
{
|
//RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
}
|
private void OutinnerSideMotherCar(AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode); //外侧母车
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
// 如果母车不在预期位置，下发移动任务
|
if (motherCarAddress != Muche.Motherinlaw)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
|
}
|
if (motherCarAddress2 != Muche2.Motherinlaw)
|
{
|
RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
|
}
|
}
|
#endregion
|
|
|
#endregion
|
|
|
|
/// <summary>
|
/// 子母车移动任务
|
/// </summary>
|
/// <param name="RGVAdders">目标地址</param>
|
/// <param name="ChildPosiDeviceCode">设备编号</param>
|
/// <returns></returns>
|
private bool RGVMovetask(int RGVAdders, string ChildPosiDeviceCode)
|
{
|
RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(RGVAdders);
|
bool sendFlag = SendCommand2(standardCommands, ChildPosiDeviceCode);
|
return sendFlag;
|
}
|
/// <summary>
|
/// 任务实体转换成命令Model
|
/// </summary>
|
/// <param name="task">任务实体</param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public RgvCraneTaskCommand? ConvertToStackerCraneTaskCommand([NotNull] Dt_Task task)
|
{
|
RgvCraneTaskCommand stackerCraneTaskCommand = new RgvCraneTaskCommand();
|
short locaticurr = task.RGVTaskType switch
|
{
|
_ when task.RGVTaskType == (short)RGVTaskTypeEnum.PickingUp ||
|
(task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && task.TaskType != (int)TaskInStatusEnum.RGV_InZichemoveFinish)
|
=> short.Parse(task.CurrentAddress),
|
_ when task.RGVTaskType == (short)RGVTaskTypeEnum.Placing || (task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && task.TaskType== (int)TaskInStatusEnum.RGV_InZichemoveFinish)
|
=> short.Parse(task.NextAddress),
|
_ => (short)0
|
};
|
stackerCraneTaskCommand.RGV_RGVTasklocation = locaticurr;
|
stackerCraneTaskCommand.RGV_RGVtasktype = (short)task.RGVTaskType;
|
stackerCraneTaskCommand.RGV_Rgvtaskid = (short)task.TaskNum;
|
stackerCraneTaskCommand.RGV_Lanjiantaskid = (short)task.TaskNum;
|
return stackerCraneTaskCommand;
|
}
|
|
|
/// <summary>
|
/// 下发移动任务
|
/// </summary>
|
/// <param name="task">任务实体</param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public RgvCraneTaskCommand? ConvertMotherCarTaskCommand(int RGVAddress)
|
{
|
RgvCraneTaskCommand stackerCraneTaskCommand = new RgvCraneTaskCommand();
|
stackerCraneTaskCommand.RGV_RGVTasklocation = (short)RGVAddress;
|
stackerCraneTaskCommand.RGV_RGVtasktype = 3;
|
stackerCraneTaskCommand.RGV_Rgvtaskid = 999; //rgv任务号
|
stackerCraneTaskCommand.RGV_Lanjiantaskid = 999; //兰剑任务id
|
return stackerCraneTaskCommand;
|
}
|
public bool SendCommand2(RgvCraneTaskCommand command, string DeviceCode)
|
{
|
try
|
{
|
IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == DeviceCode);
|
CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
|
|
DeviceProDTO? deviceProDTO = GetDeviceAddress.GetDeviceProDTO(Commonstacker, DeviceCode, "RGV_Rgvtaskstutas");
|
int MCGStatus = GetDeviceAddress.GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
|
if (Commonstacker.IsConnected)
|
{
|
if (MCGStatus == (int)RgvJobCraneStatus.Ready)
|
{
|
Commonstacker.SetValue(RgvCraneDBName.RGV_RGVTasklocation, command.RGV_RGVTasklocation);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_RGVtasktype, command.RGV_RGVtasktype);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_Rgvtaskid, command.RGV_Rgvtaskid);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_Lanjiantaskid, command.RGV_Lanjiantaskid);
|
return true;
|
}
|
}
|
return false;
|
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
}
|
}
|
