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 OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
|
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.Net;
|
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.RGVInitializationValue == RGVInitialize.Initialized)
|
{
|
//读取设备完成信息
|
if (getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.Completed || getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.AbnormalCompletion)
|
{
|
CommonStackerCrane_AGVTaskCompletedEventHandler(getStackerObject, speStackerCrane);
|
}
|
|
//判断当前设备是入库还是出库
|
/*if (GetDeviceAddress.OutbounMotherChildCartbool(speStackerCrane.DeviceCode))
|
{
|
//判断当前安全门是否为绿色灯
|
if (GetDeviceAddress.ReadAqmDecicStice(1))
|
{
|
return null;
|
}
|
}
|
else
|
{
|
//判断入库端安全门是否正常
|
if (GetDeviceAddress.ReadAqmDecicStice(2))
|
{
|
return null;
|
}
|
}*/
|
|
|
|
|
|
if (getStackerObject.RgvCraneAutoStatusValue == RgvCraneAutoStatus.Automatic &&
|
getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.Ready && getStackerObject.RgvCraneWorkStatusValue == RGVStepprocess.NoAction)
|
{
|
//查找RGV进行下发任务
|
Dt_Task task = GetTask(speStackerCrane.DeviceCode, getStackerObject);
|
if (task != null)
|
{
|
//调取写入RGV小车任务
|
RgvCraneTaskCommand? stackerCraneTaskCommand = ConvertToStackerCraneTaskCommand(task);
|
if (stackerCraneTaskCommand != null)
|
{
|
bool sendFlag = getStackerObject.SendCommand(stackerCraneTaskCommand);
|
if (sendFlag)
|
{
|
//修改任务状态
|
_taskService.UpdateTaskStatusToNext(task);
|
}
|
}
|
|
}
|
else
|
{
|
if (GetDeviceAddress.OutbounMotherChildCartbool(speStackerCrane.DeviceCode))
|
{
|
//当没任务的时候，则进行移动
|
Returnposition(speStackerCrane.DeviceCode, getStackerObject.RGVCurrentlocation, (int)getStackerObject.RgvCraneStatusValue);
|
|
}
|
else if (GetDeviceAddress.OutbounMotherChildCartbool2(speStackerCrane.DeviceCode))
|
{
|
InReturnposition(speStackerCrane.DeviceCode, getStackerObject.RGVCurrentlocation, (int)getStackerObject.RgvCraneStatusValue);
|
}
|
|
}
|
}
|
}
|
|
}
|
}
|
catch (Exception ex)
|
{
|
//Console.WriteLine(nameof(CommonStackerCraneJob) + ":" + ex.ToString());
|
}
|
return Task.CompletedTask;
|
}
|
|
#region 任务完成
|
private void CommonStackerCrane_AGVTaskCompletedEventHandler(GetStackerObject getStackerObject, SpeStackerCrane speStackerCrane)
|
{
|
if (getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.Completed && getStackerObject.CurrentRgvtaskid == 30001)
|
{
|
speStackerCrane.SetValue(RGV_taskcoDBName.RGV_taskcomplete, 1);
|
speStackerCrane.SetValue(RGV_taskcoDBName.RGV_taskcomplete, 0);
|
}
|
else if (getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.Completed && getStackerObject.CurrentRgvtaskid != 0 && getStackerObject.CurrentRgvtaskid != 30001)
|
{
|
_taskService.UpdateTaskStatus(getStackerObject.CurrentRgvtaskid); //正常任务完成
|
speStackerCrane.SetValue(RGV_taskcoDBName.RGV_taskcomplete, 1);
|
speStackerCrane.SetValue(RGV_taskcoDBName.RGV_taskcomplete, 0);
|
}
|
else if (getStackerObject.StaclerkJobJobStatusValue == RGV_Rgvtaskstutas.AbnormalCompletion && getStackerObject.CurrentRgvtaskid != 0 && getStackerObject.CurrentRgvtaskid != 30001)
|
{
|
|
//修改任务状态为异常完成
|
_taskService.HandleInAbnormal(getStackerObject.CurrentRgvtaskid);
|
|
//写入异常完成报警信息
|
speStackerCrane.Communicator.Write<short>("DB101.36", 1); //写入报警
|
}
|
}
|
#endregion
|
|
|
|
private Dt_Task? GetTask(string DeviceCode, GetStackerObject getStackerObject)
|
{
|
// 根据设备名称，获取到设备相关数据
|
AGVStation RGVTaskdevice = _agvStationService.Corridorequipment(DeviceCode); //根据设备获取到内容
|
return RGVTaskdevice.Station_tasktype switch
|
{
|
(int)RGVTasktype.Inbound => HandleInboundTask(RGVTaskdevice, getStackerObject),
|
(int)RGVTasktype.Outbound => OutboundEquipmentTask(RGVTaskdevice, getStackerObject), //出库
|
_ => null
|
};
|
|
|
}
|
|
#region 入库方法
|
private Dt_Task? HandleInboundTask(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
|
{
|
return (RGVTaskdevice.Station_material, getStackerObject.RgvCraneStatusValue) switch
|
{
|
((int)RGVEquipment.InRGVForklift, RgvEquipmentStatus.NoCargo) //叉车式RGV无货,下发取货任务
|
=> _taskService.PickupWarehouse(RGVTaskdevice.ChildPosiDeviceCode),
|
|
((int)RGVEquipment.InRGVForklift, RgvEquipmentStatus.HasCargo)
|
=> ForkliftUnloading(RGVTaskdevice), //叉车式进行放货（已完成）
|
|
((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.NoCargo)
|
=> ZichePickUpAisle(RGVTaskdevice, getStackerObject), //过道子车进行取货（已完成）
|
|
((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.HasCargo)
|
=> GoodsPlacedCorridor(RGVTaskdevice), //子车放货任务(已完成)
|
|
((int)RGVEquipment.Mothertrailer, RgvEquipmentStatus.HasCargo)
|
=> MotherVehicleMovement(RGVTaskdevice), //母车移动（已完成）
|
|
_ => null
|
};
|
|
}
|
|
#region 叉车式进行放货（已完成）
|
public Dt_Task? ForkliftUnloading(AGVStation RGVTaskdevice)
|
{
|
Dt_Task dt_Task = _taskService.GetInkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode);
|
|
//判断HCJ是否有货
|
if (GetDeviceAddress.HCJIsstock(dt_Task.NextAddress))
|
{
|
//判断子车是否在接驳台下
|
var zichestation = _agvStationService.OutGetZicheDeepHCJ(1061);
|
int ziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
if ((ziche == zichestation.WaitmomentOne || ziche == zichestation.WaitmomentTwo || ziche == zichestation.MotherCarDeviceCode || ziche == zichestation.MotherCardeputy || ziche == zichestation.HCJStorageaddress) && ziche != 1021)
|
{
|
//获取这个接驳台是否有取货任务
|
Dt_Task zitask = _taskService.ViceChariotPickupTask2(RGVTaskdevice.ChildPosiDeviceCode);
|
if (zitask == null)
|
{
|
|
return dt_Task;
|
}
|
}
|
}
|
return null;
|
}
|
#endregion
|
|
#region 过道子车进行取货（已完成）
|
public Dt_Task? ZichePickUpAisle(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
|
{
|
//获取子车取货任务
|
Dt_Task dt_Task = _taskService.ViceChariotPickupTask(RGVTaskdevice.ChildPosiDeviceCode);
|
if (dt_Task == null) return null;
|
if (RGVTaskdevice.Station_Area == 6) //外侧进取货，则需要判断子车当前位置
|
{
|
if (getStackerObject.RGVCurrentlocation == RGVTaskdevice.WaitmomentOne)
|
{
|
//还需要判断入库口叉车是否收回叉车了
|
|
//在等待点1，则需要判断1号母车在堆垛机取货口
|
var mu1rgv = _agvStationService.GetMothervehicle(RGVTaskdevice.MotherCarDeviceCode);
|
int mu1 = GetDeviceAddress.GetEquipmentlocation(mu1rgv.ChildPosiDeviceCode); //此时的RGV应该无货
|
bool ywh = GetDeviceAddress.Mucheywhaddres(mu1rgv.ChildPosiDeviceCode);
|
if (mu1 == mu1rgv.Motherinlaw || (ywh && mu1 == mu1rgv.ZicheMotherinlaw)) //在堆垛机取货口
|
{
|
//=============================新增当去取货时进行判断巷道，看能不能提前拉出母车
|
if (int.Parse(dt_Task.TargetAddress) == (int)StorageAisleEnum.LaneTwo)
|
{
|
int taraddress = int.Parse(dt_Task.TargetAddress);
|
var InMotherVehicle = _agvStationService.ObtainCcordingTunnel(taraddress); //获取到需要入库的母车(2巷道)
|
int mu2 = GetDeviceAddress.GetEquipmentlocation(InMotherVehicle.ChildPosiDeviceCode); //此时的RGV应该无货
|
if (GetDeviceAddress.Mucheywhaddres(InMotherVehicle.ChildPosiDeviceCode)) //判断无货
|
{
|
if (mu2 == InMotherVehicle.ZicheMotherinlaw)
|
{
|
return dt_Task;
|
}
|
else if (mu2 == InMotherVehicle.Motherinlaw)
|
{
|
RGVMovetask(InMotherVehicle.ZicheMotherinlaw, InMotherVehicle.ChildPosiDeviceCode);
|
}
|
}
|
}
|
//=============================新增当去取货时进行判断巷道，看能不能提前拉出母车
|
return dt_Task;
|
}
|
//去掉原因：在该出子车去取货，可直接穿过无货母车，拖车
|
/*else
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask2(RGVTaskdevice.ChildPosiDeviceCode);
|
if (task == null)
|
{
|
RGVMovetask(mu1rgv.Motherinlaw, mu1rgv.ChildPosiDeviceCode);
|
}
|
}*/
|
|
}
|
else if (getStackerObject.RGVCurrentlocation == RGVTaskdevice.WaitmomentTwo) //则需要判断两个母车的位子
|
{
|
//判断两个子车是否在堆垛机取货口
|
|
//母车1
|
var mu1rgv = _agvStationService.GetMothervehicle(RGVTaskdevice.MotherCarDeviceCode);
|
int mu1 = GetDeviceAddress.GetEquipmentlocation(mu1rgv.ChildPosiDeviceCode); //此时的RGV应该无货
|
bool m1Isitstock1 = GetDeviceAddress.Mucheywhaddres(mu1rgv.ChildPosiDeviceCode);
|
|
var mu2rgv = _agvStationService.GetMothervehicle(RGVTaskdevice.MotherCardeputy);
|
int mu2 = GetDeviceAddress.GetEquipmentlocation(mu2rgv.ChildPosiDeviceCode); //此时的RGV应该无货
|
bool m1Isitstock2 = GetDeviceAddress.Mucheywhaddres(mu2rgv.ChildPosiDeviceCode);
|
|
// 提取可读性变量
|
bool mu1AtHome = mu1 == mu1rgv.Motherinlaw;
|
bool mu2AtHome = mu2 == mu2rgv.Motherinlaw;
|
bool mu1Ready = mu1 == mu1rgv.ZicheMotherinlaw && m1Isitstock1;
|
bool mu2Ready = mu2 == mu2rgv.ZicheMotherinlaw && m1Isitstock2;
|
|
// 合并所有满足条件的情况
|
if ((mu1AtHome && mu2AtHome) || // 都在初始位置
|
(mu1Ready && mu2Ready) || // 都在就绪位置且无货
|
(mu1AtHome && mu2Ready) || // 1在初始位置，2就绪
|
(mu1Ready && mu2AtHome)) // 1就绪，2在初始位置
|
{
|
return dt_Task;
|
}
|
|
/*else
|
{
|
//无需把母车移动至取货台,无货状态的子车无需踩托盘过去去取货
|
if (mu1 != mu1rgv.Motherinlaw)
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask2(mu1rgv.ChildPosiDeviceCode);
|
if (task == null)
|
{
|
RGVMovetask(mu1rgv.Motherinlaw, mu1rgv.ChildPosiDeviceCode);
|
}
|
}
|
if (mu2 != mu2rgv.Motherinlaw)
|
{
|
Dt_Task task2 = _taskService.MothermachinemovementTask2(mu2rgv.ChildPosiDeviceCode);
|
if (task2 == null)
|
{
|
RGVMovetask(mu2rgv.Motherinlaw, mu2rgv.ChildPosiDeviceCode);
|
}
|
}
|
}*/
|
}
|
}
|
else if (RGVTaskdevice.Station_Area == 5)
|
{
|
if (getStackerObject.RGVCurrentlocation == RGVTaskdevice.WaitmomentOne)
|
{
|
//需要判断外侧小车是否在HCJ上
|
var zichestation = _agvStationService.OutGetZicheDeepHCJ(RGVTaskdevice.HCJStorageaddress);
|
int waiziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
|
if ((waiziche == zichestation.WaitmomentOne || waiziche == zichestation.WaitmomentTwo || waiziche == zichestation.MotherCardeputy || waiziche == zichestation.MotherCarDeviceCode || waiziche == 1021) && waiziche != zichestation.HCJStorageaddress)
|
{
|
return dt_Task;
|
}
|
|
}
|
else if (getStackerObject.RGVCurrentlocation == RGVTaskdevice.WaitmomentTwo) //需要判断3巷道母车是否在取货站台
|
{
|
//判断子车是否在HCJ站台
|
var zichestation = _agvStationService.OutGetZicheDeepHCJ(RGVTaskdevice.HCJStorageaddress);
|
int waiziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
|
if ((waiziche == zichestation.WaitmomentOne || waiziche == zichestation.WaitmomentTwo || waiziche == zichestation.MotherCardeputy || waiziche == zichestation.MotherCarDeviceCode || waiziche == 1021) && waiziche != zichestation.HCJStorageaddress)
|
{
|
//母车1
|
var mu1rgv = _agvStationService.GetMothervehicle(RGVTaskdevice.MotherCarDeviceCode);
|
int mu1 = GetDeviceAddress.GetEquipmentInformation(mu1rgv.ChildPosiDeviceCode); //此时的RGV应该无货
|
if (mu1 == mu1rgv.Motherinlaw)
|
{
|
return dt_Task;
|
}
|
else
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask2(mu1rgv.ChildPosiDeviceCode);
|
if (task == null)
|
{
|
RGVMovetask(mu1rgv.Motherinlaw, mu1rgv.ChildPosiDeviceCode);
|
}
|
}
|
}
|
}
|
}
|
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 过道子车进行放货
|
public Dt_Task? GoodsPlacedCorridor(AGVStation RGVTaskdevice)
|
{
|
Dt_Task task = _taskService.ViceChariotPlacingTask(RGVTaskdevice.ChildPosiDeviceCode); //获取到放货任务
|
if (task == null) return null;
|
int nexaddres = int.Parse(task.NextAddress); //判断是放货在哪的任务
|
switch (nexaddres)
|
{
|
case int Whcjaddress when Whcjaddress == RGVTaskdevice.MotherCarDeviceCode: //放货点在第一个过道点(已完成)
|
return MotherCarMoves(task, RGVTaskdevice);
|
case int Waddress when Waddress == RGVTaskdevice.MotherCardeputy: //放货点在第二个过道点(已完成)
|
return MotherCarMovesinside(task, RGVTaskdevice);
|
case int HCJaddress when HCJaddress == RGVTaskdevice.HCJStorageaddress: //放货点在HCJ上（已完成）
|
return HCJMotherCarMovesinside(task, RGVTaskdevice);
|
default: return null;
|
}
|
}
|
|
|
//区域一判断母车是否到位，可立即放货
|
private Dt_Task? MotherCarMoves(Dt_Task _Task, AGVStation aGVStation)
|
{
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode);
|
Dt_Task task = _taskService.MothermachinemovementTask2(Muche.ChildPosiDeviceCode); //获取到母车移动任务
|
if (task == null)
|
{
|
GetStackerObject getStackerObject = GetDeviceAddress.GetChildDeviceCode(Muche.ChildPosiDeviceCode);
|
if (getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.NoCargo) //判断母车是否有货
|
{
|
if (getStackerObject.RGVCurrentlocation == Muche.ZicheMotherinlaw) //判断母车是否在过道点，
|
{
|
return _Task;
|
}
|
else
|
{
|
//判断母车是否有任务
|
Dt_Task _Task1 = _taskService.MothermacTask(Muche.ChildPosiDeviceCode);
|
if (task == null)
|
{
|
RGVMovetask(Muche.ZicheMotherinlaw, Muche.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);
|
int muche1objet = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
|
//判断内侧母车是否在放货点
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
int muche2objet = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
bool NoCargobool = GetDeviceAddress.Mucheywhaddres(Muche2.ChildPosiDeviceCode);
|
|
//正常情况下，把信息反馈出去
|
if (muche1objet == Muche.Motherinlaw && muche2objet == Muche2.ZicheMotherinlaw && NoCargobool)
|
{
|
return _Task;
|
}
|
//母车1不在取货口
|
if (muche1objet != Muche.Motherinlaw) //判断母车是否在过道点，
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask2(Muche.ChildPosiDeviceCode); //获取到母车移动任务
|
if (task == null)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode); //如果没有任务，则可以进行移动出来
|
}
|
}
|
|
//母车2不在过道站点
|
if (muche2objet != Muche2.ZicheMotherinlaw) //判断母车是否在过道点，
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask2(Muche2.ChildPosiDeviceCode); //获取到母车移动任务
|
if (task == null)
|
{
|
Dt_Task _Task1 = _taskService.MothermacTask(Muche.ChildPosiDeviceCode);
|
if (task == null)
|
{
|
RGVMovetask(Muche2.ZicheMotherinlaw, Muche2.ChildPosiDeviceCode); //如果没有任务，则可以进行移动出来
|
}
|
|
}
|
}
|
return null;
|
}
|
/// <summary>
|
/// 判断放在HCJ上面
|
/// </summary>
|
/// <param name="_Task"></param>
|
/// <param name="aGVStation"></param>
|
/// <returns></returns>
|
private Dt_Task? HCJMotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
|
{
|
//先判断HCJ站台点是否有货，有任务
|
if (GetDeviceAddress.HCJIsstock(_Task.NextAddress))
|
{
|
//判断内车子车是否在等待点
|
AGVStation neiziche = _agvStationService.GetZicheDeep(aGVStation.HCJStorageaddress); //内侧子车
|
int neizichecurraddres = GetDeviceAddress.GetEquipmentlocation(neiziche.ChildPosiDeviceCode);
|
|
|
Dt_Task task = _taskService.ViceChariotPickupTask2(neiziche.ChildPosiDeviceCode); //获取到内侧子车取货任务
|
if ((neizichecurraddres != neiziche.WaitmomentOne && neizichecurraddres != neiziche.WaitmomentTwo) || task != null) //内侧子车不在两个缓存点
|
{
|
return null;
|
}
|
AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode); //外侧母车
|
int mucheaddre1 = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
|
AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy); //内侧母车
|
int mucheaddre2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
|
|
if ((neizichecurraddres == neiziche.WaitmomentOne || neizichecurraddres == neiziche.WaitmomentTwo) && task == null && neizichecurraddres != neiziche.HCJStorageaddress && mucheaddre1 == Muche.Motherinlaw && mucheaddre2 == Muche2.Motherinlaw)
|
{
|
return _Task;
|
}
|
//判断两个母车位置
|
if (mucheaddre1 != Muche.Motherinlaw) //判断母车是否在过道点，
|
{
|
Dt_Task muche1task = _taskService.MothermachinemovementTask2(Muche.ChildPosiDeviceCode); //获取到母车移动任务
|
if (muche1task == null)
|
{
|
RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode); //如果没有任务，则可以进行移动出来
|
}
|
}
|
if (mucheaddre2 != Muche2.Motherinlaw) //判断母车是否在过道点，
|
{
|
Dt_Task muche2task = _taskService.MothermachinemovementTask2(Muche2.ChildPosiDeviceCode); //获取到母车移动任务
|
if (muche2task == null)
|
{
|
RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode); //如果没有任务，则可以进行移动出来
|
}
|
}
|
}
|
return null;
|
}
|
#endregion
|
|
#region 母车移动任务
|
public Dt_Task? MotherVehicleMovement(AGVStation RGVTaskdevice)
|
{
|
Dt_Task task = _taskService.MothermachinemovementTask(RGVTaskdevice.ChildPosiDeviceCode);
|
if (task == null) return null;
|
|
AGVStation GdZiche = _agvStationService.GetMotheaisle(RGVTaskdevice.ZicheMotherinlaw);
|
int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(GdZiche.ChildPosiDeviceCode);
|
if (GdZiche.WaitmomentOne == motherCarAddress || GdZiche.WaitmomentTwo == motherCarAddress)
|
{
|
return task;
|
}
|
return null;
|
}
|
#endregion
|
|
#endregion
|
|
#region 出库方法(可进行测试)
|
public Dt_Task? OutboundEquipmentTask(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
|
{
|
return (RGVTaskdevice.Station_material, getStackerObject.RgvCraneStatusValue) switch
|
{
|
((int)RGVEquipment.Mothertrailer, RgvEquipmentStatus.HasCargo) //下发母车出来到过道上
|
=> Mothertaskdistribution(RGVTaskdevice),//已完成
|
|
((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.NoCargo) //查找子车出来取货
|
=> ChildPickupAddres(RGVTaskdevice, getStackerObject.RGVCurrentlocation), //已完成
|
|
((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.HasCargo)
|
=> Findshippingtask(RGVTaskdevice, getStackerObject.RGVCurrentlocation), //子车取货后，进行放货（已完成）
|
|
((int)RGVEquipment.OutRGVForklift, RgvEquipmentStatus.NoCargo)
|
=> OutboundGateVehicle(RGVTaskdevice), //出库口RGV取货（已完成）
|
|
((int)RGVEquipment.OutRGVForklift, RgvEquipmentStatus.HasCargo)
|
=> _taskService.GetOutkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode,
|
RGVTaskdevice.HCJStorageaddress.ToString()),
|
|
_ => null
|
};
|
}
|
|
#region 下发母车任务，需要判断当前行小车在哪个位子(已完成)
|
|
private Dt_Task? Mothertaskdistribution(AGVStation GdZiche)
|
{
|
// 提前检查无效的Area值
|
if (GdZiche.Station_Area < 1 || GdZiche.Station_Area > 4)
|
return null;
|
|
//根据母车地址，获取当前行道的子车
|
AGVStation ZicheinnerSide = _agvStationService.GetMotheaisle(GdZiche.ZicheMotherinlaw);
|
int zichecurraddre = GetDeviceAddress.GetEquipmentlocation(ZicheinnerSide.ChildPosiDeviceCode); //获取到子车实例
|
|
if (zichecurraddre != ZicheinnerSide.WaitmomentOne && zichecurraddre != ZicheinnerSide.WaitmomentTwo) return null;
|
|
//判断是哪个巷道的母车
|
return GdZiche.Station_Area switch
|
{
|
4 => OutboundSideAisle4(zichecurraddre, ZicheinnerSide), //在4巷道进行出库的任务（已完成）
|
3 => OutboundSideAisle3(zichecurraddre, ZicheinnerSide), //在3巷道进行出库的任务（已完成）
|
2 => OutboundSideAisle2(ZicheinnerSide), //在二巷道进行出库的任务（已完成）
|
1 => _taskService.ObtainMuChetask(GdZiche.ZicheMotherinlaw.ToString()), //根据母车子地址，查找是否有需要移动的任务（已完成）
|
_ => null
|
};
|
|
}
|
|
public Dt_Task? OutboundSideAisle1(AGVStation ZicheinnerSide)
|
{
|
//获取1巷道母车是否有任务
|
Dt_Task Muche1Task = _taskService.ObtainMuChetask(ZicheinnerSide.MotherCarDeviceCode.ToString());
|
if (Muche1Task == null) return null;
|
|
Dt_Task zicheTASK = _taskService.GetChariotTaskBool(ZicheinnerSide.ChildPosiDeviceCode);
|
if (zicheTASK != null) return null;
|
|
return Muche1Task;
|
}
|
|
public Dt_Task? OutboundSideAisle2(AGVStation ZicheinnerSide)
|
{
|
//获取2巷道母车是否有任务
|
Dt_Task Muche2Task = _taskService.ObtainMuChetask(ZicheinnerSide.MotherCardeputy.ToString());
|
if (Muche2Task == null) return null;
|
|
//获取子车是否有任务
|
Dt_Task zicheTASK = _taskService.GetChariotTaskBool(ZicheinnerSide.ChildPosiDeviceCode);
|
if (zicheTASK != null) return null;
|
|
//获取2巷道子车是否有任务
|
var muche1 = _agvStationService.GetMothervehicle(ZicheinnerSide.MotherCarDeviceCode);
|
Dt_Task Muche1 = _taskService.GetChariotTaskBool(muche1.ChildPosiDeviceCode.ToString());
|
if(Muche1!=null) return null;
|
|
return Muche2Task;
|
}
|
public Dt_Task? OutboundSideAisle3(int curraddZiChe, AGVStation ZicheinnerSide)
|
{
|
//获取3巷道母车是否有任务
|
Dt_Task Muche3Task = _taskService.ObtainMuChetask(ZicheinnerSide.MotherCarDeviceCode.ToString());
|
if (Muche3Task == null) return null;
|
|
//判断子车是否有要取HCJ任务
|
Dt_Task zicheTASK = _taskService.GetHCJTaskBool(ZicheinnerSide.ChildPosiDeviceCode, ZicheinnerSide.HCJStorageaddress);
|
if (zicheTASK != null) return null;
|
|
return Muche3Task;
|
}
|
public Dt_Task? OutboundSideAisle4(int curraddZiChe, AGVStation ZicheinnerSide)
|
{
|
//获取当前母车是否有任务
|
Dt_Task Muche4Task = _taskService.ObtainMuChetask(ZicheinnerSide.MotherCardeputy.ToString());
|
if (Muche4Task == null) return null;
|
|
//判断是否有需要取HCJ的任务
|
Dt_Task zicheTASK = _taskService.GetChariotTaskBool(ZicheinnerSide.ChildPosiDeviceCode);
|
if (zicheTASK != null) return null;
|
|
//判断3巷道是否有出库的任务
|
var muche3 = _agvStationService.GetMothervehicle(ZicheinnerSide.MotherCarDeviceCode);
|
Dt_Task muchetask = _taskService.OutMothermaTask(muche3.ChildPosiDeviceCode);
|
if (muchetask != null) return null;
|
|
return Muche4Task;
|
}
|
|
#endregion
|
|
#region 判断已移动出来的母车，再判断小车位置(已完成)
|
public Dt_Task? ChildPickupAddres(AGVStation GdZiche, int curraderr)
|
{
|
if (curraderr == GdZiche.WaitmomentOne || curraderr == GdZiche.WaitmomentTwo)
|
{
|
Dt_Task dtTasks = _taskService.ChildVehicleMission(GdZiche);
|
if (dtTasks == null) return null;
|
if (GdZiche.Station_Area == 5)
|
{
|
if (dtTasks.CurrentAddress == GdZiche.MotherCardeputy.ToString()) //取货的点在2巷道，则子车无论在哪个等待点，都可以取货
|
{
|
return dtTasks;
|
}
|
else if (dtTasks.CurrentAddress == GdZiche.MotherCarDeviceCode.ToString()) //取1巷道的货
|
{
|
if (curraderr == GdZiche.WaitmomentOne) //子车刚好在旁边，可立马取货
|
{
|
return dtTasks;
|
}
|
else if (curraderr == GdZiche.WaitmomentTwo)
|
{
|
var muchestation = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int muche2addres = GetDeviceAddress.GetEquipmentlocation(muchestation.ChildPosiDeviceCode); //获取2巷道母车实例
|
if (muche2addres == muchestation.Motherinlaw)
|
{
|
return dtTasks;
|
}
|
}
|
}
|
}
|
else if (GdZiche.Station_Area == 6)
|
{
|
//HCJ站台没任务
|
if (dtTasks.CurrentAddress == GdZiche.MotherCardeputy.ToString()) //优先判断是否是最外面的任务
|
{
|
if (curraderr == GdZiche.WaitmomentTwo)
|
{
|
return dtTasks;
|
}
|
else
|
{
|
var muchestation = _agvStationService.GetMothervehicle(GdZiche.MotherCarDeviceCode);
|
int muche3x = GetDeviceAddress.GetEquipmentlocation(muchestation.ChildPosiDeviceCode);
|
if (muche3x == muchestation.Motherinlaw)
|
{
|
return dtTasks;
|
}
|
}
|
}
|
else if (dtTasks.CurrentAddress == GdZiche.MotherCarDeviceCode.ToString()) //该任务为取3巷道
|
{
|
if (curraderr == GdZiche.WaitmomentOne)
|
{
|
return dtTasks;
|
}
|
else if(curraderr == GdZiche.WaitmomentTwo)
|
{
|
var muchestation = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int muche4x = GetDeviceAddress.GetEquipmentlocation(muchestation.ChildPosiDeviceCode);
|
if (muche4x == muchestation.Motherinlaw)
|
{
|
return dtTasks;
|
}
|
}
|
|
}
|
else if (dtTasks.CurrentAddress == GdZiche.HCJStorageaddress.ToString())
|
{
|
//判断内侧子车的位置
|
AGVStation neiziche = _agvStationService.GetOutZicheDeep(GdZiche.HCJStorageaddress); //内侧子车
|
int neizichecurraddres = GetDeviceAddress.GetEquipmentlocation(neiziche.ChildPosiDeviceCode);
|
if ((neiziche.WaitmomentOne == neizichecurraddres || neiziche.WaitmomentTwo == neizichecurraddres || neiziche.MotherCarDeviceCode == neizichecurraddres || neiziche.MotherCardeputy == neizichecurraddres) && neiziche.HCJStorageaddress != neizichecurraddres)
|
{
|
if (curraderr == GdZiche.WaitmomentTwo)
|
{
|
var mu1rgv = _agvStationService.GetMothervehicle(GdZiche.MotherCarDeviceCode);
|
int mu1 = GetDeviceAddress.GetEquipmentlocation(mu1rgv.ChildPosiDeviceCode);
|
|
var mu2rgv = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int mu2 = GetDeviceAddress.GetEquipmentlocation(mu2rgv.ChildPosiDeviceCode);
|
|
if (mu1 == mu1rgv.Motherinlaw && mu2 == mu2rgv.Motherinlaw)
|
{
|
return dtTasks;
|
}
|
}
|
else if (curraderr == GdZiche.WaitmomentOne)
|
{
|
return dtTasks;
|
}
|
}
|
}
|
|
|
}
|
|
}
|
return null;
|
}
|
#endregion
|
|
#region 查找子车放货任务(已完成)
|
public Dt_Task? Findshippingtask(AGVStation GdZiche, int curraderr)
|
{
|
Dt_Task task = _taskService.GetFinhuoTask(GdZiche.ChildPosiDeviceCode);
|
if (task == null) return null;
|
if (GetDeviceAddress.HCJIsstock(task.NextAddress))
|
{
|
if (GdZiche.Station_Area == 5)
|
{
|
//需要判断外侧小车是否在HCJ上
|
var zichestation = _agvStationService.OutGetZicheDeepHCJ(GdZiche.HCJStorageaddress);
|
int waiziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
if ((waiziche == zichestation.WaitmomentOne || waiziche == zichestation.WaitmomentTwo || waiziche == zichestation.MotherCardeputy || waiziche == zichestation.MotherCarDeviceCode) && waiziche != zichestation.HCJStorageaddress)
|
{
|
//判断当前位置
|
if (task.CurrentAddress == GdZiche.MotherCarDeviceCode.ToString())
|
{
|
var muchestation = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int muche2 = GetDeviceAddress.GetEquipmentlocation(muchestation.ChildPosiDeviceCode);
|
if (muche2 == muchestation.Motherinlaw)
|
{
|
return task;
|
}
|
}
|
else if (task.CurrentAddress == GdZiche.MotherCardeputy.ToString())
|
{
|
return task;
|
}
|
}
|
}
|
else if (GdZiche.Station_Area == 6)
|
{
|
if (GdZiche.HCJStorageaddress == curraderr)
|
{
|
//判断3巷道母车
|
var muchestation = _agvStationService.GetMothervehicle(GdZiche.MotherCarDeviceCode);
|
int mucboject3 = GetDeviceAddress.GetEquipmentlocation(muchestation.ChildPosiDeviceCode);
|
if (mucboject3 == muchestation.Motherinlaw)
|
{
|
//判断4巷道母车
|
var muchestation2 = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int mucboject4 = GetDeviceAddress.GetEquipmentlocation(muchestation2.ChildPosiDeviceCode);
|
if (mucboject4 == muchestation2.Motherinlaw)
|
{
|
return task;
|
}
|
|
}
|
}
|
else if (GdZiche.MotherCarDeviceCode == curraderr)
|
{
|
//判断4巷道母车
|
var muchestation2 = _agvStationService.GetMothervehicle(GdZiche.MotherCardeputy);
|
int mucboject4 = GetDeviceAddress.GetEquipmentlocation(muchestation2.ChildPosiDeviceCode);
|
if (mucboject4 == muchestation2.Motherinlaw)
|
{
|
return task;
|
}
|
}
|
else if (GdZiche.MotherCardeputy == curraderr) return task;
|
}
|
}
|
return null;
|
}
|
#endregion
|
|
#region 出库口子车取货(已完成)
|
public Dt_Task OutboundGateVehicle(AGVStation GdZiche)
|
{
|
//需要判断子车是否在HCJ上
|
var zichestation = _agvStationService.OutGetZicheDeepHCJ(1131);
|
int ziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
|
if (ziche != GdZiche.HCJStorageaddress && (ziche == zichestation.HCJStorageaddress || ziche == zichestation.WaitmomentOne || ziche == zichestation.WaitmomentTwo || ziche == zichestation.MotherCardeputy || ziche == zichestation.MotherCarDeviceCode))
|
{
|
return _taskService.GetOutchachekouFinhuoTask(GdZiche.ChildPosiDeviceCode, GdZiche.HCJStorageaddress.ToString());
|
}
|
return null;
|
}
|
#endregion
|
|
#endregion
|
|
#region 出库小车移动任务下发(已完成)
|
public void Returnposition(string DeviceCode, int RGVCurrentlocation, int RgvCraneStatusValue)
|
{
|
AGVStation GdZiche = _agvStationService.Corridorequipment(DeviceCode);
|
if (GdZiche.Station_material == (int)RGVEquipment.Mothertrailer)
|
{
|
if (GdZiche.Motherinlaw == RGVCurrentlocation) return;
|
if (RgvCraneStatusValue == (int)RgvEquipmentStatus.HasCargo) return;
|
|
//母亲回堆垛机口任务，判断子车的位置是否在母车上
|
var zichestation = _agvStationService.GetMotheaisle(GdZiche.ZicheMotherinlaw);
|
|
//获取子车是否有任务来该位置取货
|
Dt_Task Muche2Task = _taskService.OutPickupZiche(zichestation.ChildPosiDeviceCode.ToString());
|
if (Muche2Task != null) return;
|
GetStackerObject getStackerObject = GetDeviceAddress.GetChildDeviceCode(zichestation.ChildPosiDeviceCode);
|
|
if (getStackerObject.StaclerkJobJobStatusValue != RGV_Rgvtaskstutas.Executing && getStackerObject.RgvCraneAutoStatusValue == RgvCraneAutoStatus.Automatic
|
&& (getStackerObject.RGVCurrentlocation == zichestation.WaitmomentOne || getStackerObject.RGVCurrentlocation == zichestation.WaitmomentTwo || getStackerObject.RGVCurrentlocation==1171) && getStackerObject.RGVCurrentlocation != zichestation.ZicheMotherinlaw)
|
{
|
RGVMovetask(GdZiche.Motherinlaw, GdZiche.ChildPosiDeviceCode);
|
}
|
}
|
else if (GdZiche.Station_material == (int)RGVEquipment.Corridorcar)
|
{
|
if (RgvCraneStatusValue == (int)RgvEquipmentStatus.HasCargo) return;
|
if (GdZiche.Station_Area == 5)
|
{
|
if (GdZiche.MotherCardeputy == RGVCurrentlocation || GdZiche.HCJStorageaddress == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentTwo, GdZiche.ChildPosiDeviceCode);
|
}
|
else if (GdZiche.MotherCarDeviceCode == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentOne, GdZiche.ChildPosiDeviceCode);
|
}
|
}
|
else
|
{
|
if (GdZiche.MotherCarDeviceCode == RGVCurrentlocation || GdZiche.HCJStorageaddress == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentOne, GdZiche.ChildPosiDeviceCode);
|
}
|
else if (GdZiche.MotherCardeputy == RGVCurrentlocation || RGVCurrentlocation == 1171)
|
{
|
RGVMovetask(GdZiche.WaitmomentTwo, GdZiche.ChildPosiDeviceCode);
|
}
|
}
|
}
|
}
|
#endregion
|
|
#region 入库小车移动任务下发(已完成)
|
public void InReturnposition(string DeviceCode, int RGVCurrentlocation, int RgvCraneStatusValue)
|
{
|
AGVStation GdZiche = _agvStationService.Corridorequipment(DeviceCode);//获取到要移动的子车
|
if (GdZiche.Station_material == (int)RGVEquipment.Corridorcar)
|
{
|
if (GdZiche.Station_Area == 5)
|
{
|
Dt_Task task = _taskService.GetChariotTaskBool(GdZiche.ChildPosiDeviceCode);
|
if (task == null && RgvCraneStatusValue == (int)RgvEquipmentStatus.NoCargo)
|
{
|
if (GdZiche.MotherCarDeviceCode == RGVCurrentlocation || GdZiche.HCJStorageaddress == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentOne, GdZiche.ChildPosiDeviceCode);
|
}
|
else if (GdZiche.MotherCardeputy == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentTwo, GdZiche.ChildPosiDeviceCode);
|
}
|
}
|
|
}
|
else
|
{
|
Dt_Task task = _taskService.GetChariotTaskBool(GdZiche.ChildPosiDeviceCode);
|
if (task == null && RgvCraneStatusValue == (int)RgvEquipmentStatus.NoCargo)
|
{
|
if (GdZiche.HCJStorageaddress == RGVCurrentlocation)
|
{
|
//如果在2巷道的母车，则可以放子车来1号等待点，如果在HCJ则可以让子车去2号
|
RGVMovetask(GdZiche.WaitmomentTwo, GdZiche.ChildPosiDeviceCode);
|
}
|
else if (GdZiche.MotherCarDeviceCode == RGVCurrentlocation || GdZiche.MotherCardeputy == RGVCurrentlocation)
|
{
|
RGVMovetask(GdZiche.WaitmomentOne, GdZiche.ChildPosiDeviceCode);
|
}
|
else if (RGVCurrentlocation == 1021)
|
{
|
//加入判断，如果在1021站台，则需要判断1号巷道母车是否在堆垛机取货口
|
var zichestation = _agvStationService.GetMothervehicle(GdZiche.MotherCarDeviceCode);
|
int ziche = GetDeviceAddress.GetEquipmentlocation(zichestation.ChildPosiDeviceCode);
|
if (GetDeviceAddress.Mucheywhaddres(zichestation.ChildPosiDeviceCode) && (ziche == zichestation.ZicheMotherinlaw || ziche == zichestation.Motherinlaw))
|
{
|
RGVMovetask(GdZiche.WaitmomentOne, GdZiche.ChildPosiDeviceCode);
|
}
|
|
}
|
}
|
}
|
}
|
}
|
#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.TaskType switch
|
{
|
_ when task.TaskType == (int)TaskInboundTypeEnum.Inbound
|
=> InRgvLocaaddres(task),
|
_ when task.TaskType == (int)TaskOutboundTypeEnum.Outbound
|
=> RgvLocaaddres(task),
|
_ => (short)0
|
};
|
if (locaticurr == 0) return null;
|
|
stackerCraneTaskCommand.RGV_RGVTasklocation = locaticurr;
|
stackerCraneTaskCommand.RGV_RGVtasktype = (short)task.RGVTaskType;
|
stackerCraneTaskCommand.RGV_Rgvtaskid = (short)task.TaskNum;
|
stackerCraneTaskCommand.RGV_Lanjiantaskid = (short)task.TaskNum;
|
return stackerCraneTaskCommand;
|
}
|
|
public short InRgvLocaaddres(Dt_Task dt_Task)
|
{
|
if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.PickingUp) return short.Parse(dt_Task.CurrentAddress);
|
else if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.Placing) return short.Parse(dt_Task.NextAddress);
|
else if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && dt_Task.TaskState == (int)TaskInStatusEnum.RGV_InZicheReleaseFinish) return short.Parse(dt_Task.NextAddress);
|
return 0;
|
}
|
public short RgvLocaaddres(Dt_Task dt_Task)
|
{
|
if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.PickingUp) return short.Parse(dt_Task.CurrentAddress);
|
else if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.Placing) return short.Parse(dt_Task.NextAddress);
|
else if (dt_Task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && dt_Task.TaskState == (int)TaskOutStatusEnum.OutNew) return short.Parse(dt_Task.NextAddress);
|
return 0;
|
}
|
|
|
/// <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 = 30001; //rgv任务号
|
stackerCraneTaskCommand.RGV_Lanjiantaskid = 30001; //兰剑任务id
|
return stackerCraneTaskCommand;
|
}
|
public bool SendCommand2(RgvCraneTaskCommand command, string DeviceCode)
|
{
|
try
|
{
|
IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == DeviceCode);
|
SpeStackerCrane Commonstacker = (SpeStackerCrane)device;
|
|
DeviceProDTO? deviceProDTO = GetDeviceAddress.GetRGVDeviceProDTO(Commonstacker, DeviceCode, "RGV_Rgvtaskstutas");
|
int MCGStatus = GetDeviceAddress.RGVGetLine(Commonstacker, deviceProDTO.DeviceProAddress);
|
|
|
if (MCGStatus == 0)
|
{
|
if (MCGStatus == (int)RGV_Rgvtaskstutas.Ready)
|
{
|
Commonstacker.SetValue(RgvCraneDBName.RGV_RGVTasklocationt, command.RGV_RGVTasklocation);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_RGVtasktypet, command.RGV_RGVtasktype);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_Rgvtaskidt, command.RGV_Rgvtaskid);
|
Commonstacker.SetValue(RgvCraneDBName.RGV_Lanjiantaskidt, command.RGV_Lanjiantaskid);
|
return true;
|
}
|
}
|
return false;
|
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
|
|
}
|
}
|
