高翔 / ECS-ZJHX · Files

using HHECS.Application.Enums;
using HHECS.Application.Error;
using HHECS.BllModel;
using HHECS.Communication;
using HHECS.Communication.PLC;
using HHECS.Dal;
using HHECS.DAL.Repository;
using HHECS.Executor;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Model.Entities;
using HHECS.Model.Enums.Task;
using System;
using System.Collections.Generic;
using System.Linq;

namespace HHECS.Executor.EquipmentHandler.Truss
{
    /// <summary>
    /// 标准桁车实现
    /// </summary>
    public class TrussNormalExcute : TrussExcute
    {
        /// <summary>
        /// 桁架的安全距离是4000，不同的桁架对同一个点位有100的误差，所以改为4100
        /// </summary>
        public int SafetyDistance = 41000;

        //循环记录
        private static int excuteCount = 0;

        public TrussNormalExcute(EquipmentType equipmentType) : base(equipmentType)
        {
        }

        public override BllResult Excute(List<Equipment> trusses, List<Equipment> allEquipments, PLCCore plc,  User user)
        {
            try
            {
                BllResult result = null;
                if (trusses.Count == 0)
                {
                    return BllResultFactory.Error($"没有【{this.EquipmentType.Name}】类型的设备，所以不执行处理程序。");
                }

                //先初始化桁车运行距离数据
                var initResult = Init(trusses);

                var trussTaskStatus = (int)TaskTrussStatus.TaskCompleted;
                var taskTrussEntityRepository = new BusTaskTrussRepository();
                var taskTrussList = taskTrussEntityRepository.Where(t => t.Status < trussTaskStatus).ToList();

                IOrderedEnumerable<Equipment> trussesOrder = null;
                excuteCount++;
                // 避免一个桁架不停的执行任务，两边轮流执行
                if (excuteCount % 2 == 0)
                {
                    excuteCount = 0;
                    trussesOrder = trusses.OrderByDescending(t => t.Id);
                }
                else
                {
                    trussesOrder = trusses.OrderBy(t => t.Id);
                }

                //有货的优先放到前面处理
                var excuteTrusses = trussesOrder.OrderByDescending(t => t[TrussNormalProps.ForkHasPallet.ToString()].Value == "True").ToList();
                foreach (var truss in excuteTrusses)
                {
                    //执行任务
                    result = ExcuteTask(truss, allEquipments, taskTrussList, plc, user);
                    if (result != null)
                    {
                        OnEquipmentExecuteLog(result.Code, truss, result.Msg, result.ErrorCode);
                        result = BllResultFactory.Success();
                    }
                }

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"桁车处理过程中出现异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 初始化桁车运行距离
        /// </summary>
        /// <param name="trusses"></param>
        /// <returns></returns>
        public BllResult Init(List<Equipment> trusses)
        {
            try
            {
                foreach (var truss in trusses)
                {
                    var wcsTaskFlag = truss[TrussNormalProps.WCSTaskFlag.ToString()].Value;
                    if (truss.RowIndex1 == 0 || truss.RowIndex2 == 0)
                    {
                        // 如果任务类型是 取货、放货、行走，那么就把任务的运行距离写入RowIndex1和RowIndex2
                        if (wcsTaskFlag == TrussTaskFlag.Take.GetIndexString() || wcsTaskFlag == TrussTaskFlag.Put.GetIndexString() || wcsTaskFlag == TrussTaskFlag.Walk.GetIndexString())
                        {
                            // 任务的最小距离
                            int taskSmallDistance = 0;
                            // 任务的最大距离
                            int taskBigDistance = 0;
                            var currentDistance = Convert.ToInt32(truss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                            //如果是行走任务，那么运行距离就是从当前点位到目的点位
                            if (wcsTaskFlag == TrussTaskFlag.Walk.GetIndexString())
                            {
                                var wcsMoverPosition = Convert.ToInt32(truss[TrussNormalProps.WCSMoverPosition.ToString()].Value);
                                var moverStation = truss.WorkStationList.FirstOrDefault(t => t.PutLocation == wcsMoverPosition || t.TakeLocation == wcsMoverPosition);
                                if (moverStation == null)
                                {
                                    return BllResultFactory.Error($"初始化桁车{truss.Name}运行距离出现错误：根据位置[{wcsMoverPosition}]找不到任务目的站台");
                                }
                                taskSmallDistance = currentDistance;
                                taskBigDistance = moverStation.Distance;
                            }
                            // 如果是取货、放货任务，那么运行距离就是从取货点位到放货点位
                            if (wcsTaskFlag == TrussTaskFlag.Take.GetIndexString() || wcsTaskFlag == TrussTaskFlag.Put.GetIndexString())
                            {
                                var wcsTakePosition = Convert.ToInt32(truss[TrussNormalProps.WCSTakePosition.ToString()].Value);
                                var takeStation = truss.WorkStationList.FirstOrDefault(t => t.TakeLocation == wcsTakePosition);
                                if (takeStation == null)
                                {
                                    return BllResultFactory.Error($"初始化桁车{truss.Name}运行距离，出现错误：根据位置[{wcsTakePosition}]找不到取货站台");
                                }
                                var wcsPutPosition = Convert.ToInt32(truss[TrussNormalProps.WCSPutPosition.ToString()].Value);
                                var putStation = truss.WorkStationList.FirstOrDefault(t => t.PutLocation == wcsPutPosition);
                                if (putStation == null)
                                {
                                    return BllResultFactory.Error($"初始化桁车{truss.Name}运行距离，出现错误：根据位置[{wcsPutPosition}]找不到放货站台");
                                }
                                taskSmallDistance = takeStation.Distance;
                                taskBigDistance = putStation.Distance;
                            }

                            // 如果 最小距离 大于 最大距离，就要对调下
                            if (taskSmallDistance > taskBigDistance)
                            {
                                int temp = taskSmallDistance;
                                taskSmallDistance = taskBigDistance;
                                taskBigDistance = temp;
                            }

                            // 运行安全的最小距离
                            int safetySmallDistance = taskSmallDistance - SafetyDistance;
                            // 运行安全的最大距离
                            int safetyBigDistance = taskBigDistance + SafetyDistance;

                            //如果桁车的当前距离比任务的最小距离还小，就把运行距离拉大
                            if (currentDistance < safetySmallDistance)
                            {
                                taskSmallDistance = currentDistance;
                                safetySmallDistance = currentDistance;
                            }
                            //如果桁车的当前距离比任务的最大距离还大，就把运行距离拉大
                            if (currentDistance > safetyBigDistance)
                            {
                                taskBigDistance = currentDistance;
                                safetyBigDistance = currentDistance;
                            }
                            //写入桁车任务运行距离
                            truss.RowIndex1 = taskSmallDistance;
                            truss.RowIndex2 = taskBigDistance;
                        }
                    }
                    else
                    {
                        if (wcsTaskFlag == TrussTaskFlag.NoTask.GetIndexString())
                        {
                            //清除桁车任务运行距离
                            truss.RowIndex1 = 0;
                            truss.RowIndex2 = 0;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Error, ex, $"初始化桁车运行距离的时候，产生异常：${ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
            return BllResultFactory.Success();
        }


        /// <summary>
        /// 执行桁车任务
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteTask(Equipment truss, List<Equipment> allEquipments, List<BusTaskTruss> taskTrussList, PLCCore plc, User user)
        {
            var trussValidate = Validate(truss);
            if (trussValidate.Success)
            {
                #region 桁车任务执行判断
                if (truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()].Value == TrussTaskExcuteStatus.TaskExecuting.GetIndexString())
                {
                    //任务执行中就return
                    return BllResultFactory.Success();
                }
                if (truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()].Value == TrussTaskExcuteStatus.TaskInterruptError.GetIndexString())
                {
                    //由人工处理，一般为空出和重入
                    return BllResultFactory.Success();
                }
                if (truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()].Value == TrussTaskExcuteStatus.TaskSendError.GetIndexString())
                {
                    //由人工处理，需要重新下发任务
                    return BllResultFactory.Success();
                }
                #endregion

                EquipmentProp forkTaskExcuteStatus = truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()];
                EquipmentProp wcsTaskFlag = truss[TrussNormalProps.WCSTaskFlag.ToString()];

                //待机情况下
                if (forkTaskExcuteStatus.Value == TrussTaskExcuteStatus.Standby.GetIndexString())
                {
                    //货叉任务待机时，可执行放和取任务，同时当执行完成时，交互后货叉1会从任务完成更新为待机
                    if (wcsTaskFlag.Value == TrussTaskFlag.TaskComplete.GetIndexString() || wcsTaskFlag.Value == TrussTaskFlag.TaskDelete.GetIndexString())
                    {
                        var sendResult = ClearWCSData(truss, plc);
                        return sendResult;
                    }
                    //桁车无任务，也没有下发过任务
                    if (wcsTaskFlag.Value == TrussTaskFlag.NoTask.GetIndexString())
                    {
                        #region 优先处理重新下发的任务

                        // 如果已经下发了放货任务，又重新下任务，并且货叉有货，那么就重发放货指令
                        var taskForResend = taskTrussList.FirstOrDefault(t => t.Status == TaskTrussStatus.SendPut.GetIndexInt() && t.SendAgain == 1 && t.TrussCode == truss.Code);
                        if (taskForResend != null && truss[TrussNormalProps.ForkHasPallet.ToString()].Value == "True")
                        {
                            var check = Check(truss, allEquipments, taskForResend, plc);
                            if (check.Success)
                            {
                                return ReSendTask(truss, plc, taskForResend, TrussTaskFlag.Put);
                            }
                            else
                            {
                                return check;
                            }
                        }

                        // 如果已经下发了取货任务，又重下任务的，并且货叉无货，那么就重发放货指令
                        taskForResend = taskTrussList.FirstOrDefault(t => t.Status == TaskTrussStatus.SendTake.GetIndexInt() && t.SendAgain == 1 && t.TrussCode == truss.Code);
                        if (taskForResend != null && truss[TrussNormalProps.ForkHasPallet.ToString()].Value == "False")
                        {
                            var avoid = Avoid(truss, allEquipments, plc);
                            //如果需要避让，先执行避让程序
                            if (avoid.Success == false)
                            {
                                return avoid;
                            }
                            var check = Check(truss, allEquipments, taskForResend, plc);
                            if (check.Success)
                            {
                                return ReSendTask(truss, plc, taskForResend, TrussTaskFlag.Take);
                            }
                            else
                            {
                                return check;
                            }
                        }

                        #endregion

                        //判断桁车货叉上是不是有货，有货就只能接受放货任务，无货就可以接受取货任务
                        if (truss[TrussNormalProps.ForkHasPallet.ToString()].Value == "True")
                        {
                            //有货，则查找同巷道的取货任务完成状态的任务，同一个桁车，单叉情况下最多一条
                            #region 判断是否超出一条
                            if (taskTrussList.Count(t => t.Status == TaskTrussStatus.ResponseTakeCompleted.GetIndexInt() && t.TrussCode == truss.Code) > 1)
                            {
                                return BllResultFactory.Error($"桁车{truss.Name}显示货叉上有货，但是对应的任务超过1条，请检查状态为{TaskTrussStatus.ResponseTakeCompleted}的任务");
                            }
                            #endregion

                            //添加任务号进行判断
                            int taskTrussId = int.Parse(truss[TrussNormalProps.ForkTaskCode.ToString()].Value);
                            //先找响应桁车取货完成的任务
                            var taskTruss = taskTrussList.FirstOrDefault(t => t.Status == TaskTrussStatus.ResponseTakeCompleted.GetIndexInt() && t.TrussCode == truss.Code);
                            if (taskTruss == null)
                            {
                                //如果还是没有找到任务，那就说明的确没有这条任务，或是人为原因导致的，但此时又显示货叉有货，所以这里是有问题的，做个日志
                                return BllResultFactory.Error($"桁车{truss.Name}显示货叉上有货，但是没有对应的任务");
                            }
                            else
                            {
                                if (taskTruss.Id != taskTrussId)
                                {
                                    return BllResultFactory.Error($"桁车{truss.Name}显示货叉上有货，但是桁车任务号[{taskTrussId}]和和数据库库中任务号[{taskTruss.StepTraceId}]不一致，请核对数据！");
                                }
                                var check = Check(truss, allEquipments, taskTruss, plc);
                                if (check.Success)
                                {
                                    //下发放货任务
                                    return SendTaskToStation(truss, plc, taskTruss, TaskTrussStatus.SendPut, TrussTaskFlag.Put);
                                }
                                else
                                {
                                    return check;
                                }
                            }
                        }
                        else
                        {
                            var excutingStepTrace = taskTrussList.FirstOrDefault(t => (t.Status == TaskTrussStatus.SendTake.GetIndexInt() || t.Status == TaskTrussStatus.ResponseTakeCompleted.GetIndexInt() || t.Status == TaskTrussStatus.SendPut.GetIndexInt()) && t.TrussCode == truss.Code);
                            if (excutingStepTrace != null)
                            {
                                return BllResultFactory.Error($"桁车{truss.Name}有任务[{excutingStepTrace.Id}]还在执行中，不能自动下发新任务！");
                            }
                            //如果需要避让，先执行避让程序
                            var avoid = Avoid(truss, allEquipments, plc);
                            if (avoid.Success == false)
                            {
                                return avoid;
                            }
                            var taskTruss = taskTrussList.FirstOrDefault(t => t.Status == TaskTrussStatus.TaskCreate.GetIndexInt() && t.TrussCode == truss.Code);
                            if (taskTruss != null)
                            {
                                var check = Check(truss, allEquipments, taskTruss, plc);
                                if (check.Success)
                                {
                                    //下发取货任务
                                    return SendTaskToStation(truss, plc, taskTruss, TaskTrussStatus.SendTake, TrussTaskFlag.Take);
                                }
                                else
                                {
                                    return check;
                                }
                            }
                            //如果空闲无任务就去避让点
                            var CurrentTongs = truss[TrussNormalProps.CurrentTongs.ToString()].Value;
                            if (CurrentTongs != truss.WorkStation.TakeLocation.ToString())
                            {
                                return ToAvoidStation(truss, allEquipments, plc);
                            }
                        }
                    }

                    return BllResultFactory.Success();
                }
                else if (forkTaskExcuteStatus.Value == TrussTaskExcuteStatus.TaskCompleted.GetIndexString() && wcsTaskFlag.Value != TrussTaskFlag.TaskComplete.GetIndexString())
                {
                    //一共3种完成情况
                    //根据任务号和任务类型进行任务完成处理
                    EquipmentProp forkTaskType = truss[TrussNormalProps.ForkTaskType.ToString()];
                    var taskTrussId = int.Parse(truss[TrussNormalProps.ForkTaskCode.ToString()].Value);
                    var taskTruss = taskTrussList.FirstOrDefault(t => t.Id == taskTrussId);

                    if (taskTruss == null || forkTaskType.Value == TrussTaskFlag.Walk.GetIndexString())
                    {
                        truss.RowIndex1 = 0;
                        truss.RowIndex2 = 0;
                        var prop = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                        prop.Value = TrussTaskFlag.TaskComplete.GetIndexString();
                        var sendResult = plc.Write(prop);
                        if (sendResult.Success)
                        {
                            if (forkTaskType.Value == TrussTaskFlag.Walk.GetIndexString())
                            {
                                return BllResultFactory.Success($"桁车{truss.Name}完成机械手行走成功，任务:{taskTrussId}");
                            }
                            else
                            {
                                return BllResultFactory.Create(BllResultCode.Warning, $"根据桁车任务[{taskTrussId}]未找到【机械手取货、机械手放货】任务，直接完成！");
                            }
                        }
                        else
                        {
                            return BllResultFactory.Error($"桁车{truss.Name}完成机械手行走写入PLC失败，原因：{sendResult.Msg}，任务:{taskTrussId}");
                        }
                        #region 旧写法
                        //var rowIndex1 = truss.RowIndex1;
                        //var rowIndex2 = truss.RowIndex2;

                        //EquipmentRepository equipmentRepository = new EquipmentRepository();
                        //equipmentRepository.Attach(truss);
                        //truss.RowIndex1 = 0;
                        //truss.RowIndex2 = 0;
                        //using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                        //{
                        //    try
                        //    {
                        //        equipmentRepository.UnitOfWork = uw;
                        //        equipmentRepository.Update(truss);

                        //        var prop = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                        //        prop.Value = TrussTaskFlag.任务完成.GetIndexString();
                        //        var sendResult = plc.Write(prop);
                        //        if (sendResult.Success)
                        //        {
                        //            uw?.Commit();
                        //            if (forkType == TrussTaskFlag.机械手行走.GetIndexString())
                        //            {
                        //                return BllResultFactory.Success($"桁车{truss.Name}完成机械手行走成功，任务:{stepTraceId}");
                        //            }
                        //            else
                        //            {
                        //                return BllResultFactory.Warning($"根据桁车任务[{stepTraceId}]未找到【机械手取货、机械手放货】任务，直接完成！");
                        //            }
                        //        }
                        //        else
                        //        {
                        //            uw?.Rollback();
                        //            truss.RowIndex1 = rowIndex1;
                        //            truss.RowIndex2 = rowIndex2;
                        //            return BllResultFactory.Error($"桁车{truss.Name}完成机械手行走写入PLC失败，原因：{sendResult.Msg}，任务:{stepTraceId}");
                        //        }
                        //    }
                        //    catch (Exception ex)
                        //    {
                        //        uw?.Rollback();
                        //        truss.RowIndex1 = rowIndex1;
                        //        truss.RowIndex2 = rowIndex2;
                        //        return BllResultFactory.Exception($"桁车{truss.Name}完成机械手行走失败，原因：{ex.Message}，任务:{stepTraceId}", ex);
                        //    }
                        //}
                        #endregion
                    }
                    if (forkTaskType.Value == TrussTaskFlag.Take.GetIndexString())
                    {
                        BusTaskTrussRepository taskTrussRepository = new BusTaskTrussRepository();
                        taskTrussRepository.Attach(taskTruss);
                        //更新任务状态
                        taskTruss.Status = TaskTrussStatus.ResponseTakeCompleted.GetIndexInt();
                        taskTruss.Type = TrussTaskFlag.Put.GetIndexInt();
                        taskTruss.UpdateBy = user.UserCode;
                        taskTruss.UpdateTime = DateTime.Now;

                        using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                        {
                            try
                            {
                                taskTrussRepository.UnitOfWork = uw;
                                taskTrussRepository.Update(taskTruss);

                                var prop = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                                prop.Value = TrussTaskFlag.TaskComplete.GetIndexString();
                                var sendResult = plc.Write(prop);
                                if (sendResult.Success)
                                {
                                    uw?.Commit();
                                    return BllResultFactory.Success($"桁车{truss.Name}响应桁车取货任务[{taskTrussId}]完成成功");
                                }
                                else
                                {
                                    uw?.Rollback();
                                    return BllResultFactory.Error($"桁车{truss.Name}响应桁车取货任务[{taskTrussId}]完成失败，原因：{sendResult.Msg}");
                                }
                            }
                            catch (Exception ex)
                            {
                                uw?.Rollback();
                                return BllResultFactory.Create(BllResultCode.Error, ex, $"桁车{truss.Name}响应桁车取货任务[{taskTrussId}]完成发生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                            }
                        }
                    }
                    else if (forkTaskType.Value == TrussTaskFlag.Put.GetIndexString())
                    {
                        BusTaskTrussRepository taskTrussRepository = new BusTaskTrussRepository();
                        //BaseStepTraceRepository baseStepTraceRepository = new BaseStepTraceRepository();
                        taskTrussRepository.Attach(taskTruss);
                        taskTruss.Status = TaskTrussStatus.ResponsePutCompleted.GetIndexInt();
                        taskTruss.Type = TrussTaskFlag.TaskComplete.GetIndexInt();
                        taskTruss.EndTime = DateTime.Now;
                        taskTruss.UpdateBy = user.UserCode;
                        taskTruss.UpdateTime = DateTime.Now;
                        //var stepTrace = DALHelper.GetRepository<BaseStepTrace>().Where(u => u.Id == taskTrussId).First();
                        //if (stepTrace == null)
                        //{
                        //    return BllResultFactory.Error($"桁车{truss.Name}响应桁车取货任务[{taskTrussId}]没有找到对应的任务");
                        //}
                        //stepTrace.Status = (int)StepTraceStatus.人工确认位置;
                        using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                        {
                            try
                            {

                                //baseStepTraceRepository.UnitOfWork = uw;
                                taskTrussRepository.UnitOfWork = uw;
                                //baseStepTraceRepository.Update(stepTrace);
                                taskTrussRepository.Update(taskTruss);

                                var prop = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                                prop.Value = TrussTaskFlag.TaskComplete.GetIndexString();
                                var sendResult = plc.Write(prop);
                                if (sendResult.Success)
                                {
                                    uw?.Commit();
                                    return BllResultFactory.Success($"桁车[{truss.Name}]响应桁车放货任务[{taskTrussId}]完成成功");
                                }
                                else
                                {
                                    uw?.Rollback();
                                    return BllResultFactory.Error($"桁车[{truss.Name}]响应桁车放货任务[{taskTrussId}]完成失败，原因：{sendResult.Msg}");
                                }
                            }
                            catch (Exception ex)
                            {
                                uw?.Rollback();
                                return BllResultFactory.Create(BllResultCode.Error, ex, $"桁车[{truss.Name}]响应桁车放货任务[{taskTrussId}]完成的时候发生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                            }
                        }
                    }

                    return BllResultFactory.Success();
                }
                else
                {
                    //未知情况
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}执行中，执行状态为：{truss[TrussNormalProps.ForkTaskExcuteStatus.ToString()].Value}可能由于ECS还未处理造成");
                }
            }
            else
            {
                return trussValidate;
            }
        }

        /// <summary>
        /// 检查桁车任务是否可以执行，并且生成其他桁车的避让
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTrace"></param>
        /// <returns></returns>
        private BllResult Check(Equipment truss, List<Equipment> allEquipments, BusTaskTruss taskTruss, PLCCore plc)
        {
            try
            {
                if (taskTruss.ProductType < 1)
                {
                    return BllResultFactory.Error($"检查桁车{truss.Name}任务是否可以执行执行的时候，出现错误：任务id[{taskTruss.Id}]对应的工件类型不是大于1的整数！");
                }
                var fromStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.FromStationCode);
                var toStationCode = truss.WorkStationList.FirstOrDefault(t => t.WorkStationCode == taskTruss.ToStationCode);
                if (fromStationCode == null)
                {
                    return BllResultFactory.Error($"检查桁车{truss.Name}任务是否可以执行执行的时候，出现错误：找不到任务起始站台[{taskTruss.FromStationCode}]");
                }
                if (toStationCode == null)
                {
                    return BllResultFactory.Error($"检查桁车{truss.Name}任务是否可以执行执行的时候，出现错误：找不到任务到达站台[{taskTruss.ToStationCode}]");
                }
                var currentDistance = Convert.ToInt32(truss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                // 任务的最小距离
                int taskSmallDistance = fromStationCode.Distance;
                // 任务的最大距离
                int taskBigDistance = toStationCode.Distance;

                // 如果 最小距离 大于 最大距离，就要对调下
                if (taskSmallDistance > taskBigDistance)
                {
                    int temp = taskSmallDistance;
                    taskSmallDistance = taskBigDistance;
                    taskBigDistance = temp;
                }

                // 运行安全的最小距离
                int safetySmallDistance = taskSmallDistance - SafetyDistance;
                // 运行安全的最大距离
                int safetyBigDistance = taskBigDistance + SafetyDistance;

                //如果桁车的当前距离比任务的最小距离还小，就把运行距离拉大
                if (currentDistance < safetySmallDistance)
                {
                    taskSmallDistance = currentDistance;
                    safetySmallDistance = currentDistance;
                }
                //如果桁车的当前距离比任务的最大距离还大，就把运行距离拉大
                if (currentDistance > safetyBigDistance)
                {
                    taskBigDistance = currentDistance;
                    safetyBigDistance = currentDistance;
                }

                //找出其他的桁架
                List<Equipment> trusses = allEquipments.Where(t => t.EquipmentTypeId == truss.EquipmentTypeId && t.Id != truss.Id).ToList();

                #region  找出有避让任务的桁车，来判断是否会阻挡当前任务
                List<Equipment> avoidTrusses = trusses.Where(t => t[TrussNormalProps.ForkTaskCode.ToString()].Value == Int32.MaxValue.ToString()).ToList();
                foreach (var avoidTruss in avoidTrusses)
                {
                    int avoidTrussDistance = int.Parse(avoidTruss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                    // 如果无任务的桁车阻挡了要执行的路劲，就调走该桁车
                    if (avoidTrussDistance >= safetySmallDistance && avoidTrussDistance <= safetyBigDistance)
                    {
                        //如果目标路径有任务了，就先不执行，等到任务完成了再执行本条任务
                        return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}执行任务{taskTruss.Id}需要运行{safetySmallDistance}到{safetyBigDistance}之间的路劲，该路径内有桁车{avoidTruss.Name}正在避让，需要等待！");
                    }
                }
                #endregion
                #region 找出有任务的桁车（避让任务除外），来判断是否会阻挡当前任务
                var avoidTrussesId = avoidTrusses.Select(t => t.Id).ToArray();
                List<Equipment> excuteTrusses = trusses.Where(t => t.RowIndex2 > 0 && !avoidTrussesId.Contains(t.Id)).ToList();

                // 找出任务的运行区间存在的桁车任务
                var excutingTruss = excuteTrusses.FirstOrDefault(t => (t.RowIndex1 >= safetySmallDistance && t.RowIndex1 <= safetyBigDistance)
                                                                     || (t.RowIndex2 >= safetySmallDistance && t.RowIndex2 <= safetyBigDistance)
                                                                     || (t.RowIndex1 < safetySmallDistance && t.RowIndex2 > safetyBigDistance));
                if (excutingTruss != null)
                {
                    //如果目标路径有任务了，就先不执行，等到任务完成了再执行本条任务
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}执行任务{taskTruss.Id}需要运行{safetySmallDistance}到{safetyBigDistance}之间的路劲，该路径内有桁车{excutingTruss.Name}正在执行任务，需要等待！");
                }
                #endregion
                #region 找出无任务的桁车，来判断是否会阻挡当前任务
                List<Equipment> freeTrusses = trusses.Where(t => t.RowIndex2 == 0).ToList();
                foreach (var freeTruss in freeTrusses)
                {
                    int freeTrussesDistance = int.Parse(freeTruss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                    // 如果无任务的桁车阻挡了要执行的路劲，就调走该桁车
                    if (freeTrussesDistance >= safetySmallDistance && freeTrussesDistance <= safetyBigDistance)
                    {
                        ToAvoidStation(freeTruss, allEquipments, plc);
                        return BllResultFactory.Create(BllResultCode.Warning, $"桁车[{truss.Name}]任务运行范围从{safetySmallDistance}到{safetyBigDistance}，给桁车[{freeTruss.Name}]下主动避让任务");
                    }
                }
                #endregion
                truss.RowIndex1 = taskSmallDistance;
                truss.RowIndex2 = taskBigDistance;
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Error, ex, $"检查桁车[{truss.Name}]任务是否可以执行执行的时候，产生异常：${ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 检查本桁车是否需要避让其他桁车，如果需要就下发 机械手行走 来避让其他桁架，并且返回是否需要避让的判断
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTrace"></param>
        /// <param name="plc"></param>
        /// <returns>是否需要避让</returns>
        private BllResult Avoid(Equipment truss, List<Equipment> allEquipments, PLCCore plc)
        {
            try
            {
                var currentDistance = Convert.ToInt32(truss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                // 找出其他的桁架
                List<Equipment> trusses = allEquipments.Where(t => t.EquipmentTypeId == truss.EquipmentTypeId && t.Id != truss.Id).ToList();
                // 找出有避让任务的桁车
                List<Equipment> avoidTrusses = trusses.Where(t => t[TrussNormalProps.ForkTaskCode.ToString()].Value == Int32.MaxValue.ToString()).ToList();
                var avoidTrussesId = avoidTrusses.Select(t => t.Id).ToArray();
                // 找出有任务的桁车（避让任务除外）
                List<Equipment> excuteTrusses = trusses.Where(t => t.RowIndex2 > 0 && !avoidTrussesId.Contains(t.Id)).ToList();
                // 如果当前桁车挡住了其他桁车路劲，就去避让点等待
                var excuteTruss = excuteTrusses.FirstOrDefault(t => currentDistance >= t.RowIndex1 - SafetyDistance && currentDistance <= t.RowIndex2 + SafetyDistance);
                if (excuteTruss != null)
                {
                    ToAvoidStation(truss, allEquipments, plc);
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车[{excuteTruss.Name}]任务运行范围从{excuteTruss.RowIndex1}到{excuteTruss.RowIndex2}，桁车[{truss.Name}]开始主动避让");
                }
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Error, ex, $"桁车{truss.Name}执行避让程序的时候，产生异常：${ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 下发 桁架 到避让站台的任务
        /// </summary>
        /// <param name="truss"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTrace"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        private BllResult ToAvoidStation(Equipment truss, List<Equipment> allEquipments, PLCCore plc)
        {
            try
            {
                var trussValidate = Validate(truss);
                if (!trussValidate.Success)
                {
                    return BllResultFactory.Create(BllResultCode.Warning, $"{trussValidate.Msg}，不能生成避让任务移开，需等待！");
                }
                //判断桁车货叉上是不是有货，有货就不避让，无货才避让
                if (truss[TrussNormalProps.ForkHasPallet.ToString()].Value == "True")
                {
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}有货，不能生成避让任务移开，需等待该桁车任务完成！");
                }
                //判断桁车状态不是“任务完成”、“删除任务” 才可以避让 （等待ECS确认任务完成得时候，桁车也是空闲）
                EquipmentProp fork1TaskFlag = truss[TrussNormalProps.WCSTaskFlag.ToString()];
                if (fork1TaskFlag.Value == TrussTaskFlag.TaskComplete.GetIndexString())
                {
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}是{TrussTaskFlag.TaskComplete}状态，需要等待ECS确认，然后才能下发移车任务！");
                }
                else if (fork1TaskFlag.Value == TrussTaskFlag.TaskDelete.GetIndexString())
                {
                    return BllResultFactory.Create(BllResultCode.Warning, $"桁车{truss.Name}是{TrussTaskFlag.TaskDelete}状态，需要等待ECS确认，然后才能下发移车任务！");
                }
                if (truss.WorkStation == null)
                {
                    return BllResultFactory.Error($"桁车[{truss.Name}]没有避让站台");
                }
                var currentDistance = Convert.ToInt32(truss[TrussNormalProps.HorizontalDistance.ToString()].Value);
                truss.RowIndex1 = currentDistance;
                truss.RowIndex2 = truss.WorkStation.Distance;
                //下发桁车行走任务
                BllResult sendResult = SendTaskToTruss(truss, plc, TrussTaskFlag.Walk, 0, 0, 0, truss.WorkStation.TakeLocation, Int32.MaxValue);
                if (sendResult.Success)
                {
                    return BllResultFactory.Success($"桁车[{truss.Name}]去站台[{truss.WorkStation.WorkStationName}]的[机械手行走]任务下发成功！");
                }
                else
                {
                    truss.RowIndex1 = 0;
                    truss.RowIndex2 = 0;
                    return BllResultFactory.Error($"桁车[{truss.Name}]去站台[{truss.WorkStation.WorkStationName}]的[机械手行走]任务下发失败，写入PLC失败，原因：{sendResult.Msg}！");
                }

                #region 旧写法
                //var equipmentRepository = new EquipmentRepository();
                ////开始追踪实体变化
                //equipmentRepository.Attach(truss);
                //truss.RowIndex1 = currentDistance;
                //truss.RowIndex2 = truss.Station.Distance;

                //using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                //{
                //    try
                //    {
                //        equipmentRepository.UnitOfWork = uw;
                //        equipmentRepository.Update(truss);
                //        //下发桁车行走任务
                //        BllResult sendResult = SendTaskToTruss(truss, plc, TrussTaskFlag.机械手行走, 0, truss.Station.TakeLocation, 0, Int32.MaxValue);
                //        if (sendResult.Success)
                //        {
                //            uw?.Commit();
                //            return BllResultFactory.Success($"桁车[{truss.Name}]去站台[{truss.Station.Name}]的[机械手行走]任务下发成功！");
                //        }
                //        else
                //        {
                //            truss.RowIndex1 = 0;
                //            truss.RowIndex2 = 0;
                //            uw?.Rollback();
                //            return BllResultFactory.Error($"桁车[{truss.Name}]去站台[{truss.Station.Name}]的[机械手行走]任务下发失败，写入PLC失败，原因：{sendResult.Msg}！");
                //        }
                //    }
                //    catch (Exception ex)
                //    {
                //        uw?.Rollback();
                //        return BllResultFactory.Exception($"桁车[{truss.Name}]下发去站台[{truss.Station.Name}]的[机械手行走]任务下发的时候，出现异常,原因：{ex.Message}", ex);
                //    }
                //}
                #endregion
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Error, ex, $"桁车[{truss.Name}]下发去站台[{truss.WorkStation.WorkStationName}]的[机械手行走]任务的时候，产生异常：${ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }






    }
}