using Asa;
using log4net.Util;
using OnlineStore.Common;
using OnlineStore.DeviceLibrary.deviceLibrary;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static System.Windows.Forms.AxHost;

namespace OnlineStore.DeviceLibrary
{
    partial class InputEquip
    {
        public bool ClampEmptyMove = false;
        public Dictionary<int, int> reelHeightOffset = new Dictionary<int, int>();
        public string InstoreNgMsg = "";
        protected override bool CheckWaitResult(DeviceMoveInfo moveInfo, WaitResultInfo wait)
        {
            TimeSpan span = DateTime.Now - moveInfo.LastSetpTime;
            if (wait.WaitType.Equals(WaitEnum.W004_ClampReached))
            {
                if (ClampJaw != null)
                {
                    if (ClampJaw.IsReached())
                    {
                        float currp = ClampJaw.GetPosition() - (float)wait.TargetPosition;
                        if (currp < 1)
                        {
                            wait.IsEnd = true;
                        }
                    }
                }
            }
            else if (wait.WaitType.Equals(WaitEnum.W005_WaitHasReel))
            {
                if (ClampJaw != null)
                {
                    wait.IsEnd = ClampJaw.HasReel();

                    if ((!wait.IsEnd) && ClampEmptyMove)
                    {
                        LogUtil.info(Name + " 用户点击了：忽略夹爪有料信号，继续出入库动作");
                        wait.IsEnd = true;
                    }
                    //如果是运动中，且到达目标，认为有料 
                    if ((!wait.IsEnd) && ClampJaw.IsMoving() && ClampJaw.IsReached() && span.TotalSeconds > 3)
                    {
                        LogUtil.info(Name + "  无料，但在运动中，且运动到位，认为有料");
                        wait.IsEnd = true;
                    }
                }
            }

            return wait.IsEnd;
        }
        bool Is7CunReel()
        {
            return MoveInfo.MoveParam.PosInfo.PlateW == 7;
        }
        int getOffset()
        {
            if (reelHeightOffset.ContainsKey(MoveInfo.MoveParam.PosInfo.PlateH))
            {
                return reelHeightOffset[MoveInfo.MoveParam.PosInfo.PlateH];
            }
            return 0;
        }
        void II44_UpdownToP5()
        {
            MoveInfo.NextMoveStep(StepEnum.II44_UpdownToP5);

            if (Is7CunReel())
            {
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 升降轴 到P5(A上暂存区7寸放料低点){Config.Updown_P5_AUpperL7 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P5_AUpperL7 + getOffset(), Config.Updown_P5_Speed);
            }
            else
            {
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 升降轴 到P14(A上暂存区13寸放料低点){Config.Updown_P14_AUpperL13 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P14_AUpperL13 + getOffset(), Config.Updown_P14_Speed);
            }
        }
        void II64_UpdownToP11()
        {
            MoveInfo.NextMoveStep(StepEnum.II64_UpdownToP11);
            if (Is7CunReel())
            {
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 升降轴 到P11 (B上暂存区7寸放料低点){Config.Updown_P11_BUpperL7 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P11_BUpperL7 + getOffset(), Config.Updown_P11_Speed);
            }
            else
            {
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 升降轴 到P16 (B上暂存区13寸放料低点){Config.Updown_P16_BUpperL13 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P16_BUpperL13 + getOffset(), Config.Updown_P17_Speed);
            }
        }
        /// <summary>
        /// 取料升降轴SVD12  运动到P7（A下暂存区取料低点）
        /// </summary>
        void IO04_UpdownToP7(int shelf)
        {
            MoveInfo.NextMoveStep(StepEnum.IO04_UpdownToP7);
            if (Is7CunReel())
            {
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P7（A下暂存区7寸取料低点）{Config.Updown_P7_AUnderL7 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P7_AUnderL7 + getOffset(), Config.Updown_P7_Speed);
            }
            else
            {
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P15（A下暂存区13寸取料低点）{Config.Updown_P15_AUnderL13 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P15_AUnderL13 + getOffset(), Config.Updown_P15_Speed);
            }
        }
        void IO14_UpdownToP13(int shelf)
        {
            MoveInfo.NextMoveStep(StepEnum.IO14_UpdownToP13);
            if (Is7CunReel())
            {
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P13（B下暂存区7寸取料低点）{Config.Updown_P13_BUnderL7 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P13_BUnderL7 + getOffset(), Config.Updown_P13_Speed);
            }
            else
            {
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P17（B下暂存区13寸取料低点）{Config.Updown_P17_BUnderL13 + getOffset()}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P17_BUnderL13 + getOffset(), Config.Updown_P17_Speed);
            }

        }
        /// <summary>
        /// 检查夹爪是否有料
        /// </summary>
        /// <returns></returns>
        bool CheckClampHasReel()
        {
            return IOValue(IO_Type.Feeding_Reel_13_Check).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.Feeding_Reel_7_Check).Equals(IO_VALUE.HIGH);
        }
        #region 入库
        private DateTime startInTime = DateTime.Now;
        public override bool StartInstore(InOutParam param)
        {
            if (!NoAlarm())
            {
                LogInfo("报警中，无法开始取料入库：" + param.PosInfo.ToStr());
                return false;
            }
            if (AxisInWorkingArea(new int[] { 1, 2, 3, 4 }))
            {
                LogInfo("选择轴在暂存区，请先手动复位。 取料入库失败：" + param.PosInfo.ToStr());
                return false;
            }
            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                runStatus = RunStatus.Busy;
                MoveInfo.NewMove(MoveType.InStore, param);
                startInTime = DateTime.Now;

                int updownP = UpdownAxis.GetAclPosition();

                //如果升降轴在待机点上方，上方为-
                int upP1 = Config.Updown_P1 + 1000;
                //if (UpdownAxis.IsInPosition(Config.Updown_P1))
                if (UpdownAxis.IsInPosition(Config.Updown_P1) || (updownP <= upP1))
                {
                    II01_InoutToP1();
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.II01_UpdownToP1);
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                    MoveLog($"开始入库{param.ShelfType}{MoveInfo.SLog}:  升降轴先返回P1{Config.Updown_P1}");
                }
                return true;
            }
            return false;
        }

        protected override void InstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            int shelf = MoveInfo.MoveParam.ShelfType;

            #region 入库取料，获取库位号
            //if (MoveInfo.IsStep(StepEnum.II00_MiddleToP1))
            //{
            //    if (UpdownAxis.IsInPosition(Config.Updown_P1))
            //    {
            //        ToShelfMove();
            //    }
            //    else
            //    {
            //        MoveInfo.NextMoveStep(StepEnum.II01_UpdownToP1);
            //        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
            //        MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  升降轴先返回P1{Config.Updown_P1}"); 
            //    }
            //}
            if (MoveInfo.IsStep(StepEnum.II01_UpdownToP1))
            {
                II01_InoutToP1();
            }
            else if (MoveInfo.IsStep(StepEnum.II01_InoutToP1))
            {
                ToShelfMove();

            }
            else if (MoveInfo.IsStep(StepEnum.II02_MIddleToP2))
            {
                II07_InoutToP4P5();

            }
            else if (MoveInfo.IsStep(StepEnum.II05_MIddleToP3))
            {
                II07_InoutToP4P5();
            }
            else if (MoveInfo.IsStep(StepEnum.II07_InoutToP4P5))
            {
                II0306_UpdownToP2P3();
            }
            else if (MoveInfo.IsStep(StepEnum.II03_UpdownToP2))
            {
                II08_ClampWork();
            }
            else if (MoveInfo.IsStep(StepEnum.II06_UpdownToP3))
            {
                II08_ClampWork();
            }
            else if (MoveInfo.IsStep(StepEnum.II08_ClampWork))
            {
                MoveInfo.NextMoveStep(StepEnum.II09_UpdownToP1);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  升降轴到待机点P1 {Config.Updown_P1}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II09_UpdownToP1))
            {
                II10_WaitAxisCheck();
            }
            else if (MoveInfo.IsStep(StepEnum.II10_WaitAxisCheck))
            {
                II10_WaitAxisCheck();
            }
            else if (MoveInfo.IsStep(StepEnum.II11_WaitHeight))
            {
                BatchMoveBean moveBean = BatchMove_A;
                if (shelf.Equals(2))
                {
                    moveBean = BatchMove_B;
                }
                if (moveBean.LastHeight > 0)
                {
                    ClearTimeoutAlarm("获取料盘高度完成超时");
                    int Height = moveBean.LastHeight;
                    int width = 7;
                    if (IOValue(IO_Type.Feeding_Reel_13_Check).Equals(IO_VALUE.HIGH))
                    {
                        width = 13;
                    }
                    if (ConfigHelper.Config.Get("IPCamera_EnableAOI", false))
                    {
                        var check13 = moveBean.CameraCheck(MoveInfo.Name, out string err);
                        if (check13)
                        {
                            width = 13;
                            MoveLog($"入库取料{shelf}{MoveInfo.SLog}: 检测到有料，认为13寸：{err}");
                        }
                        else
                        {
                            width = 7;
                            MoveLog($"入库取料{shelf}{MoveInfo.SLog}: 检测到无料，认为7寸：{err}");
                        }
                    }
                    MoveInfo.MoveParam.PosInfo.PlateH = Height;
                    MoveInfo.MoveParam.PosInfo.PlateTotalH = moveBean.LastTotalHeight;
                    MoveInfo.MoveParam.PosInfo.PlateW = width;

                    MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  料盘尺寸{width}X{Height}");
                    II13_GetPosId();
                }
                else if (MoveInfo.IsTimeOut(60))
                {
                    SetWarnMsg(Name + " " + moveBean.Name + "获取料盘高度超时");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II13_GetPosId))
            {
                if (getPosTask != null && getPosTask.IsCompleted && LastPosInfo != null)
                {
                    getPosIdMsg = "";
                    ClearTimeoutAlarm("获取库位号超时");
                    InOutPosInfo oldPos = MoveInfo.MoveParam.PosInfo;
                    if ((!LastPosInfo.PlateH.Equals(oldPos.PlateH)) || (!LastPosInfo.PlateW.Equals(oldPos.PlateW)))
                    {
                        MoveLog(" " + MoveInfo.SLog + " 原有料盘尺寸：【" + oldPos.PlateW + "X" + oldPos.PlateH + "】服务器返回尺寸【" + LastPosInfo.PlateW + "X" + LastPosInfo.PlateH + "】   ");
                    }
                    MoveInfo.MoveParam.PosInfo = LastPosInfo;
                    if (LastResult.Equals(98))
                    {
                        //出库料 暂不处理出库，全部入库

                    }
                    StrartToTargetP();
                }
                else if (MoveInfo.IsTimeOut(15))
                {
                    SetWarnMsg("获取库位号超时 " + getPosIdMsg);
                }
            }

            #endregion

            #region 入料->A侧上暂存区
            //else if (MoveInfo.IsStep(StepEnum.II40_UpdownToP4))
            //{
            //    II41_MiddleToP4();
            //}
            else if (MoveInfo.IsStep(StepEnum.II41_MiddleToP4))
            {
                //如果无料且暂存区为空，进出轴出去
                bool empty = (BufferDataManager.AInStoreInfo == null || BufferDataManager.AInStoreInfo.PosId.Equals(""));
                if (IOValue(IO_Type.FeedingA_Instore_UpperArea_ReelCheck).Equals(IO_VALUE.LOW) && empty)
                {
                    II43_InoutToP2();
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.II42_WaitNoReel);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区有料，等待暂存区无料");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II42_WaitNoReel))
            {
                if (BufferDataManager.AInStoreInfo == null || BufferDataManager.AInStoreInfo.PosId.Equals(""))
                {
                    ClearTimeoutAlarm("A上暂存区物料拿走");
                    MoveInfo.NextMoveStep(StepEnum.II43_InoutToP2);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区为空， 进出轴 到P2(A暂存区放料点){Config.Inout_P2}");
                    InOutAxis.AbsMove(MoveInfo, Config.Inout_P2, Config.Inout_P2_Speed);
                }
                else if (MoveInfo.IsTimeOut(120))
                {
                    if (StoreManager.XLRStore.boxEquip.runStatus == RunStatus.Reset ||
                         StoreManager.XLRStore.boxEquip.runStatus == RunStatus.HomeMoving)
                    {
                        MoveInfo.LastSetpTime = DateTime.Now;
                    }
                    else
                        SetWarnMsg("A上暂存区物料拿走");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II43_InoutToP2))
            {
                TrayHasLeave();
                II44_UpdownToP5();
            }
            else if (MoveInfo.IsStep(StepEnum.II44_UpdownToP5))
            {
                MoveInfo.NextMoveStep(StepEnum.II45_ClampRelax);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 夹爪放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.II45_ClampRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.II46_UpdownToP4);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 升降轴 到P4(A上暂存区放料高点){Config.Updown_P4_AUpperH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P4_AUpperH, Config.Updown_P4_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II46_UpdownToP4))
            {
                MoveInfo.NextMoveStep(StepEnum.II47_1_InoutToP1);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 进出轴 到P1{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II47_1_InoutToP1))
            {
                if (!BatchMove_A.IsInScanCode())
                {
                    int targetV = Config.Middle_P4_AUpper;
                    MoveInfo.NextMoveStep(StepEnum.II47_MiddleToP1);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 旋转轴 到P4{targetV}");
                    MiddleAxis.AbsMove(MoveInfo, targetV, Config.Middle_P1_Speed);
                }
                //else if (MoveInfo.IsTimeOut())
                //{
                //    MoveTimeOut(MoveInfo, "等待" + BatchMove_A.Name + "扫码结束");
                //}
            }
            else if (MoveInfo.IsStep(StepEnum.II47_MiddleToP1))
            {
                TimeSpan span = DateTime.Now - startInTime;
                MoveLog($" 入料->A侧放料结束，更新A上暂存区物料{MoveInfo.MoveParam.PosInfo.ToStr()}，耗时【{FormUtil.GetSpanStr(span)}】");
                BufferDataManager.AInStoreInfo = MoveInfo.MoveParam.PosInfo;
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                InoutEndEvent();
            }
            #endregion

            #region 入料->B侧上暂存区

            //else if (MoveInfo.IsStep(StepEnum.II60_UpdownToP10))
            //{
            //    bool empty = BufferDataManager.BInStoreInfo == null || BufferDataManager.BInStoreInfo.PosId.Equals("");
            //    if (IOValue(IO_Type.FeedingB_Instore_UpperArea_ReelCheck).Equals(IO_VALUE.LOW) && empty)
            //    {
            //        II63_MiddleToP5();
            //    }
            //    else
            //    {
            //        int targetValue = Config.Middle_P5_BUpper + Config.MiddleOffsetValue;
            //        MoveInfo.NextMoveStep(StepEnum.II61_MiddleToP5);
            //        MoveLog($" 入料->B侧 {MoveInfo.SLog}: 暂存区有料， 旋转轴 到P5{Config.Middle_P5_BUpper}-{Config.MiddleOffsetValue}=目标{targetValue}位置等待暂存区无料");
            //        MiddleAxis.AbsMove(MoveInfo, targetValue, Config.Middle_P5_Speed);
            //    }
            //}
            else if (MoveInfo.IsStep(StepEnum.II61_MiddleToP5))
            {
                bool empty = BufferDataManager.BInStoreInfo == null || BufferDataManager.BInStoreInfo.PosId.Equals("");
                if (IOValue(IO_Type.FeedingB_Instore_UpperArea_ReelCheck).Equals(IO_VALUE.LOW) && empty)
                {
                    II63_InoutToP3();
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.II62_WaitNoReel);
                    MoveLog($" 入料->B侧 {MoveInfo.SLog}: 暂存区有料，等待暂存区无料");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II62_WaitNoReel))
            {
                if (BufferDataManager.BInStoreInfo == null || BufferDataManager.BInStoreInfo.PosId.Equals(""))
                {
                    ClearTimeoutAlarm("B上暂存区物料拿走");
                    II63_InoutToP3();
                }
                else if (MoveInfo.IsTimeOut(120))
                {
                    if (StoreManager.XLRStore.boxEquip.runStatus == RunStatus.Reset ||
                        StoreManager.XLRStore.boxEquip.runStatus == RunStatus.HomeMoving)
                    {
                        MoveInfo.LastSetpTime = DateTime.Now;
                    }
                    else
                        SetWarnMsg("B上暂存区物料拿走");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II63_InoutToP3))
            {
                TrayHasLeave();
                II64_UpdownToP11();
            }
            else if (MoveInfo.IsStep(StepEnum.II64_UpdownToP11))
            {
                MoveInfo.NextMoveStep(StepEnum.II65_ClampRelax);
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 夹爪放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.II65_ClampRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.II66_UpdownToP10);
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 升降轴 到P10 (B上暂存区放料高点){Config.Updown_P10_BUpperH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P10_BUpperH, Config.Updown_P10_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II66_UpdownToP10))
            {
                MoveInfo.NextMoveStep(StepEnum.II67_1_InoutToP1);
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 进出轴 到待机点P1{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II67_1_InoutToP1))
            {
                //需要等A侧料串不扫码时再过去
                if (!BatchMove_B.IsInScanCode())
                {
                    // int targetValue = Config.Middle_P5_BUpper + Config.MiddleOffsetValue;

                    MoveInfo.NextMoveStep(StepEnum.II67_MiddleToP1);
                    MoveLog($" 入料->B侧 {MoveInfo.SLog}: 旋转轴 到P5{Config.Middle_P5_BUpper}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P5_BUpper, Config.Middle_P5_Speed);
                    //MoveLog($" 入料->B侧 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    //MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
                else if (MoveInfo.IsTimeOut(30))
                {
                    Msg.add("等待" + BatchMove_B.Name + "扫码结束", MsgLevel.warning);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II67_MiddleToP1))
            {
                TimeSpan span = DateTime.Now - startInTime;
                MoveLog($" 入料->B侧放料结束，更新B上暂存区物料{MoveInfo.MoveParam.PosInfo.ToStr()}，耗时【{FormUtil.GetSpanStr(span)}】");
                BufferDataManager.BInStoreInfo = MoveInfo.MoveParam.PosInfo;
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                InoutEndEvent();
            }
            #endregion

            #region 入料->NG箱
            else if (MoveInfo.IsStep(StepEnum.II81_MiddleToNg))
            {
                MoveInfo.NextMoveStep(StepEnum.II82_InoutToP6);
                InstoreNgMsg = $"入库ng :{MoveInfo.MoveParam.PosInfo?.ToStr()}";
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 进出轴到P6（NG料区放料点）{Config.Inout_P6}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P6, Config.Inout_P6_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II82_InoutToP6))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II83_UpdownToP9);
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 升降轴到P9（NG料区放料低点）{Config.Updown_P9_NGL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P9_NGL, Config.Updown_P9_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II83_UpdownToP9))
            {
                MoveInfo.NextMoveStep(StepEnum.II84_ClampRelax);
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 夹爪放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.II84_ClampRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.II85_UpdownToP8);
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 升降轴到P8（NG料区放料高点）{Config.Updown_P8_NGH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8_NGH, Config.Updown_P8_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II85_UpdownToP8))
            {
                MoveInfo.NextMoveStep(StepEnum.II86_1_InoutToP1);
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 进出轴到P1（待机点）{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II86_1_InoutToP1))
            {
                InstoreNgMsg = "";
                if (shelf.Equals(1))
                {
                    MoveLog($" 入料->NG箱放料结束");
                    MoveInfo.EndMove();
                    runStatus = RunStatus.Runing;
                }
                else
                {
                    //旋转轴暂不回待机点
                    MoveInfo.NextMoveStep(StepEnum.II86_MiddleToP1);
                    MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II86_MiddleToP1))
            {
                TimeSpan span = DateTime.Now - startInTime;
                MoveLog($" 入料->NG箱放料结束，耗时【{FormUtil.GetSpanStr(span)}】");
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                InoutEndEvent();
            }
            #endregion

        }

        private void II63_InoutToP3()
        {
            MoveInfo.NextMoveStep(StepEnum.II63_InoutToP3);
            MoveInfo.TimeOutSeconds = 10;
            MoveLog($" 入料->B侧 {MoveInfo.SLog}: 暂存区无料，进出轴 到P3 (B暂存区放料点){Config.Inout_P3}");
            InOutAxis.AbsMove(MoveInfo, Config.Inout_P3, Config.Inout_P3_Speed);
        }

        private void II43_InoutToP2()
        {
            MoveInfo.NextMoveStep(StepEnum.II43_InoutToP2);
            MoveInfo.TimeOutSeconds = 10;
            MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区为空， 进出轴 到P2(A暂存区放料点){Config.Inout_P2}");
            InOutAxis.AbsMove(MoveInfo, Config.Inout_P2, Config.Inout_P2_Speed);
        }
        private void II01_InoutToP1()
        {
            MoveInfo.NextMoveStep(StepEnum.II01_InoutToP1);
            MoveLog($"入库取料{MoveInfo.SLog}: 进出轴到P1 {Config.Inout_P1}");
            InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
        }
        private void II0306_UpdownToP2P3()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                MoveInfo.NextMoveStep(StepEnum.II03_UpdownToP2);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  升降轴到P2（A料口取料点） {Config.Updown_P2_ATake}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P2_ATake, Config.Updown_P2_Speed);
            }
            else if (shelf.Equals(2))
            {
                MoveInfo.NextMoveStep(StepEnum.II06_UpdownToP3);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  升降轴到P3（B料口取料点） {Config.Updown_P3_BTake}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P3_BTake, Config.Updown_P3_Speed);
            }



        }
        private void II07_InoutToP4P5()
        {
            MoveInfo.NextMoveStep(StepEnum.II07_InoutToP4P5);
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}: 进出轴到P4(A料口取料点){Config.Inout_P4}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P4, Config.Inout_P4_Speed);
            }
            else if (shelf.Equals(2))
            {
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}: 进出轴到P5(B料口取料点){Config.Inout_P5}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P5, Config.Inout_P5_Speed);
            }
        }
        private void ToShelfMove()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                MoveInfo.NextMoveStep(StepEnum.II02_MIddleToP2);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  升降轴下降到P1{Config.Updown_P1}，旋转轴到P2（A料口取料点）{Config.Middle_P2_ATake}");//，等待{IO_Type.MAxis_Check_A}信号亮
                if (!UpdownAxis.IsInPosition(Config.Updown_P1))
                {
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                }
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P2_ATake, Config.Middle_P2_Speed);
                // MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_A, IO_VALUE.HIGH));
            }
            else if (shelf.Equals(2))
            {
                MoveInfo.NextMoveStep(StepEnum.II05_MIddleToP3);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:   升降轴下降到P1{Config.Updown_P1}，旋转轴到P3（B料口取料点）{Config.Middle_P3_BTake}");//，等待{IO_Type.MAxis_Check_B}信号亮
                if (!UpdownAxis.IsInPosition(Config.Updown_P1))
                {
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                }
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P3_BTake, Config.Middle_P3_Speed);
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_B, IO_VALUE.HIGH));
            }
            else
            {
                MoveLog($"入库{MoveInfo.SLog}未找到料串{shelf},结束处理");
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
            }
        }
        private void StrartToTargetP()
        {
            InOutPosInfo lastPosInfo = MoveInfo.MoveParam.PosInfo;
            int shelf = MoveInfo.MoveParam.ShelfType;
            //判断是A还是B
            if (lastPosInfo.IsNG)
            {
                MoveInfo.NextMoveStep(StepEnum.II81_MiddleToNg);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  NG料{lastPosInfo.ToStr()} 升降轴到P8（NG料区放料高点）{Config.Updown_P8_NGH}，旋转轴到P6（NG料区放料点）{Config.Middle_P6_NG}");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P6_NG, Config.Middle_P6_Speed);
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8_NGH, Config.Updown_P8_Speed);
            }
            else
            {
                //检查暂存区是否有相同料
                if (BufferDataManager.AInStoreInfo != null && BufferDataManager.AInStoreInfo.barcode.Equals(lastPosInfo.barcode) && IOValue(IO_Type.FeedingA_Instore_UpperArea_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    SServerManager.cancelPutInTask(Name, BufferDataManager.AInStoreInfo.barcode);
                    BufferDataManager.AInStoreInfo = null;
                    MoveLog($"入库取料{MoveInfo.SLog}:  A上暂存区已有相同{lastPosInfo.ToStr()}，且信号未亮，清除A上暂存区");
                }
                else if (BufferDataManager.BInStoreInfo != null && BufferDataManager.BInStoreInfo.barcode.Equals(lastPosInfo.barcode) && IOValue(IO_Type.FeedingB_Instore_UpperArea_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    SServerManager.cancelPutInTask(Name, BufferDataManager.BInStoreInfo.barcode);
                    BufferDataManager.BInStoreInfo = null;
                    MoveLog($"入库取料{MoveInfo.SLog}:  A上暂存区已有相同{lastPosInfo.ToStr()}，且信号未亮，清除B上暂存区");
                }
                if (lastPosInfo.GetPosSide().Equals("A"))
                {
                    II41_MiddleToP4();
                }
                else
                {
                    II61_MiddleToP5();
                }
            }

            TrayStartLeave();
        }

        private void II61_MiddleToP5()
        {
            MoveInfo.NextMoveStep(StepEnum.II61_MiddleToP5);
            MoveLog($" 入料->B侧 {MoveInfo.SLog}: 暂存区有料，升降轴 到P10（B上暂存区放料高点){Config.Updown_P10_BUpperH}， 旋转轴 到P5位置,等待暂存区无料");
            UpdownAxis.AbsMove(MoveInfo, Config.Updown_P10_BUpperH, Config.Updown_P10_Speed);
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P5_BUpper, Config.Middle_P5_Speed);
        }

        private void II41_MiddleToP4()
        {
            MoveInfo.NextMoveStep(StepEnum.II41_MiddleToP4);
            MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区有料，升降轴 到P4(A上暂存区放料高点){Config.Updown_P4_AUpperH}， 旋转轴 到P4{Config.Middle_P4_AUpper}位置,等待暂存区无料");
            UpdownAxis.AbsMove(MoveInfo, Config.Updown_P4_AUpperH, Config.Updown_P4_Speed);
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P4_AUpper, Config.Middle_P4_Speed);
        }

        private Task getPosTask = null;
        private InOutPosInfo LastPosInfo = null;
        private int LastResult = 0;
        private string getPosIdMsg = "";
        private void II13_GetPosId()
        {
            MoveInfo.NextMoveStep(StepEnum.II13_GetPosId);
            MoveLog($"入库{MoveInfo.SLog}:  清空LastPosResult，从服务器获取入库库位,进出轴回待机点P1 {Config.Inout_P1}");
            InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            LastPosInfo = null;
            InOutPosInfo pos = MoveInfo.MoveParam.PosInfo;
            List<string> codeList = Regex.Split(pos.barcode, "##", RegexOptions.IgnoreCase).ToList();
            getPosTask = Task.Factory.StartNew(delegate
            {
                //更新托盘条码信息 
                try
                {
                    int count = 1;
                    while (MoveInfo.MoveType.Equals(MoveType.InStore))
                    {
                        int ms = 5000;


                        string lastPosId = "";
                        //如果左侧是空右侧有料
                        if (BufferDataManager.AInStoreInfo == null && (BufferDataManager.BInStoreInfo != null))
                        {
                            lastPosId = BufferDataManager.BInStoreInfo.PosId;
                        }
                        else if (BufferDataManager.AInStoreInfo != null && (BufferDataManager.BInStoreInfo == null))
                        {
                            lastPosId = BufferDataManager.AInStoreInfo.PosId;
                        }

                        //从服务器获取库位号
                        GetPosResult result = SServerManager.GetPosId(Name, codeList, pos.PlateH, pos.PlateW, pos.rfid, lastPosId,pos.PlateTotalH);
                        LastResult = result.Result;
                        if (result.IsTimeOut)
                        {
                            if (count < 5)
                            {
                                ms = 2000;
                            }
                            Thread.Sleep(ms);
                            LogUtil.error(Name + "【" + pos.barcode + "】第[" + count + "]次 " + MoveInfo.SLog + " 超时，等待" + ms + "后重新获取");
                        }
                        else if (result.Result.Equals(99) || result.Result.Equals(100))
                        {
                            if (count < 5)
                            {
                                ms = 3000;
                            }
                            getPosIdMsg = result.Msg;
                            Thread.Sleep(ms);
                            LogUtil.error(Name + "【" + pos.barcode + "】第[" + count + "]次  " + MoveInfo.SLog + "  结果【" + result.Result + "】，等待" + ms + "后重新获取");
                        }
                        else if (!result.Msg.Equals(""))
                        {
                            LastPosInfo = result.Param;
                            LogUtil.error(Name + "【" + pos.barcode + "】第[" + count + "]次  " + MoveInfo.SLog + "  入库NG：" + result.Msg);
                            break;
                        }
                        else
                        {
                            LastPosInfo = result.Param;
                            break;
                        }

                        //if (count >= 3)
                        //{
                        //    //自动NG
                        //    LastPosInfo = new InOutPosInfo(pos.barcode, "");
                        //    LastPosInfo.IsNG = true;
                        //    LastPosInfo.NgMsg = "获取库位超过三次，直接NG";
                        //    break;
                        //}
                        count++;
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "【" + pos.barcode + "】 " + MoveInfo.SLog + " 获取库位号报错：" + ex.ToString());
                }

            });
        }
        private void II08_ClampWork()
        {
            MoveInfo.NextMoveStep(StepEnum.II08_ClampWork);
            MoveLog($"入库取料{MoveInfo.MoveParam.ShelfType}{MoveInfo.SLog}:  夹爪夹紧，判断到位 ");
            ClampWork(MoveInfo, true, MoveInfo.MoveParam.PosInfo.barcode);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
        }
        private void II10_WaitAxisCheck()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            MoveInfo.NextMoveStep(StepEnum.II10_WaitAxisCheck);
            MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  等待伺服检测信号消失,通知料串料盘已离开");
            if (shelf.Equals(1))
            {
                if (IOValue(IO_Type.ReelCheck_A).Equals(IO_VALUE.LOW))
                {
                    MoveInfo.NextMoveStep(StepEnum.II11_WaitHeight);
                    BatchMove_A.GetTrayOK();
                }
                else
                {
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ReelCheck_A, IO_VALUE.LOW));
                }
            }
            else if (shelf.Equals(2))
            {
                if (IOValue(IO_Type.ReelCheck_B).Equals(IO_VALUE.LOW))
                {
                    MoveInfo.NextMoveStep(StepEnum.II11_WaitHeight);
                    BatchMove_B.GetTrayOK();
                }
                else
                {
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ReelCheck_B, IO_VALUE.LOW));
                }
            }
        }
        #endregion

        #region 出库

        private void ToNG()
        {
            MoveInfo.NextMoveStep(StepEnum.II81_MiddleToNg);
            //清空暂存区
            int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
            if (startp.Equals(1))
            {
                BufferDataManager.AOutStoreInfo = null;
            }
            else
            {
                BufferDataManager.BOutStoreInfo = null;
            }
            MoveLog($"出库{MoveInfo.SLog}:  NG料 升降轴到P8（NG料区放料高点）{Config.Updown_P8_NGH}，旋转轴到P6（NG料区放料点）{Config.Middle_P6_NG}");
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P6_NG, Config.Middle_P6_Speed);
            UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8_NGH, Config.Updown_P8_Speed);
        }
        private void ToUrgentBox()
        {
            MoveInfo.NextMoveStep(StepEnum.I035_MiddleToUrgentBox);
            //清空暂存区
            int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
            if (startp.Equals(1))
            {
                BufferDataManager.AOutStoreInfo = null;
            }
            else
            {
                BufferDataManager.BOutStoreInfo = null;
            }
            MoveLog($"出库{MoveInfo.SLog}:  紧急料 升降轴到P18（紧急料区放料高点）{Config.Updown_P18_NGH}，旋转轴到P9（紧急料区放料点）{Config.Middle_P9_NG}");
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P9_NG, Config.Middle_P9_Speed);
            UpdownAxis.AbsMove(MoveInfo, Config.Updown_P18_NGH, Config.Updown_P18_Speed);
        }
        private DateTime startOutTime = DateTime.Now;
        public override bool StartOutstore(InOutParam param)
        {
            if (!NoAlarm())
            {
                LogError("报警中，无法开始出库：" + param.PosInfo.ToStr());
                return false;
            }
            if (AxisInWorkingArea(new int[] { 1, 2, 3, 4 }))
            {
                LogInfo("选择轴在暂存区，请先手动复位。出库失败：" + param.PosInfo.ToStr());
                return false;
            }
            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                if (!InOutAxis.IsInPosition(Config.Inout_P1)) return false;
                //获取位置是左侧还是右侧。
                int startp = param.PosInfo.GetPosType();
                if (startp.Equals(1))
                {
                    runStatus = RunStatus.Busy;
                    MoveInfo.NewMove(MoveType.OutStore, param);
                    startOutTime = DateTime.Now;
                    MoveInfo.NextMoveStep(StepEnum.IO01_ReelCheck);
                    if (!MiddleAxis.IsInPosition(Config.Middle_P1))
                    {
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(200));
                        MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                        MoveLog($"开始A下暂存区物料出库{MoveInfo.SLog}: 料串{param.ShelfType}，等待料盘检测=1，旋转轴到P1{Config.Middle_P1}");
                    }
                    else
                    {
                        MoveLog($"开始A下暂存区物料出库{MoveInfo.SLog}: 料串{param.ShelfType}，等待料盘检测=1");
                    }
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FeedingA_Outstore_UnderArea_ReelCheck, IO_VALUE.HIGH));
                }
                else if (startp.Equals(2))
                {
                    runStatus = RunStatus.Busy;
                    MoveInfo.NewMove(MoveType.OutStore, param);
                    startOutTime = DateTime.Now;
                    MoveInfo.NextMoveStep(StepEnum.IO11_ReelCheck);
                    if (!MiddleAxis.IsInPosition(Config.Middle_P1))
                    {
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(200));
                        MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                        MoveLog($"开始B下暂存区物料出库{MoveInfo.SLog}: 料串{param.ShelfType}，等待料盘检测=1，旋转轴到P1{Config.Middle_P1}");
                    }
                    else
                    {
                        MoveLog($"开始B下暂存区物料出库{MoveInfo.SLog}: 料串{param.ShelfType}，等待料盘检测=1");
                    }
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FeedingB_Outstore_UnderArea_ReelCheck, IO_VALUE.HIGH));
                }
                else
                {
                    LogInfo("出库失败，未找到库位位置：" + param.PosInfo.ToStr());
                    return false;
                }

                return true;
            }
            return false;
        }
        private void TrayHasLeave()
        {

        }
        private void TrayStartLeave()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                BatchMove_A.GetTrayStartLeave();
            }
            else if (shelf.Equals(2))
            {
                BatchMove_B.GetTrayStartLeave();
            }
        }
        /// <summary>
        /// 夹爪重试次数
        /// </summary>
        int clampTryCount = 0;
        protected override void OutstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            int shelf = MoveInfo.MoveParam.ShelfType;

            #region 出库A侧取料
            if (MoveInfo.IsStep(StepEnum.IO01_ReelCheck))
            {
                if (BufferDataManager.AOutStoreInfo != null)
                {
                    clampTryCount = 0;
                    if (BufferDataManager.AOutStoreInfo.barcode.Equals(MoveInfo.MoveParam.PosInfo.barcode))
                    {
                        MoveInfo.NextMoveStep(StepEnum.IO02_UpdownToP6);
                        MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P6（A下暂存区取料高点）{Config.Updown_P6_AUnderH},旋转轴到P7（A下暂存区取料点）{Config.Middle_P7_AUnder}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P6_AUnderH, Config.Updown_P6_Speed);
                        MiddleAxis.AbsMove(MoveInfo, Config.Middle_P7_AUnder, Config.Middle_P7_Speed);
                        ShelfBatchAxisDown();
                    }
                    else
                    {
                        MoveLog($"存储机构出的料盘信息[{BufferDataManager.AOutStoreInfo.ToStr()}]与准备出到料串上的料盘信息[{MoveInfo.MoveParam.PosInfo.ToStr()}]不符,结束等待");
                        MoveInfo.EndMove();
                    }
                }

            }
            else if (MoveInfo.IsStep(StepEnum.IO02_UpdownToP6))
            {
                MoveInfo.NextMoveStep(StepEnum.IO03_InoutToP2);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 进出轴到P2（A暂存区点）{Config.Inout_P2}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P2, Config.Inout_P2_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO03_InoutToP2))
            {
                IO04_UpdownToP7(shelf);
            }
            else if (MoveInfo.IsStep(StepEnum.IO04_UpdownToP7))
            {
                MoveInfo.NextMoveStep(StepEnum.IO05_ClampWork);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 电卡爪夹紧     判断到位");
                ClampWork(MoveInfo, true, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO05_ClampWork))
            {
                MoveInfo.NextMoveStep(StepEnum.IO06_UpdownToP6);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P6（A下暂存区取料高点）{Config.Updown_P6_AUnderH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P6_AUnderH, Config.Updown_P6_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO06_UpdownToP6))
            {
                if (CheckClampHasReel() || clampTryCount > 3)
                {
                    MoveInfo.NextMoveStep(StepEnum.IO07_1_InoutToP1);
                    clampTryCount = 0;
                    MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 进出轴到P1（待机点点）{Config.Inout_P1}");
                    InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO03_InoutToP2);
                    ClampRelax(MoveInfo);
                    clampTryCount++;
                    MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 未检测到料，重新抓取");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO07_1_InoutToP1))
            {
                //判断料盘信号是否消失 
                if (IOValue(IO_Type.FeedingA_Outstore_UnderArea_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    if (MoveInfo.MoveParam.PosInfo.IsNG)
                    {
                        ToNG();
                        return;
                    }
                    else if (string.IsNullOrEmpty(MoveInfo.MoveParam.PosInfo.hSerial))
                    {
                        ToUrgentBox();
                        return;
                    }
                    if (!MiddleToShelf())
                    {
                        MoveInfo.NextMoveStep(StepEnum.IO21_WaitShelfReady);
                        MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 等待料串可放料");
                    }
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO07_WaitReelCheckLow);
                    MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 料盘已拿走，等待料盘检测信号=0");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FeedingA_Outstore_UnderArea_ReelCheck, IO_VALUE.LOW));
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO07_WaitReelCheckLow))
            {
                if (MoveInfo.MoveParam.PosInfo.IsNG)
                {
                    ToNG();
                    return;
                }
                else if (string.IsNullOrEmpty(MoveInfo.MoveParam.PosInfo.hSerial))
                {
                    ToUrgentBox();
                    return;
                }
                if (!MiddleToShelf())
                {
                    MoveInfo.NextMoveStep(StepEnum.IO21_WaitShelfReady);
                    MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 等待料串可放料");
                }
            }
            #endregion

            #region 出库B侧取料
            else if (MoveInfo.IsStep(StepEnum.IO11_ReelCheck))
            {
                if (BufferDataManager.BOutStoreInfo != null)
                {
                    clampTryCount = 0;
                    if (BufferDataManager.BOutStoreInfo.barcode.Equals(MoveInfo.MoveParam.PosInfo.barcode))
                    {
                        MoveInfo.NextMoveStep(StepEnum.IO12_UpdownToP12);
                        MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P12（B下暂存区取料高点）{Config.Updown_P12_BUnderH}，旋转轴到P8（B下暂存区取料点）{Config.Middle_P8_BUnder}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P12_BUnderH, Config.Updown_P12_Speed);
                        MiddleAxis.AbsMove(MoveInfo, Config.Middle_P8_BUnder, Config.Middle_P8_Speed);
                        ShelfBatchAxisDown();
                    }
                    else
                    {
                        MoveLog($"存储机构出的料盘信息[{BufferDataManager.BOutStoreInfo.ToStr()}]与准备出到料串上的料盘信息[{MoveInfo.MoveParam.PosInfo.ToStr()}]不符,结束等待");
                        MoveInfo.EndMove();
                    }

                }

            }
            else if (MoveInfo.IsStep(StepEnum.IO12_UpdownToP12))
            {
                MoveInfo.NextMoveStep(StepEnum.IO13_InoutToP3);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 进出轴到P3(B暂存区点)");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P3, Config.Inout_P3_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO13_InoutToP3))
            {
                IO14_UpdownToP13(shelf);
            }
            else if (MoveInfo.IsStep(StepEnum.IO14_UpdownToP13))
            {
                MoveInfo.NextMoveStep(StepEnum.IO15_ClampWork);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 电卡爪夹紧     判断到位");
                ClampWork(MoveInfo, true, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO15_ClampWork))
            {
                MoveInfo.NextMoveStep(StepEnum.IO16_UpdownToP6);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P12（B下暂存区取料高点）{Config.Updown_P12_BUnderH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P12_BUnderH, Config.Updown_P12_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO16_UpdownToP6))
            {
                if (CheckClampHasReel() || clampTryCount > 3)
                {
                    MoveInfo.NextMoveStep(StepEnum.IO17_1_InoutToP1);
                    clampTryCount = 0;
                    MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: j进出轴到P11（待机点）{Config.Inout_P1}");
                    InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO13_InoutToP3);
                    ClampRelax(MoveInfo);
                    clampTryCount++;
                    MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 未检测到料，重新抓取");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO17_1_InoutToP1))
            {
                //判断料盘信号是否消失
                if (IOValue(IO_Type.FeedingB_Outstore_UnderArea_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    if (MoveInfo.MoveParam.PosInfo.IsNG)
                    {
                        ToNG();
                        return;
                    }
                    else if (string.IsNullOrEmpty(MoveInfo.MoveParam.PosInfo.hSerial))
                    {
                        ToUrgentBox();
                        return;
                    }
                    if (!MiddleToShelf())
                    {
                        MoveInfo.NextMoveStep(StepEnum.IO21_WaitShelfReady);
                        MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 等待料串可放料");
                    }
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IO17_WaitReelCheckLow);
                    MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 料盘已拿走，等待料盘检测信号=0");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FeedingB_Outstore_UnderArea_ReelCheck, IO_VALUE.LOW));
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO17_WaitReelCheckLow))
            {
                if (MoveInfo.MoveParam.PosInfo.IsNG)
                {
                    ToNG();
                    return;
                }
                else if (string.IsNullOrEmpty(MoveInfo.MoveParam.PosInfo.hSerial))
                {
                    ToUrgentBox();
                    return;
                }
                if (!MiddleToShelf())
                {
                    MoveInfo.NextMoveStep(StepEnum.IO21_WaitShelfReady);
                    MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 等待料串可放料");
                }
            }
            #endregion

            #region 出库放料到料串
            else if (MoveInfo.IsStep(StepEnum.IO21_WaitShelfReady))
            {
                if (MiddleToShelf())
                {
                }
                else if (MoveInfo.IsTimeOut(30))
                {
                    SetWarnMsg("等待料串可放料");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IO23_MiddleToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IO24_InoutToP4);
                MoveLog($"出库->A料串 {MoveInfo.SLog}: 料盘已离开，进出轴到P4（A料口取料点）{Config.Inout_P4}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P4, Config.Inout_P4_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO24_InoutToP4))
            {
                MoveInfo.NextMoveStep(StepEnum.IO25_UpdownToP2);
                MoveLog($"出库->A料串 {MoveInfo.SLog}:升降轴到P2（A料口取料点）{Config.Updown_P2_ATake}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P2_ATake, Config.Updown_P2_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO27_MiddleToP3))
            {
                MoveInfo.NextMoveStep(StepEnum.IO28_InoutToP5);
                MoveLog($"出库->B料串 {MoveInfo.SLog}: 料盘已离开，进出轴到P5（B料口取料点）{Config.Inout_P5}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P5, Config.Inout_P5_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO25_UpdownToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IO31_ClampRelax);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 电卡爪放松   判断到位");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO28_InoutToP5))
            {
                MoveInfo.NextMoveStep(StepEnum.IO29_UpdownToP3);
                MoveLog($"出库->B料串 {MoveInfo.SLog}: 升降轴到P3（B料口取料点）{Config.Updown_P3_BTake}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P3_BTake, Config.Updown_P3_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO29_UpdownToP3))
            {
                MoveInfo.NextMoveStep(StepEnum.IO31_ClampRelax);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 电卡爪放松   判断到位");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO31_ClampRelax))
            {
                if (!StoreManager.XLRStore.boxEquip.SendStoreState(MoveInfo.MoveParam.PosInfo.PosId, MoveInfo.MoveParam.PosInfo.barcode, DeviceStatus.OutStoreEnd))
                    return;
                Msg.add($"出库完成：【{MoveInfo.MoveParam.PosInfo.PosId}】【{MoveInfo.MoveParam.PosInfo.barcode}】【{DeviceStatus.OutStoreEnd}】", MsgLevel.info);
                if (shelf.Equals(1))
                {

                    BatchMove_A.ReelPutOk();
                    SServerManager.ShelfFinish(BatchMove_A.CurrShelf.ShelfRfid, MoveInfo.MoveParam.PosInfo.barcode);
                }
                else
                {
                    BatchMove_B.ReelPutOk();
                    SServerManager.ShelfFinish(BatchMove_B.CurrShelf.ShelfRfid, MoveInfo.MoveParam.PosInfo.barcode);
                }
                MoveInfo.NextMoveStep(StepEnum.IO32_UpdownToP1);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 升降轴到P1（待机点）{Config.Updown_P1}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO32_UpdownToP1))
            {
                MoveInfo.NextMoveStep(StepEnum.IO33_InoutToP1);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 进出轴到P1（待机点）{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO33_InoutToP1))
            {
                MoveInfo.NextMoveStep(StepEnum.IO34_MiddleToP1);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 旋转轴 到P1（待机点） {Config.Middle_P1}");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO34_MiddleToP1))
            {
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                TimeSpan span = DateTime.Now - startOutTime;
                MoveLog($"出库->料串 {MoveInfo.SLog}: 放料完成，耗时【{FormUtil.GetSpanStr(span)}】");
                InoutEndEvent();
            }

            #endregion

            #region 出库->NG箱
            else if (MoveInfo.IsStep(StepEnum.II81_MiddleToNg))
            {
                MoveInfo.NextMoveStep(StepEnum.II82_InoutToP6);
                MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 进出轴到P6（NG料区放料点）{Config.Inout_P6}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P6, Config.Inout_P6_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II82_InoutToP6))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II83_UpdownToP9);
                MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 升降轴到P9（NG料区放料低点）{Config.Updown_P9_NGL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P9_NGL, Config.Updown_P9_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II83_UpdownToP9))
            {
                MoveInfo.NextMoveStep(StepEnum.II84_ClampRelax);
                MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 夹爪放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.II84_ClampRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.II85_UpdownToP8);
                MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 升降轴到P8（NG料区放料高点）{Config.Updown_P8_NGH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8_NGH, Config.Updown_P8_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II85_UpdownToP8))
            {
                MoveInfo.NextMoveStep(StepEnum.II86_1_InoutToP1);
                MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 进出轴到P1（待机点）{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II86_1_InoutToP1))
            {
                if (shelf.Equals(1))
                {
                    MoveLog($" 出料->NG箱放料结束");
                    MoveInfo.EndMove();
                    runStatus = RunStatus.Runing;
                    InoutEndEvent();
                }
                else
                {
                    //旋转轴暂不回待机点
                    MoveInfo.NextMoveStep(StepEnum.II86_MiddleToP1);
                    MoveLog($" 出料->NG箱 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II86_MiddleToP1))
            {
                TimeSpan span = DateTime.Now - startInTime;
                MoveLog($" 出料->NG箱放料结束，耗时【{FormUtil.GetSpanStr(span)}】");
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                InoutEndEvent();
            }
            #endregion

            #region 出库->紧急箱
            else if (MoveInfo.IsStep(StepEnum.I035_MiddleToUrgentBox))
            {
                MoveInfo.NextMoveStep(StepEnum.I036_InoutToP7);
                MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 进出轴到P7（紧急料区放料点）{Config.Inout_P7}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P7, Config.Inout_P7_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.I036_InoutToP7))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.I037_UpdownToP19);
                MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 升降轴到P19（紧急料区放料低点）{Config.Updown_P19_NGL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P19_NGL, Config.Updown_P19_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.I037_UpdownToP19))
            {
                MoveInfo.NextMoveStep(StepEnum.I038_ClampRelax);
                MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 夹爪放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.I038_ClampRelax))
            {
                if (!StoreManager.XLRStore.boxEquip.SendStoreState(MoveInfo.MoveParam.PosInfo.PosId, MoveInfo.MoveParam.PosInfo.barcode, DeviceStatus.OutStoreEnd))
                    return;
                Msg.add($"出库完成：紧急料【{MoveInfo.MoveParam.PosInfo.PosId}】【{MoveInfo.MoveParam.PosInfo.barcode}】【{DeviceStatus.OutStoreEnd}】", MsgLevel.info);
                MoveInfo.NextMoveStep(StepEnum.I039_UpdownToP18);
                MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 升降轴到P18（紧急料区放料高点）{Config.Updown_P18_NGH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P18_NGH, Config.Updown_P18_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.I039_UpdownToP18))
            {
                MoveInfo.NextMoveStep(StepEnum.I040_1_InoutToP1);
                MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 进出轴到P1（待机点）{Config.Inout_P1}");
                InOutAxis.AbsMove(MoveInfo, Config.Inout_P1, Config.Inout_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.I040_1_InoutToP1))
            {
                if (shelf.Equals(1))
                {
                    MoveLog($" 出料->紧急箱放料结束");
                    MoveInfo.EndMove();
                    runStatus = RunStatus.Runing;
                }
                else
                {
                    //旋转轴暂不回待机点
                    MoveInfo.NextMoveStep(StepEnum.I041_MiddleToP1);
                    MoveLog($" 出料->紧急箱 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.I041_MiddleToP1))
            {
                TimeSpan span = DateTime.Now - startInTime;
                MoveLog($" 出料->紧急箱放料结束，耗时【{FormUtil.GetSpanStr(span)}】");
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                InoutEndEvent();
            }
            #endregion
        }
        private bool MiddleToShelf()
        {
            bool isTest = MoveInfo.MoveParam.PosInfo.barcode.EndsWith("TEST");
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                bool shelfOk = BatchMove_A.MoveInfo.MoveType.Equals(MoveType.OutStore) && BatchMove_A.MoveInfo.IsStep(StepEnum.IS13_WaitReel);
                if (isTest || shelfOk)
                {
                    ClearTimeoutAlarm("等待料串可放料");

                    MoveInfo.NextMoveStep(StepEnum.IO23_MiddleToP2);
                    MoveLog($"出库->A料串 {MoveInfo.SLog}: 清除暂存区。旋转轴到P2（A料口取料点）{Config.Middle_P2_ATake}，升降轴到P1(待机点){Config.Updown_P1}");//，等待{IO_Type.MAxis_Check_A}信号亮
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P2_ATake, Config.Middle_P2_Speed);
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                    //清空暂存区
                    int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
                    if (startp.Equals(1))
                    {
                        BufferDataManager.AOutStoreInfo = null;
                    }
                    else
                    {
                        BufferDataManager.BOutStoreInfo = null;
                    }

                    return true;
                }
            }
            else if (shelf.Equals(2))
            {
                bool shelfOk = BatchMove_B.MoveInfo.MoveType.Equals(MoveType.OutStore) && BatchMove_B.MoveInfo.IsStep(StepEnum.IS13_WaitReel);
                if (isTest || shelfOk)
                {
                    ClearTimeoutAlarm("等待料串可放料");
                    MoveInfo.NextMoveStep(StepEnum.IO27_MiddleToP3);
                    MoveLog($"出库->B料串 {MoveInfo.SLog}:清除暂存区。 旋转轴到P3（B料口取料点）{Config.Middle_P3_BTake},升降轴到P1（待机点）{Config.Updown_P1}");//，等待{IO_Type.MAxis_Check_B}信号亮
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P3_BTake, Config.Middle_P3_Speed);
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                    //清空暂存区
                    int startp = MoveInfo.MoveParam.PosInfo.GetPosType();
                    if (startp.Equals(1))
                    {
                        BufferDataManager.AOutStoreInfo = null;
                    }
                    else
                    {
                        BufferDataManager.BOutStoreInfo = null;
                    }
                    return true;
                }
            }

            return false;

        }

        private void ShelfBatchAxisDown()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            //判断料串是否完成
            if (shelf.Equals(1))
            {
                BatchMove_A.NewReelOut(MoveInfo.MoveParam.PosInfo);
            }
            else if (shelf.Equals(2))
            {
                BatchMove_B.NewReelOut(MoveInfo.MoveParam.PosInfo);
            }
            else
            {
                LogUtil.error($"{Name}{MoveInfo.SLog}出库错误：未找到准备好的料串    ");
            }
        }

        #endregion
    }
}