using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    partial class DUOStoreBean
    {

        public bool InstoreEndSendShelf = false;
        public bool OutstoreEndSendShelf = false;

        public string CurrShelfNum = "0";
        /// <summary>
        /// 料架类型，0=空料架，1=入库料架，2=出库料架
        /// </summary>
        public int CurrShelfType = 0;
        /// <summary>
        /// 更新料架信息
        /// </summary>
        /// <param name="num">料架编号</param>
        /// <param name="type">料架类型，0=空料架，1=入库料架，2=出库料架</param>
        private void UpdateShelfNum(string num, int type)
        {

            CurrShelfNum = num;
            Properties.Settings1.Default.CurrShelfNum = num;
            //ConfigAppSettings.SaveValue(Setting_Init.CurrShelfNum, num);


            CurrShelfType = type;
            Properties.Settings1.Default.CurrShelfType = type;
            //ConfigAppSettings.SaveValue(Setting_Init.CurrShelfType, type);
            Properties.Settings1.Default.Save();
            if (type.Equals(0) || type.Equals(1))
            {
                outStoreCount = 0;
            }
            LogUtil.info(Name + $"更新料架信息:【" + CurrShelfNum + "】【" + CurrShelfType + "】");
        }

        protected override bool CheckWaitResult(StoreMoveInfo moveInfo, WaitResultInfo wait)
        {
            if (wait.WaitType.Equals(WaitEnum.W008_BatchAxis))
            {
                //等待信号亮或者走到绝对位置才停止
                if (IOValue(T1_BatchAxis.TargetIoType).Equals(T1_BatchAxis.TargetIoValue))
                {
                    LogUtil.debug(Name + "CheckWaitResult 检测到" + T1_BatchAxis.TargetIoType + "=" + T1_BatchAxis.TargetIoValue + ",停止运行");
                    T1_BatchAxis.StopAxisCheckMove();
                    if (AxisManager.instance.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(1))
                    {
                        T1_BatchAxis.SuddenStop();
                    }
                    return true;
                }
                else
                {
                    bool isOk = AxisManager.instance.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(0);
                    if (isOk)
                    {
                        //TODO 判断是否达到高度，如果未达到，继续上升
                        T1_BatchAxis.StopAxisCheckMove();
                        return true;
                    }
                }
            }
            else if (wait.WaitType.Equals(WaitEnum.W009_ScanCode))
            {
                if (scanTask == null)
                    return true;

                if (scanTask.IsCompleted)
                    return true;
                //if (LastCodeList.Count > 0)
                //{
                //    return true;
                //}
            }
            return false;
        }


        #region 料架出料
        public int outStoreCount = 0;
        public bool CanOut(bool IsStart = false)
        {
            if (isInSuddenDown || isNoAirCheck)
            {
                return false;
            }
            if (runStatus <= StoreRunStatus.Wait)
            {
                return false;
            }

            LogUtil.OutputDebugString($"CanOut MoveType:{MoveInfo.MoveType},IsStart:{IsStart},Line_WaitCheck:{IOValue(IO_Type.Line_WaitCheck)},{Config.AgvInName}:{AgvClient.GetAction(Config.AgvInName)},{AgvClient.GetShelf(Config.AgvInName)}");

            if (MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                return true;
            }
            else if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                if (IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
                {
                    if (CurrShelfType.Equals(0) || CurrShelfType.Equals(2))
                    {
                        if (IsStart)
                        {
                            return StartOutStoreMove(new InOutParam(MoveType.OutStore),false);
                        }
                        else
                        {
                            return true;
                        }
                    }
                }
            }
            bool isLineEmpty = IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.LOW);
            if (IsStart && isLineEmpty && (AgvClient.GetAction(Config.AgvInName) == Agv.ClientAction.None || AgvClient.GetAction(Config.AgvInName) == Agv.ClientAction.NeedEnter) && AgvClient.GetShelf(Config.AgvInName) != Agv.ClientShelf.Empty)
            {
                StoreManager.AgvNeedEmptyTime = DateTime.Now;
                AgvNeedInshelf = Agv.ClientShelf.Empty;
                AgvClient.SetToNone(Config.AgvInName);
                AgvClient.NeedEnter(Config.AgvInName, "", AgvNeedInshelf);
                LogUtil.info(Name + "CanOut AgvClient.NeedEnter" + Config.AgvInName + ",AgvNeedInshelf:" + AgvNeedInshelf);
                //AgvNeedInshelf = Agv.ClientShelf.None;
            }
            return false;
        }

        public override bool StartOutStoreMove(InOutParam param,bool shelfisready=false)
        {
            if (IOValue(IO_Type.RaiseStation_BackendCheck).Equals(IO_VALUE.HIGH)
                || IOValue(IO_Type.RaiseStation_UpLocation1).Equals(IO_VALUE.HIGH)
                ) {
                runStatus = StoreRunStatus.Busy;
                storeStatus = StoreStatus.OutStoreExecute;
                MoveInfo.NewMove(MoveType.OutStore, new InOutParam(MoveType.OutStore));
                if (shelfisready) {
                    LogUtil.info(Name + " 料架已就位");
                    
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_08_AxisUpToP2);
                }
                else
                {
                    LogUtil.info(Name + " 检测到库位有料架");
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_07_RaiseStationForward);
                }
                return true;
            }
            //判断是哪个工位有料架
            else if (IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
            {
                if (CurrShelfType.Equals(0) || CurrShelfType.Equals(2))
                { 
                    runStatus = StoreRunStatus.Busy;
                    storeStatus = StoreStatus.OutStoreExecute;
                    MoveInfo.NewMove(MoveType.OutStore, new InOutParam(MoveType.OutStore));
                    LogUtil.info(Name + " 当前料架["+CurrShelfNum+"]["+CurrShelfType+"],开始出库");
                    UpdateShelfNum(CurrShelfNum, 2);
                    L_05_WaitTime(StoreMoveStep.LO_05_WaitTime);
                    return true;
                }
            }

            return false;
        }
        public bool StartTrayOut(InOutParam outParam)
        {

            if (outParam == null || outParam.PosID == null || outParam.PosID.Equals(""))
            {
                LogUtil.error(Name + " StartTrayOut 出库失败，参数不完整：");
                LogUtil.error(outParam.ToStr());
                return false;
            }
            bool rightTrayHas15 = false;
            if (outParam.TargetBox == 1 && IOManager.IOValue(IO_Type.InDoor_Check, 2).Equals(IO_VALUE.HIGH) && BoxMap[2].MoveInfo.MoveParam != null && BoxMap[2].MoveInfo.MoveParam.PlateW == 15)
            {
                rightTrayHas15 = true;
                LogUtil.error(Name + "StartTrayOut 左侧出库,但右侧料架存在15村盘");
            }
            //MoveInfo.NextMoveStep(StoreMoveStep.LO_11_BatchAxisDown);
            //InOutStoreLog("取料：批量轴下降指定的高度");
            lock (worklock)
            {
                if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveStep.Equals(StoreMoveStep.LO_09_WaitOut) && !rightTrayHas15)
                {
                    MoveInfo.NewMove(MoveType.OutStore, outParam);
                    //可以开始出库啦
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_11_BatchAxisDown);
                    int height = outParam.PlateH + 4;
                    if (outParam.PlateH >= 24)
                        height += 6;
                    int targetPosition = T1_BatchAxis.GetAclPosition() - height * Config.BatchAxis_ChangeValue;
                    if (targetPosition < Config.BatchAxis_P1)
                    {
                        targetPosition = Config.BatchAxis_P1;
                    }
                    InOutStoreLog(" StartTrayOut 出库移栽：" + outParam.ToStr() + " 提升伺服下降" + height + "mm，目标：" + targetPosition);
                    T1_BatchAxis.AbsMove(null, targetPosition, Config.BatchAxis_P2Speed);
                    outStoreCount++;
                    StoreManager.putShelfFinished(outParam.PosID, CurrShelfNum, outStoreCount.ToString(), outParam.WareCode);
                    return true;
                }
                else
                {
                    LogUtil.error(Name + "StartTrayOut 出库" + outParam.ToStr() + "失败，未准备好料架");
                    return false;
                }
            }
        }
        /// <summary>
        /// 料串下降过度重新上升校准次数
        /// </summary>
        int TrayStringUpFix = 0;
        protected override void OutStoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait();
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            #region 料串检测


            else if (MoveInfo.IsStep(StoreMoveStep.LO_05_WaitTime))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_06_TopUp);
                InOutStoreLog("料架出库： 提升机构上升");
                InOutStation_RasieUp();
                OpenGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_06_TopUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_07_RaiseStationForward);
                InOutStoreLog("料架出库：横移机构前进");
                InOutStation_GoIn();
                LineStop(MoveInfo);
                //hoisterCylinder.StartForward(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_07_RaiseStationForward))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_07_RaiseStationForward_2);
                InOutStoreLog("料架出库：料窜到位，顶升上升");
                InOutStation_Stop(1000);
                InOutStation_LocationUp();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_07_RaiseStationForward_2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_08_AxisUpToP2);
                InOutStoreLog("料架出库：上料轴开始慢速上升到P2点[" + Config.BatchAxis_P2 + "]，等待检测到料盘");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                BatchAxisToP2(true);
                //CloseGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_08_AxisUpToP2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_09_WaitOut);
                InOutStoreLog("料架出库：料架准备完成，等待料盘出库");
                TrayStringUpFix = 0;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(5000));
                T1_BatchAxis.AbsMove(MoveInfo, T1_BatchAxis.GetAclPosition() - Config.BatchAxis_ChangeValue * 40, Config.BatchAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_09_WaitOut))
            {
                //if (OutstoreEndSendShelf && outStoreCount > 0)
                //{
                //    InOutStoreLog("料架出库：OutstoreEndSendShelf=true，已出库盘数[" + outStoreCount + "]，开始送出料架");
                //    LO_31_BatchAxisToP1();
                //}
                //else
                {
                    int xuqiudan = StoreManager.unfinishedTaskCount(Name, CurrShelfNum);
                    if (outStoreCount == 0 || (xuqiudan > 0))//  && !StoreManager.ShelfNeedOut))
                    {
                        MoveInfo.NextMoveStep(StoreMoveStep.LO_09_WaitOut);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(5000));
                    }
                    else
                    {
                        InOutStoreLog("料架出库：工单已结束，已出库盘数[" + outStoreCount + "]，开始送出料架");
                        lock (StoreManager.Store)
                        {
                            StoreManager.ShelfNeedOut = false;
                            StoreManager.LastVisualRfid = "";
                        }
                        outStoreCount = 0;
                        LO_31_BatchAxisToP1();
                    }
                    //InOutStoreLog(" 等待料盘出库");
                }
            }
            #endregion

            #region 取放料处理

            else if (MoveInfo.IsStep(StoreMoveStep.LO_11_BatchAxisDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_12a_ToBoxDoor);
                /*
                bool waitRightLeave = false;
                if (HasT4Axis && MoveInfo.MoveParam.TargetBox.Equals(1) && IOManager.IOValue(IO_Type.InDoor_Check, 2).Equals(IO_VALUE.HIGH))
                {
                    waitRightLeave = true;
                }
                */
                UpdateShelfNum(CurrShelfNum, 2);
                if (MoveInfo.MoveParam.TargetBox.Equals(1))
                {
                    InOutStoreLog("取料， BOX1 升降轴到料门口高点[" + Config.UpdownAxis_P4 + "]，旋转轴到料仓门口 P2 [" + Config.MiddleAxis_P2 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P4, Config.UpdownAxis_P4Speed);
                    T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P2, Config.MiddleAxis_P2Speed);
                    if (HasT4Axis)
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P2Speed);
                }
                else
                {
                    InOutStoreLog("取料， BOX2 升降轴到料门口高点[" + Config.UpdownAxis_P6 + "]，旋转轴到料仓门口 P3 [" + Config.MiddleAxis_P3 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P6, Config.UpdownAxis_P6Speed);
                    T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P3, Config.MiddleAxis_P3Speed);
                    if (HasT4Axis)
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P3Speed);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_12a_ToBoxDoor))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_12_ToBoxDoor);
                if (HasT4Axis)
                {
                    if (MoveInfo.MoveParam.TargetBox == 1)
                    {
                        InOutStoreLog("取料：进出轴回到待机点到P2 [" + Config.InOutAxis_P2 + "]");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P2, Config.InOutAxis_P1Speed);
                    }
                    else
                    {
                        InOutStoreLog("取料：进出轴回到取料前点到P3 [" + Config.InOutAxis_P3 + "]");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P3, Config.InOutAxis_P1Speed);
                    }
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_12_ToBoxDoor))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_13_UpdownDown);
                if (MoveInfo.MoveParam.TargetBox.Equals(1))
                {
                    InOutStoreLog("取料：BOX1 升降轴到料门口低点P3[" + Config.UpdownAxis_P3 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P3, Config.UpdownAxis_P3Speed);
                }
                else
                {
                    InOutStoreLog("取料：BOX2 升降轴到料门口低点P5[" + Config.UpdownAxis_P5 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P5, Config.UpdownAxis_P5Speed);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_13_UpdownDown))
            {
               
                if (electricClamp.Clamp(null))
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_14_CylinderTighten);
                    InOutStoreLog("取料：夹爪气缸夹紧");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
                }
                else if (MoveInfo.IsTimeOut(10))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待 电夹爪空闲 超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }

            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_14_CylinderTighten))
            {
                ClearTimeoutAlarm("电夹爪空闲");
                MoveInfo.NextMoveStep(StoreMoveStep.LO_15a_UpdownUp);
                if (MoveInfo.MoveParam.TargetBox.Equals(1))
                {
                    InOutStoreLog("取料：BOX1 升降轴上升到料门口高点P4 [" + Config.UpdownAxis_P4 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P4, (int)(Config.UpdownAxis_P4Speed));
                }
                else
                {
                    InOutStoreLog("取料：BOX2 升降轴上升到料门口高点P6 [" + Config.UpdownAxis_P6 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P6, (int)(Config.UpdownAxis_P6Speed));
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_15a_UpdownUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_15_UpdownUp);
                if (HasT4Axis)
                {
                    if (MoveInfo.MoveParam.TargetBox.Equals(1))
                    {
                        InOutStoreLog("取料：进出轴回到待机点到P6 [" + Config.InOutAxis_P6 + "]");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P6, Config.InOutAxis_P1Speed);
                    }
                    else
                    {
                        InOutStoreLog("取料：进出轴回到取料前点到P1 [" + Config.InOutAxis_P1 + "]");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P1Speed);
                    }
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_15_UpdownUp))
            {
                if (BoxMap[MoveInfo.MoveParam.TargetBox].IOValue(IO_Type.InDoor_Check).Equals(IO_VALUE.LOW))
                {
                    //BoxMap[MoveInfo.MoveParam.TargetBox].MoveInfo.MoveParam.TargetPosition = 1;
                    //BoxMap[MoveInfo.MoveParam.TargetBox].MoveInfo.NextMoveStep(StoreMoveStep.SO_14_InoutToP1);
                }
                MoveInfo.NextMoveStep(StoreMoveStep.LO_16_MiddleToP1);
                InOutStoreLog("取料：旋转轴到料串位置P4 [" + Config.MiddleAxis_P4 + "]");
                T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P4, Config.MiddleAxis_P4Speed);
                //T2_MiddleAxis_Run_Count++;

            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_16_MiddleToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_17_UpdownToP2);
                if (HasT4Axis)
                    T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P4, Config.InOutAxis_P4Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_17_UpdownToP2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_18_UpdownDown);
                InOutStoreLog("取料：升降轴到料串放料低点P1 [" + Config.UpdownAxis_P1 + "]");
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P1, (int)(Config.UpdownAxis_P1Speed * 2));
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_18_UpdownDown))
            {
                
                if (electricClamp.Release()) {
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_19_CylinderRelax);
                    InOutStoreLog("料盘移栽： 夹爪气缸放松");
                }
                else if (MoveInfo.IsTimeOut(10))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待 电夹爪空闲 超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_19_CylinderRelax))
            {
                ClearTimeoutAlarm("电夹爪空闲");
                MoveInfo.NextMoveStep(StoreMoveStep.LO_20_BatchAxisToP2);
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);
                InOutStoreLog("料盘移栽： 升降轴上升到P2");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_20_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_20a_UpdownUp);
                //只有提升轴位置过低时才需要到P3
                int currPosition = T1_BatchAxis.GetAclPosition();
                int reoppos = (Config.BatchAxis_P1 + Config.BatchAxis_ChangeValue * 100);
                InOutStoreLog($"料盘移栽： 当前T1位置[{currPosition}]，最低需要重新上升位置:[{reoppos}]");
                if (currPosition <= reoppos && TrayStringUpFix < 2)
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_20_UpdownUp_wait);
                    TrayStringUpFix++;
                    InOutStoreLog($"料盘移栽：  第{TrayStringUpFix}次,升降轴到料串高点[" + Config.UpdownAxis_P2 + "]，提升轴[" + currPosition + $"]需要到P2");
                    BatchAxisToP2();
                }
                else
                {
                    InOutStoreLog("料盘移栽：  升降轴到料串高点[" + Config.UpdownAxis_P2 + "]，提升轴[" + currPosition + "]不需要到P2");
                }
                if (HasT4Axis)
                    T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_20_UpdownUp_wait))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_20a_UpdownUp);
                int currPosition = T1_BatchAxis.GetAclPosition();
                int targetP2 = currPosition - Config.BatchAxis_ChangeValue * 20;
                InOutStoreLog($"料盘移栽： 料串下降当前位置:{currPosition},目标位置:{targetP2}");
                T1_BatchAxis.AbsMove(MoveInfo, targetP2, Config.BatchAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_20a_UpdownUp))
            {
                if (T2_MiddleAxis_Run_Count > T2_MiddleAxis_Run_Reset)
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_20b_UpdownUp);
                else
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_20_UpdownUp);
                    return;
                }
                T2_MiddleAxis_Run_Count = 0;
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P6, Config.UpdownAxis_P2Speed);
                T2_MiddleAxis.HomeMove(MoveInfo);
                InOutStoreLog($"取料：取料旋转轴运动满100次开始回原复位{T2_MiddleAxis_Run_Count}");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_20b_UpdownUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_20_UpdownUp);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                InOutStoreLog($"料盘移栽： 等待");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_20_UpdownUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_21_NeedSendShelf);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                InOutStoreLog("料盘移栽：判断是否送出料架");
                if (T2_MiddleAxis_Run_Count==0)
                    T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P4, Config.MiddleAxis_P4Speed);

                int currPositon = T1_BatchAxis.GetAclPosition();
                int tp = currPositon - Config.BatchAxis_ChangeValue * 60;
                if (tp <= Config.BatchAxis_P1)
                {
                    LO_31_BatchAxisToP1(" 提升轴位置：" + currPositon + ",料架已满，需要送出料架");
                }
                else
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LO_09_WaitOut);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(5000));
                    InOutStoreLog(" 等待料盘出库");
                }
            }
            #endregion


            #region 送出料架处理
            else if (MoveInfo.IsStep(StoreMoveStep.LO_31_BatchAxisToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_32_RaiseStationBack);
                InOutStoreLog("送出料架：升降盘定位气缸后退");
                InOutStation_LocationDown();
                InOutStation_RasieUp();
                OpenGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_32_RaiseStationBack))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_32_RaiseStationBack_2);
                InOutStoreLog("送出料架：横移机构后退");
                InOutStation_GoOut();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_32_RaiseStationBack_2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_32_RaiseStationBack_3);

                InOutStation_Stop();
                InOutStoreLog("送出料架：横移机构停止");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_32_RaiseStationBack_3))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_33_TopCylinderDown);

                InOutStoreLog("送出料架：顶升气缸下降");
                InOutStation_RasieDown();
                CloseGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_33_TopCylinderDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_34_WorkStopDown);
                InOutStoreLog("送出料架：流水线开始转动");
                UpdateShelfNum(CurrShelfNum, -1);
                Properties.Settings1.Default.LastOutShelfType = 1;
                Properties.Settings1.Default.Save();
                //ConfigAppSettings.SaveValue(Setting_Init.LastOutShelfType, 1);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                LineRun(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_34_WorkStopDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_35_WaitShelfGo);
                InOutStoreLog("送出料架：上料阻挡下降2秒，等待上料无料架");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
                IOMove(IO_Type.Line_Stop2_Work, IO_VALUE.HIGH, false, 1000);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_WorkCheck, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_35_WaitShelfGo))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_36_LineRun);
                AgvNeedOutshelf = Agv.ClientShelf.Full;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3500));
                InOutStoreLog($"送出料架：流水线再转动3秒 AgvNeedOutshelf:{AgvNeedOutshelf}");
                LineRun(MoveInfo);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_OutCheck, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_36_LineRun))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LO_37_LineStop);
                //var rfiddevice = RFIDManager.GetShelfId(Config.Out_Rfid_IP);
                //var rfid = rfiddevice.NumStr();
                //AgvNeedOutshelf = Agv.ClientShelf.Full;
                InOutStoreLog($"送出料架：流水线停止转动");
                LineStop(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LO_37_LineStop))
            {
                LineStop(MoveInfo);
                MoveEndP();
            }
            #endregion

        }
        private void LO_31_BatchAxisToP1(string msg = "")
        {
            MoveInfo.NextMoveStep(StoreMoveStep.LO_31_BatchAxisToP1);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
            InOutStoreLog("出库 ：" + msg + "开始送出料架，提升伺服到P1点 ["+ Config.BatchAxis_P1 + "] ");
            StoreManager.LastVisualRfid = "";
            UpdateShelfNum(CurrShelfNum, 0);
            T1_BatchAxis.SuddenStop();
            T1_BatchAxis.AbsMove(MoveInfo, Config.BatchAxis_P1, Config.BatchAxis_P2Speed);
        }



        #endregion

        #region 料架入料 
        private bool ShelfNoTray = false; 
        private int StartMovePosition = 0;
        private int EndMovePosition = 0;
        private int LastHeight = 0;
        private int LastWidth = 0;
        private List<string> LastCodeList = new List<string>();
        private List<string> YuCodeList = new List<string>();
        private Task getPosTask = null;
        private string lastcode = "";
        private InOutParam LastPosParam = null;
        private bool InShelfInProcess = false;

        private bool StartInStoreP()
        {
            if (IOValue(IO_Type.Line_InCheck).Equals(IO_VALUE.HIGH) && IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.LOW) && (!InShelfInProcess))
            {
               // ShelfEnterProcess();
            }
            if (!MoveInfo.MoveType.Equals(MoveType.None))
            {
                return false;
            }
            //判断是否检测到料架
            if (IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
            {
                StartInStoreMove(null);
            }
            if (IOValue(IO_Type.RaiseStation_FrontCheck).Equals(IO_VALUE.HIGH) && IOValue(IO_Type.RaiseStation_BackendCheck).Equals(IO_VALUE.HIGH))
            {
                StartInStoreMove(null);
            }
            return false;
        }
        public async Task AgvSendShelfIn() {
            bool result = await ShelfEnterProcess();
            if (result) { 
                AgvClient.SetStatus(StoreManager.Config.AgvInName, "", Agv.ClientAction.FinishEnter);
                _=Task.Run(() => {
                    Task.Delay(2000).Wait();
                    AgvClient.SetStatus(StoreManager.Config.AgvInName, "", Agv.ClientAction.None);
                });
            }
        }
        private Task<bool> ShelfEnterProcess()
        {
            //入口有料架，需要转动链条 
            return Task<bool>.Run(new Func<bool>(()=>
            {
                InShelfInProcess = true;
                bool result = false;
                try
                {
                    InOutStoreLog("检测到入口(X03-Line_InCheck)有料");
                    InShelfInProcess = true;
                    LineRun("ShelfEnterProcess",999);
                    Thread.Sleep(1000 * 20);
                    //等待进料检测信号
                    result = WaitIo(IO_Type.Line_InCheck, IO_VALUE.LOW, 10000);
                    //InOutStoreLog($"Line_InCheck:{result}");
                    result = WaitIo(IO_Type.Line_WaitCheck, IO_VALUE.HIGH, 50000);
                    //InOutStoreLog($"Line_WaitCheck:{result}");
                }
                catch (Exception ex)
                {
                    InOutStoreLog("检测到入口(X03-Line_InCheck)有料:"+ex.ToString());
                }
                finally
                {
                    InShelfInProcess = false;
                    LineStop("ShelfEnterProcess");
                }
                return result;
            }));
        }

        private void L_05_WaitTime(StoreMoveStep step)
        {
            //定位工位有料架，等待1秒后再次检测
            MoveInfo.NextMoveStep(step);
            InOutStoreLog("上料区检测到料架：  阻挡1上升，阻挡2上升，转动流水线5秒");
            IOMove(IO_Type.Line_Stop1_Wait, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Stop2_Work, IO_VALUE.LOW);
            LineRun(MoveInfo);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_WorkCheck, IO_VALUE.HIGH));
        }

        private void LI_04_LineStart()
        { 
            //UpdateShelfNum(GetShelfNum(), 1);
            if (IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
            {
                InOutStoreLog($"入料检测： 上料工作区有料架1 ，阻挡1下降2000，阻挡2上升，流水线转动 ,等待料架到达上料区,CurrShelfType:{CurrShelfType}");
                L_05_WaitTime(StoreMoveStep.LI_05_WaitTime);
            }
            else if (IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_05_WaitTime);
                InOutStoreLog($"入料检测： 上料等待区有料架2 ，阻挡1下降2000，阻挡2上升，流水线转动 ,等待料架到达上料区,CurrShelfType:{CurrShelfType}");

                IOMove(IO_Type.Line_Stop1_Wait, IO_VALUE.HIGH, false, 1000);//进料阻挡下降
                IOMove(IO_Type.Line_Stop2_Work, IO_VALUE.LOW);//缓冲阻挡前进1000
                LineRun(MoveInfo);
                //等待指定时间
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2500));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_WorkCheck, IO_VALUE.HIGH));
            }
            else
            {
                if (!InShelfInProcess)
                {
                    LineStop("n", "LI_04_LineStart");
                }

                MoveEndP();
                LogUtil.info(" 未检测到料架，入料结束");
            }
        }

        public override bool StartInStoreMove(InOutParam param)
        {
            if (IOValue(IO_Type.RaiseStation_BackendCheck).Equals(IO_VALUE.HIGH)
                || IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
            {
                if (CurrShelfType.Equals(1))
                {
                    if (IOValue(IO_Type.Line_WorkCheck).Equals(IO_VALUE.HIGH))
                    {
                        InOutStoreLog($"StartInStoreMove CurrShelfNum:{CurrShelfNum},CurrShelfType={CurrShelfType}");
                        runStatus = StoreRunStatus.Busy;
                        storeStatus = StoreStatus.InStoreExecute;
                        MoveInfo.NewMove(MoveType.InStore, new InOutParam(MoveType.InStore));
                        L_05_WaitTime(StoreMoveStep.LI_05_WaitTime);
                        return true;

                        
                    }
                    else {
                        runStatus = StoreRunStatus.Busy;
                        storeStatus = StoreStatus.InStoreExecute;
                        MoveInfo.NewMove(MoveType.InStore, new InOutParam(MoveType.InStore));
                        MoveInfo.NextMoveStep(StoreMoveStep.LI_06_TopUp);
                        return true;
                    }
                } else if (CurrShelfType==2)
                {
                    //runStatus = StoreRunStatus.Busy;
                    //storeStatus = StoreStatus.OutStoreExecute;
                    //MoveInfo.NewMove(MoveType.OutStore, new InOutParam(MoveType.OutStore));
                    StartOutStoreMove(new InOutParam(MoveType.OutStore));
                    //先将当前料架送出
                    //LO_31_BatchAxisToP1();
                }
                else if (IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.HIGH))
                {
                    runStatus = StoreRunStatus.Busy;
                    storeStatus = StoreStatus.InStoreExecute;
                    MoveInfo.NewMove(MoveType.InStore, new InOutParam(MoveType.InStore));
                    //先将当前料架送出
                    LI_31_BatchAxisToP1();
                } else if (IOValue(IO_Type.RaiseStation_BackendCheck).Equals(IO_VALUE.HIGH)){
                    runStatus = StoreRunStatus.Busy;
                    storeStatus = StoreStatus.InStoreExecute;
                    MoveInfo.NewMove(MoveType.InStore, new InOutParam(MoveType.InStore));
                    LI_31_BatchAxisToP1();
                }
            }
            else if (IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.HIGH))
            {
                runStatus = StoreRunStatus.Busy;
                storeStatus = StoreStatus.InStoreExecute;
                MoveInfo.NewMove(MoveType.InStore, new InOutParam(MoveType.InStore));
                if (T1_BatchAxis.IsInPosition(Config.BatchAxis_P1))
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_02_HoisterBack);
                    InOutStoreLog("检测到料架：取料提升机构后退端");
                    InOutStation_LocationDown();
                }
                else
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_01_BatchAxisToP1);
                    InOutStoreLog("检测到料架，提升轴先返回P1");
                    T1_BatchAxis.AbsMove(MoveInfo, Config.BatchAxis_P1, Config.BatchAxis_P1Speed);
                }
                return true;
            }
            return false ;
        }

        protected override void InStoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait();
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            #region 料串检测

            if (MoveInfo.IsStep(StoreMoveStep.LI_01_BatchAxisToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_02_HoisterBack);
                InOutStoreLog("检测到料架：取料提升机构后退端");
                //hoisterCylinder.StartBack(MoveInfo);
                InOutStation_LocationDown();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_02_HoisterBack))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_03_LocationDown);
                InOutStoreLog("入料检测：定位气缸下降");
                InOutStation_RasieDown();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_03_LocationDown))
            {
                LI_04_LineStart();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_04_LineStart))
            {
                LI_04_LineStart();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_05_WaitTime))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_06_TopUp);
                InOutStoreLog("入料检测：链条停止转动，  进出机构上升");
                LineStop(MoveInfo);
                InOutStation_RasieUp();
                OpenGate(MoveInfo);
                CurrShelfNum = Properties.Settings1.Default.CurrShelfNum;
                CurrShelfType = Properties.Settings1.Default.CurrShelfType;
                var rfiddevice = RFIDManager.GetShelfId(Config.In_Rfid_IP);
                var rfid = rfiddevice.NumStr();
                InOutStoreLog($"入料检测：读取到rfid: {rfid}");
                if (rfid == "000")
                {
                    rfid = CurrShelfNum;
                }
                if (rfid == CurrShelfNum && CurrShelfType == 2)
                {
                    MoveEndP();
                }
                else
                {
                    CurrShelfType = 1;
                }
                UpdateShelfNum(rfid, CurrShelfType);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_06_TopUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_07_HoisterForward);
                InOutStoreLog("入料检测：进出机构前进");
                InOutStation_GoIn();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_07_HoisterForward))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_07_HoisterForward_2);
                InOutStoreLog("入料检测：定位销上升");
                InOutStation_LocationUp();
                InOutStation_Stop();
                //CloseGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_07_HoisterForward_2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_08_AxisUpToP2);
                InOutStoreLog("入料检测：上料轴开始慢速上升到P2 [" + Config.BatchAxis_P2 + "]，等待检测到料盘");
                T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P1, Config.MiddleAxis_P1Speed);
                BatchAxisToP2(true);
                ShelfNoTray = false;
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_08_AxisUpToP2))
            {
                CheckHasTray();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_09_ScanCode))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_11_AxisToTray);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                InOutStoreLog("入料检测：有料盘：升降轴到料串高点P2[" + Config.UpdownAxis_P2 + "]，旋转轴到料串位置P4[" + Config.MiddleAxis_P4 + "]进出轴回p1");
                if (HasT4Axis)
                    T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P1Speed);
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);
                T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P4, Config.MiddleAxis_P4Speed);
                //T2_MiddleAxis_Run_Count++;
            }

            #endregion

            #region 取放料处理
            else if (MoveInfo.IsStep(StoreMoveStep.LI_11_AxisToTray))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_11a_AxisToTray);

                if (HasT4Axis)
                {
                    InOutStoreLog("取料：进出轴到P4");
                    T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P4, Config.InOutAxis_P4Speed);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_11a_AxisToTray))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_12_UpdownAxisToP3);
                InOutStoreLog("取料：升降轴到料串低点P1[" + Config.UpdownAxis_P1 + "]");
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P1, Config.UpdownAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_12_UpdownAxisToP3))
            {                
                if (electricClamp.Clamp(null))
                {
                    InOutStoreLog("取料：夹爪气缸夹紧");
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_13_CylinderTighten);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
                }
                else if (MoveInfo.IsTimeOut(10)) {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待 电夹爪空闲 超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
                
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_13_CylinderTighten))
            {
                ClearTimeoutAlarm("电夹爪空闲");
                MoveInfo.NextMoveStep(StoreMoveStep.LI_14_UpdownToP1);
                InOutStoreLog("取料：升降轴到料串高点P2[" + Config.UpdownAxis_P2 + "]");
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_14_UpdownToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_15_WaitNoCheck);
                InOutStoreLog("取料：等待没有提升机构料盘检测");
                InOutStoreLog($"取料：夹爪状态 IsPushEmpty:{!electricClamp.IsClamp},IsReached:{!electricClamp.IsBusy}");
                if (Math.Abs(T1_BatchAxis.GetAclPosition() - Config.BatchAxis_P2) > T1_BatchAxis.Config.CanErrorCountMin)
                {
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.BatchAxis_Check, IO_VALUE.LOW));
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_15_WaitNoCheck))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_16_BatchAxisToP2);
                InOutStoreLog("取料：批量轴到P2 [" + Config.BatchAxis_P2 + "],计算高度,");
                BatchAxisToP2(false);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_16_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_17_SaveSize);
                LastWidth = GetWidth();
                LastHeight = GetHeight();
                //if (LastWidth == 13)
                //    electricClamp.Clamp(null,15);
                InOutStoreLog($"取料：记录高度尺寸 LastWidth:{LastWidth}, LastHeight{LastHeight},计算高度");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitScanCode());
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_17_SaveSize))
            {
                bool hasbox = false;
                foreach (int k in BoxMap.Keys)
                {
                    if (BoxMap[k].runStatus >= StoreRunStatus.Runing && BoxMap[k].IOValue(IO_Type.InDoor_Check).Equals(IO_VALUE.LOW))
                    {
                        hasbox = true;
                    }
                }
                if (hasbox)
                    LI_18_GetPosID();
                else if (MoveInfo.IsTimeOut(120))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待料仓空闲 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }


            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_18_GetPosID))
            {
                if (getPosTask.IsCompleted && LastPosParam != null)
                {
                    if (LastPosParam.InStoreNg)
                    {
                        int box = GetInstoreNgBox();
                        if (HasT4Axis)
                        {
                            if (LastWidth >= 13)
                                box = 2;
                            else
                                box = 1;
                        }
                        LastPosParam.TargetBox = box;
                        LastPosParam.TargetPosition = 1;
                        MoveInfo.MoveParam = LastPosParam;
                    }
                    else
                    {
                        int storeId = LastPosParam.GetStoreId();
                        if (storeId.Equals(1))
                        {
                            LastPosParam.TargetBox = 1;
                        }
                        else
                        {
                            LastPosParam.TargetBox = 2;
                        }
                    }
                    if (HasT4Axis)
                    {
                        if (LastPosParam.TargetBox == 2)
                        {
                            InOutStoreLog("取料：进出轴回到待机点到P1 [" + Config.InOutAxis_P1 + "]");
                            T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P1Speed);
                        }
                        else
                        {
                            InOutStoreLog("取料：进出轴回到取料前点到P6 [" + Config.InOutAxis_P6 + "]");
                            T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P6, Config.InOutAxis_P1Speed);
                        }
                    }
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_21_WaitToBox);
                    //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                    InOutStoreLog("料盘移栽：" + LastPosParam.ToStr() + " 等待料仓门口无信号");
                    ClearTimeoutAlarm("获取库位号超时");
                }
                else if (MoveInfo.IsTimeOut(120))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 获取库位号超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_21_WaitToBox))
            {
                int storeId = LastPosParam.GetStoreId();
                if (storeId == -1)
                    storeId = LastPosParam.TargetBox;
                // InOutStoreLog($"料盘移栽：storeId :{storeId}");
                //BoxBean box = BoxMap[storeId];


                bool waitRightLeave = false;
                if (HasT4Axis && storeId == 1 && (IOManager.IOValue(IO_Type.InDoor_Check, 2).Equals(IO_VALUE.HIGH) || (BoxMap[2].MoveInfo.MoveStep < StoreMoveStep.SI_05_InoutToP1 && BoxMap[2].MoveInfo.MoveStep > StoreMoveStep.SI_03_InoutToP2)))
                {
                    waitRightLeave = true;
                }
                bool boxdoorready = BoxMap[storeId].InoutAxis.GetAclPosition() < (BoxMap[storeId].Config.InOutAxis_P2 - BoxMap[storeId].Config.InOutAxis_P1) / 2;
                if (IOManager.IOValue(IO_Type.InDoor_Check, storeId).Equals(IO_VALUE.LOW) && boxdoorready && !waitRightLeave)// && box.waitInStoreParam == null
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_22a_ToBoxDoor);
                    //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                    //判断是左侧还是右侧
                    if (LastPosParam.TargetBox.Equals(1))
                    {
                        InOutStoreLog("料盘移栽：获取库位号完成， BOX " + storeId + " 升降轴到料门口高点P4[" + Config.UpdownAxis_P4 + "]，旋转轴到料仓门口 P2[" + Config.MiddleAxis_P2 + "]");
                        T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P4, Config.UpdownAxis_P4Speed);
                        T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P2, Config.MiddleAxis_P2Speed);

                    }
                    else
                    {
                        InOutStoreLog("料盘移栽：获取库位号完成， BOX " + storeId + " 升降轴到料门口高点P6[" + Config.UpdownAxis_P6 + "]，旋转轴到料仓门口 P3[" + Config.MiddleAxis_P3 + "]");
                        T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P6, Config.UpdownAxis_P6Speed);
                        T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P3, Config.MiddleAxis_P3Speed);

                    }

                    ClearTimeoutAlarm("入料口无料盘");
                }
                else if (MoveInfo.IsTimeOut(120))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待BOX_" + storeId + " 入料口无料盘 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_22a_ToBoxDoor))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_22_ToBoxDoor);
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                //判断是左侧还是右侧
                if (HasT4Axis)
                {
                    if (LastPosParam.TargetBox.Equals(1))
                    {

                        InOutStoreLog($"料盘移栽：左侧,进出轴到P2:{Config.InOutAxis_P2}");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P2, Config.InOutAxis_P2Speed);
                    }
                    else
                    {

                        InOutStoreLog($"料盘移栽：右侧,进出轴到P3:{Config.InOutAxis_P3}");
                        T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P3, Config.InOutAxis_P3Speed);

                    }
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_22_ToBoxDoor))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_23_UpdownDown);

                YuScanCode();
                if (LastPosParam.TargetBox.Equals(1))
                {
                    InOutStoreLog($"料盘移栽：  升降轴到料门口低点P3[{Config.UpdownAxis_P3},补偿:{(LastHeight - 8) * Config.UpdownAxis_ChangeValue}]，开始预扫码");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P3 - (LastHeight - 8) * Config.UpdownAxis_ChangeValue, (int)(Config.UpdownAxis_P3Speed * 2));
                }
                else
                {
                    InOutStoreLog($"料盘移栽：  升降轴到料门口低点P5[{Config.UpdownAxis_P5},补偿:{(LastHeight - 8) * Config.UpdownAxis_ChangeValue}]，开始预扫码");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P5 - (LastHeight - 8) * Config.UpdownAxis_ChangeValue, (int)(Config.UpdownAxis_P5Speed * 2));
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_23_UpdownDown))
            {
                if (electricClamp.Release())
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_24_CylinderRelax);
                    InOutStoreLog("料盘移栽： 上料气缸放松");
                }
                else if (MoveInfo.IsTimeOut(10))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 等待 电夹爪空闲 超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, ID * 1000 + 30);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_24_CylinderRelax))
            {
                ClearTimeoutAlarm("电夹爪空闲");
                MoveInfo.NextMoveStep(StoreMoveStep.LI_25_UpdownUp);
                if (LastPosParam.TargetBox.Equals(1))
                {
                    InOutStoreLog("料盘移栽：  升降轴到料门口高点P4[" + Config.UpdownAxis_P4 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P4, (int)(Config.UpdownAxis_P4Speed));
                }
                else
                {
                    InOutStoreLog("料盘移栽：  升降轴到料门口高点P6[" + Config.UpdownAxis_P6 + "]");
                    T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P6, (int)(Config.UpdownAxis_P6Speed));
                }

                int storeId = LastPosParam.GetStoreId();
                BoxBean box;
                if (storeId == -1)
                    storeId = LastPosParam.TargetBox;
                box = BoxMap[storeId];
                InOutStoreLog($"料盘移栽：storeId={storeId},targetpos={LastPosParam.TargetPosition},isNG={LastPosParam.InStoreNg}");
                box.waitInStoreParam = LastPosParam.clone();
            }

            else if (MoveInfo.IsStep(StoreMoveStep.LI_25_UpdownUp))
            {
                if (T2_MiddleAxis_Run_Count > T2_MiddleAxis_Run_Reset)
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_25a_UpdownUp);
                }
                else
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_26_AxisToWait);
                    //return;
                }

                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                InOutStoreLog("料盘移栽：旋转轴返回待机点P1[" + Config.MiddleAxis_P1 + "],升降轴到料串高点P2[" + Config.UpdownAxis_P2 + "]进出轴回P1");
                //T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P1, Config.MiddleAxis_P1Speed);
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);
                if (HasT4Axis)
                    T4_InOut_Axis.AbsMove(MoveInfo, Config.InOutAxis_P1, Config.InOutAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_25a_UpdownUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_26_AxisToWait);
                T2_MiddleAxis_Run_Count = 0;
                T2_MiddleAxis.HomeMove(MoveInfo);
                InOutStoreLog("取料：取料旋转轴运动满100次开始回原复位");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_26_AxisToWait))
            {
                CheckHasTray();
            }
            #endregion


            #region 送出料架处理
            else if (MoveInfo.IsStep(StoreMoveStep.LI_31_BatchAxisToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_32_HoisterBack);

                InOutStoreLog("送出料架：顶升气缸下降");
                InOutStation_LocationDown();
                InOutStation_RasieUp();
                OpenGate(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_32_HoisterBack))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_33_TopCylinderDown);
                InOutStoreLog("送出料架：升降盘定位气缸后退");
                InOutStation_GoOut();
                //hoisterCylinder.StartBack(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_33_TopCylinderDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_33_TopCylinderDown_2);
                InOutStoreLog("送出料架：进出滚筒往外");
                InOutStation_GoOut();
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_33_TopCylinderDown_2))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_33_TopCylinderDown_3);
                InOutStoreLog("送出料架：进出机构下降");
                InOutStation_RasieDown();

            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_33_TopCylinderDown_3))
            {
                InOutStation_Stop(1000);
                CloseGate(MoveInfo);
                /*
                InOutStoreLog($"送出料架：BoxMap[1]={BoxMap[1].storeStatus},BoxMap[2]={BoxMap[2].storeStatus}");
                //如果有等待出库的料先出库
                if (BoxMap[1].storeStatus == StoreStatus.OutStoreExecute || BoxMap[1].storeStatus == StoreStatus.OutStoreBoxEnd
                  || BoxMap[2].storeStatus == StoreStatus.OutStoreExecute || BoxMap[2].storeStatus == StoreStatus.OutStoreBoxEnd)
                {
                    InOutStoreLog("送出料架：检测到有待出库料盘,立刻开始出库");
                    LineStop(MoveInfo);
                    if (!StartOutStoreMove(new InOutParam(MoveType.OutStore),false))
                    {
                        InOutStoreLog("送出料架：转换出库失败.");

                        //MoveEndP();
                    }
                }
                //判断是否需要送出料架，如果入口和等待区无料架，暂不送出
                else */
                if (true || IOValue(IO_Type.Line_InCheck).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.HIGH) || InstoreEndSendShelf)
                {
                    MoveInfo.NextMoveStep(StoreMoveStep.LI_34_WorkStopDown);
                    InOutStoreLog("送出料架[" + InstoreEndSendShelf + "]：上料阻挡下降1秒，流水线开始转动");
                    UpdateShelfNum(CurrShelfNum, -1);
                    Properties.Settings1.Default.LastOutShelfType = 0;
                    Properties.Settings1.Default.Save();
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                    LineRun(MoveInfo);
                    IOMove(IO_Type.Line_Stop2_Work, IO_VALUE.HIGH, false, 1000);

                }
                else
                {
                    InOutStoreLog("送出料架：入口和等待区暂无料架，不需要送出料架");
                    LineStop(MoveInfo);
                    MoveEndP();
                }
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_34_WorkStopDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_35_WaitShelfGo);
                InOutStoreLog("送出料架：等待上料无料架");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_WorkCheck, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_35_WaitShelfGo))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_36_LineRun);
                InOutStoreLog("送出料架：流水线再转动3秒");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(4000));
                LineRun(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_36_LineRun))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LI_37_LineStop);
                InOutStoreLog("送出料架：流水线停止转动");
                LineStop(MoveInfo);
                AgvNeedOutshelf = Agv.ClientShelf.Empty;
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LI_37_LineStop))
            {
                LineStop(MoveInfo);
                MoveEndP();
            } 
            #endregion

        }

        private int GetInstoreNgBox()
        {
            //空闲且门口无料盘
            foreach (BoxBean box in BoxMap.Values)
            {
                if (IOManager.IOValue(IO_Type.InDoor_Check, box.ID).Equals(IO_VALUE.LOW))
                {
                    return box.ID;
                }
            }
            
            return 1;
        }
         
        private void LI_18_GetPosID()
        {
            MoveInfo.NextMoveStep(StoreMoveStep.LI_18_GetPosID);
            InOutStoreLog("料盘移栽：从服务器获取入库库位号");
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
            LastPosParam = null;
            string code = CodeManager.ProcessCode(LastCodeList);
            lastcode = code;
            getPosTask = Task.Factory.StartNew(delegate
            {
                //更新托盘条码信息 
                try
                {
                    int count = 1;
                    while (MoveInfo.MoveType.Equals(MoveType.InStore))
                    {
                        //从服务器获取库位号
                        GetPosResult result = StoreManager.GetPosId(Name, LastCodeList, LastHeight, LastWidth, CurrShelfNum);
                        if (result.IsTimeOut)
                        {
                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 LI_18_GetPosID 超时，等待1s后重新获取");
                            Thread.Sleep(1000);
                        }
                        else if (result.Result.Equals(99) || result.Result.Equals(100))
                        {
                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 LI_18_GetPosID 结果【" + result.Result + "】，等待3s后重新获取");
                            Thread.Sleep(3000);
                        }
                        else if (!result.Msg.Equals(""))
                        {
                            result.Param.InStoreNg = true;
                            LastPosParam = result.Param.clone();

                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 LI_18_GetPosID 入库NG：" + result.Msg);

                            break;
                        }
                        else
                        {
                            LastPosParam = result.Param.clone();
                            break;
                        }
                        count++;
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "【" + code + "】获取库位号报错：" + ex.ToString());
                }

            });

            MoveInfo.MoveParam = LastPosParam;
        }
         
        private void LI_11_AxisToTray()
        {
            MoveInfo.NextMoveStep(StoreMoveStep.LI_11_AxisToTray);
            InOutStoreLog("入料检测：有料盘：升降轴到料串高点P2 ["+ Config.UpdownAxis_P2 + "]，旋转轴到料串位置P4 ["+ Config.MiddleAxis_P4 + "]");
            T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);
            T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P4, Config.MiddleAxis_P4Speed);
            //T2_MiddleAxis_Run_Count++;
        }
        Task<List<string>> scanTask;
        private void LI_09_ScanCode()
        {
            MoveInfo.NextMoveStep(StoreMoveStep.LI_09_ScanCode); 
            LastCodeList = new List<string>();

            if (YuCodeList.Count > 0)
            {
                InOutStoreLog("入料检测：开始扫码：使用预扫码");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
                LastCodeList = new List<string>(YuCodeList);
                YuCodeList = new List<string>();
                LI_11_AxisToTray();
            }
            else
            {
                InOutStoreLog("料盘移栽 ：开始扫码");
                MoveInfo.OneWaitCanEndStep = true;
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitScanCode());
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                try
                {
                    scanTask = Task.Factory.StartNew(delegate
                    {
                        IOMove(IO_Type.Camera_Led, IO_VALUE.HIGH);
                        Task.Delay(10).Wait();
                        LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name);

                        if (LastCodeList.Count <= 0)
                        {
                            LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name,   3000);
                        }
                        IOMove(IO_Type.Camera_Led, IO_VALUE.LOW);
                        return LastCodeList;
                    });
                }
                catch (Exception ex)
                {
                    LogUtil.error("FI_13_ScanCode扫码出错：", ex);
                }
            }
        }

        private void YuScanCode()
        {
            //TODO 此处需要等待空托盘 
            if (ShelfNoTray.Equals(false))
            {
                InOutStoreLog("料盘移栽 ： ，预扫码");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                //还有料盘，直接扫码
                YuCodeList = new List<string>();
                List<string> bijiaoList = new List<string>(LastCodeList);
                try
                {
                    Task<List<string>> scanTask = Task.Factory.StartNew(delegate
                    {
                        IOMove(IO_Type.Camera_Led, IO_VALUE.HIGH);
                        Task.Delay(10).Wait();
                        YuCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name.Trim() + "预扫码");
                        //IOMove(IO_Type.Camera_Led, IO_VALUE.LOW);
                        bool isCanUse = true;
                        //判断是否可用
                        foreach (string nC in YuCodeList)
                        {
                            foreach (string n in bijiaoList)
                            {
                                if (nC.Length > 15 && nC.Equals(n))
                                {
                                    LogUtil.error(Name + "预扫码结果【" + nC + "】与上个条码【" + n + "】重复，预扫码不可用");
                                    isCanUse = false;
                                    break;
                                }
                            }
                        }
                        if (!isCanUse)
                        {
                            YuCodeList = new List<string>();
                        }
                        //if (!CodeManager.HasRightCode(YuCodeList.ToArray()))
                        //{
                        //    YuCodeList = new List<string>();
                        //}
                        return YuCodeList;
                    });
                }
                catch (Exception ex)
                {
                    LogUtil.error(" 为下一盘料扫码出错：", ex);
                }
            }
        }

        private void CheckHasTray()
        {
            if (IOValue(IO_Type.BatchAxis_Check).Equals(IO_VALUE.HIGH) && ShelfNoTray.Equals(false))
            {
                LI_09_ScanCode();
            }
            else
            {
                if (ShelfNoTray.Equals(false))
                {
                    //判断当前位置是否在指定的位置
                    int currP = T1_BatchAxis.GetAclPosition();
                    int chaz = Math.Abs(currP - Config.BatchAxis_P2);
                    if (chaz > T1_BatchAxis.Config.CanErrorCountMax)
                    {
                        MoveInfo.NextMoveStep(StoreMoveStep.LI_08_AxisUpToP2);
                        InOutStoreLog(" CheckHasTray：上料轴开始慢速上升到P2["+Config.BatchAxis_P2+"]，等待检测到料盘");
                        ShelfNoTray = false;
                        BatchAxisToP2(false);
                        return;
                    }
                }
                //无料盘
                ShelfNoTray = true;
                UpdateShelfNum(CurrShelfNum, 0);
                int box1miscout = 0;
                int box2miscout = 0;
                bool hasMission = false;
                int MissionTest = 0;
                while (MissionTest < 10 && !hasMission)
                {
                    //lock (BoxMap[1].waitOutStoreList)
                    {
                        var box1wl = BoxMap[1].waitOutStoreList.ToList();
                        box1miscout = (from a in box1wl where a.TargetPosition == 0 select a).Count();
                    }
                    //lock (BoxMap[2].waitOutStoreList)
                    {
                        var box1wl = BoxMap[2].waitOutStoreList.ToList();
                        box2miscout = (from a in box1wl where a.TargetPosition == 0 select a).Count();
                    }
                    //如果有等待出库的料先出库
                    if (box1miscout > 0 || box2miscout > 0)
                        hasMission = true;
                    MissionTest++;
                    Thread.Sleep(50);
                }

                if (!hasMission) {
                    hasMission= BoxMap[1].MoveInfo.MoveStep == StoreMoveStep.SO_11_GoBack || BoxMap[2].MoveInfo.MoveStep == StoreMoveStep.SO_11_GoBack;
                }


                InOutStoreLog($"检测料架为空：BoxMap[1]={box1miscout},BoxMap[2]={box2miscout}");
                if (hasMission)
                {
                    InOutStoreLog("检测料架为空：检测到有待出库料盘,立刻开始出库");
                    if (!StartOutStoreMove(new InOutParam(MoveType.OutStore), true))
                    {
                        InOutStoreLog("检测料架为空：转换出库失败.");
                        LI_31_BatchAxisToP1();
                        //MoveEndP();
                    }
                }
                else
                {
                    LI_31_BatchAxisToP1();
                }                    
                
            }
        }

        private void LI_31_BatchAxisToP1()
        {
            MoveInfo.NextMoveStep(StoreMoveStep.LI_31_BatchAxisToP1);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
            InOutStoreLog("料盘移栽 ：未检测到料盘，提升伺服到P1点 ["+ Config.BatchAxis_P1 + "] ");
            UpdateShelfNum(CurrShelfNum, 0);
            T1_BatchAxis.SuddenStop();
            T1_BatchAxis.AbsMove(MoveInfo, Config.BatchAxis_P1, Config.BatchAxis_P1Speed);
        }

        private void BatchAxisToP2(bool isFirstMove = true)
        {
            int targetP2 = Config.BatchAxis_P2;
            int targetSpeed = Config.BatchAxis_P2Speed;
            if (!isFirstMove)
            {
                int currPosition = T1_BatchAxis.GetAclPosition();
                if (currPosition != -1)
                {
                    targetP2 = currPosition + Config.BatchAxis_ChangeValue * 80;
                    if (targetP2 > Config.BatchAxis_P2)
                    {
                        targetP2 = Config.BatchAxis_P2;
                    }
                    LogUtil.info(Name + " BatchAxisToP2 目标P2: " + targetP2 + "(" + currPosition + ")");
                }
                //targetSpeed = Config.BatchAxis_P3Speed / 2;
            }
            MoveInfo.TimeOutSeconds = 200;
            MoveInfo.CanWhileCount = 0;
            //  需要增加定时器，获取验证信号并停止伺服
            StartMovePosition = T1_BatchAxis.GetAclPosition();
            MoveInfo.WaitList.Add(WaitResultInfo.WaitBatchAxisMove(Config.T1_Batch_Axis, targetP2, targetSpeed));
            Config.T1_Batch_Axis.TargetPosition = targetP2;
            T1_BatchAxis.AbsMove(null, targetP2, isFirstMove?targetSpeed: targetSpeed/2);
            //开始检测信号
            T1_BatchAxis.BatchAxisStartCheck(IO_Type.BatchAxis_Check, IO_VALUE.HIGH);
        }

        private int GetHeight()
        {
            LastHeight = 0;
            int AxisChangeValue = Config.BatchAxis_ChangeValue;
            //计算高度
            EndMovePosition = T1_BatchAxis.GetAclPosition();
            bool isLast = false;
            int chaz = Math.Abs(EndMovePosition - Config.BatchAxis_P2);
            if (chaz < T1_BatchAxis.Config.CanErrorCountMax)
            {
                isLast = true;
            }
            float height = (float)Math.Ceiling(1F * Math.Abs(EndMovePosition - StartMovePosition) / AxisChangeValue);
            string buchongStr = "";
            if (isLast)
            {
                buchongStr = $"(最后一盘料已补充{Config.LastTrayAddHeight})";
                height += Config.LastTrayAddHeight;
            }
            if (LastWidth == 15) {
                height -= 2;
            }else if (LastWidth == 13)
            {
                //height -= 3;
            }
            //如果检测出<=15,都按照8计算
            if (height < 12)
            {
                LastHeight = 8;
            }
            else
            {
                List<int> heightList = new List<int> { 8, 12, 16, 24, 32, 44, 56 };
                //heightList = (from m in heightList orderby m descending select m).ToList<int>();
                //float minCha = height;
                foreach (int h in heightList)
                {
                    if (height > h)
                    {
                        LastHeight = h;
                    }/*
                    //取差值最小的接近值
                    float cha = Math.Abs(h - (height - 4));
                    if (cha < minCha)
                    {
                        LastHeight = h;
                        minCha = cha;
                    }*/
                }
            }
            if (LastHeight <= 8) { LastHeight = 8; }
            string code = CodeManager.ProcessCode(LastCodeList);
            string msg = Name + " 计算盘高：上升前 [" + StartMovePosition + "]实时[ " + EndMovePosition + "]差值[" + (EndMovePosition - StartMovePosition) + "]系数[" + AxisChangeValue + "] 计算后" + buchongStr + "[" + height + "]" + ",归类为【" + LastHeight + "mm】条码【" + code + "】";
            LogUtil.info(msg);
            return LastHeight;
        }

        public int GetWidth()
        {
            if (IOManager.IOValue(IO_Type.TrayCheck_15, 0).Equals(IO_VALUE.HIGH))
                return 15;
            if (IOManager.IOValue(IO_Type.TrayCheck_11to13, 0).Equals(IO_VALUE.HIGH)) 
                return 13;

            return 7;
        }

        #endregion

        #region MyRegion


        internal bool BoxDoorFree(int id)
        {
            if (MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                if (MoveInfo.MoveStep >= StoreMoveStep.LO_13_UpdownDown && MoveInfo.MoveStep <= StoreMoveStep.LO_15_UpdownUp)
                {
                    if (MoveInfo.MoveParam != null && MoveInfo.MoveParam.TargetBox.Equals(id))
                    {
                        return false;
                    }
                }

            }else if (MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                if (MoveInfo.MoveStep >= StoreMoveStep.LI_23_UpdownDown && MoveInfo.MoveStep <= StoreMoveStep.LI_26_AxisToWait)
                {
                    if (MoveInfo.MoveParam!=null && MoveInfo.MoveParam.TargetBox.Equals(id))
                    {
                        return false;
                    }
                }
            }
            return true ;
        }

        #endregion

    }
}