using Asa; 
using OnlineStore.Common;
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;

namespace OnlineStore.DeviceLibrary
{
    partial class InputEquip
    {
        public bool ClampEmptyMove = false;
        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;
        }

        #region 入库
        public override bool StartInstore(InOutParam param)
        {
            if (!NoAlarm())
            {
                LogInfo("报警中，无法开始取料入库：" + param.PosInfo.ToStr());
                return false;
            }

            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                runStatus = RunStatus.Busy;
                MoveInfo.NewMove(MoveType.InStore, param);
                //if (MiddleAxis.IsInPosition(Config.Middle_P1))
                //{
                if (UpdownAxis.IsInPosition(Config.Updown_P1))
                {
                    ToShelfMove();
                }
                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}");
                } 
                //}
                //else
                //{
                //    MoveInfo.NextMoveStep(StepEnum.II00_MiddleToP1);
                //    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                //    MoveLog($"开始入库{MoveInfo.SLog}: 料串{param.ShelfType}，旋转轴先返回P1{Config.Middle_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))
            {
                ToShelfMove();

            }
            else if (MoveInfo.IsStep(StepEnum.II02_MIddleToP2))
            {
                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 (MoveInfo.IsStep(StepEnum.II05_MIddleToP3))
            {
                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);
            }
            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))
            {
                //    MoveInfo.NextMoveStep(StepEnum.II09_MiddleToP1);
                //    MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  旋转轴到待机点P1 {Config.Middle_P1}");
                //    UpdownAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                //}else if (MoveInfo.IsStep(StepEnum.II09_MiddleToP1)) 
                //{ 
                //如果是测试，直接开始取目标位置
                if (MoveInfo.MoveParam.PosInfo.barcode.EndsWith("TEST"))
                {
                    MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  条码 {MoveInfo.MoveParam.PosInfo.barcode}为测试料，直接去目标位置");
                    LastPosInfo = MoveInfo.MoveParam.PosInfo;
                    StrartToTargetP();
                }
                else
                {
                    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.MAxis_ReelCheck_13).Equals(IO_VALUE.HIGH))
                    {
                        width = 13;
                    }
                    MoveInfo.MoveParam.PosInfo.PlateH = Height;
                    MoveInfo.MoveParam.PosInfo.PlateW = width;

                    MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  料盘尺寸{width}X{Height}");
                    II13_GetPosId();
                }
                else if (MoveInfo.IsTimeOut(60))
                {
                    MoveTimeOut(MoveInfo, "" + 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))
                {
                    MoveTimeOut(MoveInfo, "获取库位号超时 " + getPosIdMsg);
                }
            }

            #endregion

            #region 入料->A侧上暂存区
            else if (MoveInfo.IsStep(StepEnum.II40_UpdownToP4))
            {
                //如果无料且暂存区为空，直接过去
                bool empty = (BufferDataManager.AInStoreInfo == null || BufferDataManager.AInStoreInfo.PosId.Equals(""));
                if (IOValue(IO_Type.UpperArea_Check_A).Equals(IO_VALUE.LOW) && empty)
                {
                    II43_MiddleToP4();
                }
                else
                {
                    int targetV = Config.Middle_P4_AUpper - Config.MiddleOffsetValue;
                    MoveInfo.NextMoveStep(StepEnum.II41_MiddleTWaitP4);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区有料， 旋转轴 到P4{Config.Middle_P4_AUpper}-{Config.MiddleOffsetValue}=目标{targetV}位置等待暂存区无料");
                    MiddleAxis.AbsMove(MoveInfo, targetV, Config.Middle_P4_Speed);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II41_MiddleTWaitP4))
            { 
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II42_WaitNoReel);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  等待A上暂存区无料");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.UpperArea_Check_A, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StepEnum.II42_WaitNoReel))
            {
                if (BufferDataManager.AInStoreInfo == null || BufferDataManager.AInStoreInfo.PosId.Equals(""))
                {
                    ClearTimeoutAlarm("A上暂存区物料拿走");
                    MoveInfo.NextMoveStep(StepEnum.II43_MiddleToP4);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区为空， 旋转轴 到P4(A上暂存区放料点){Config.Middle_P4_AUpper}，等待{IO_Type.MAxis_Check_AreaA}信号亮");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P4_AUpper, Config.Middle_P4_Speed);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_AreaA, IO_VALUE.HIGH));
                }
                else if (MoveInfo.IsTimeOut(20))
                {
                    MoveTimeOut(MoveInfo, "A上暂存区物料拿走");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II42_WaitNoReel))
            {
                MoveInfo.NextMoveStep(StepEnum.II43_MiddleToP4);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 旋转轴 到P4(A上暂存区放料点){Config.Middle_P4_AUpper}，等待{IO_Type.MAxis_Check_AreaA}信号亮");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P4_AUpper, Config.Middle_P4_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_AreaA, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(StepEnum.II43_MiddleToP4))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II44_UpdownToP5);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}: 升降轴 到P5(A上暂存区放料低点){Config.Updown_P5_AUpperL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P5_AUpperL, Config.Updown_P5_Speed);
            }
            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))
            {
                if (!BatchMove_A.IsInScanCode())
                {
                    MoveInfo.NextMoveStep(StepEnum.II47_MiddleToP1);
                    MoveLog($" 入料->A侧 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
                else if (MoveInfo.IsTimeOut(20))
                {
                    MoveTimeOut(MoveInfo, "等待" + BatchMove_A.Name + "扫码结束");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II47_MiddleToP1))
            {
                ClearTimeoutAlarm("扫码结束");
                MoveLog($" 入料->A侧放料结束，更新A上暂存区物料{MoveInfo.MoveParam.PosInfo.ToStr()}");
                BufferDataManager.AInStoreInfo = MoveInfo.MoveParam.PosInfo;
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
            }
            #endregion

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

            else if (MoveInfo.IsStep(StepEnum.II60_UpdownToP10))
            {
                bool empty = BufferDataManager.BInStoreInfo == null || BufferDataManager.BInStoreInfo.PosId.Equals("");
                if (IOValue(IO_Type.UpperArea_Check_B).Equals(IO_VALUE.LOW) && empty)
                {
                    II63_MiddleToP5();
                }
                else
                {
                    int targetValue = Config.Middle_P5_BUpper + Config.MiddleOffsetValue;
                    MoveInfo.NextMoveStep(StepEnum.II61_MiddleToWaitP5);
                    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_MiddleToWaitP5))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II62_WaitNoReel);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}: 等待B上暂存区无料");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.UpperArea_Check_B, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StepEnum.II62_WaitNoReel))
            {
                if (BufferDataManager.BInStoreInfo == null || BufferDataManager.BInStoreInfo.PosId.Equals(""))
                {
                    ClearTimeoutAlarm("B上暂存区物料拿走");
                    II63_MiddleToP5();
                }
                else if (MoveInfo.IsTimeOut(20))
                {
                    MoveTimeOut(MoveInfo, "B上暂存区物料拿走");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II63_MiddleToP5))
            {
                TrayHasLeave();
                MoveInfo.NextMoveStep(StepEnum.II64_UpdownToP11);
                MoveLog($" 入料->B侧 {MoveInfo.SLog}: 升降轴 到P11 (B上暂存区放料低点){Config.Updown_P11_BUpperL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P11_BUpperL, Config.Updown_P11_Speed);
            }
            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))
            {
                //需要等A侧料串不扫码时再过去
                if (!BatchMove_B.IsInScanCode())
                {
                    MoveInfo.NextMoveStep(StepEnum.II67_MiddleToP1);
                    MoveLog($" 入料->B侧 {MoveInfo.SLog}: 旋转轴 到P1(待机点){Config.Middle_P1}");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
                }
                else if (MoveInfo.IsTimeOut(20))
                {
                    MoveTimeOut(MoveInfo, "等待" + BatchMove_B.Name + "扫码结束");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.II67_MiddleToP1))
            {
                ClearTimeoutAlarm("扫码结束");
                MoveLog($" 入料->B侧放料结束，更新B上暂存区物料{MoveInfo.MoveParam.PosInfo.ToStr()}");
                BufferDataManager.BInStoreInfo = MoveInfo.MoveParam.PosInfo;
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
            }
            #endregion

            #region 入料->NG箱上暂存区
            else if (MoveInfo.IsStep(StepEnum.II81_UpdownToP8))
            {
                MoveInfo.NextMoveStep(StepEnum.II82_MiddleToNg);
                MoveLog($" 入料->NG箱 {MoveInfo.SLog}: 旋转轴到P6（NG料区放料点）{Config.Middle_P6_NG}");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P6_NG, Config.Middle_P6_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.II82_MiddleToNg))
            {
                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))
            {
                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))
            {
                MoveLog($" 入料->NG箱放料结束");
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
            }
            #endregion

        }

        private void II63_MiddleToP5()
        {
            MoveInfo.NextMoveStep(StepEnum.II63_MiddleToP5);
            MoveInfo.TimeOutSeconds = 10;
            MoveLog($" 入料->B侧 {MoveInfo.SLog}: 暂存区无料，旋转轴 到P5 (B上暂存区放料点){Config.Middle_P5_BUpper}，等待{MiddleAxis.AxisName}原点信号亮");
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P5_BUpper, Config.Middle_P5_Speed);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitAxisOrg(MiddleAxis.Config, IO_VALUE.HIGH));
        }

        private void II43_MiddleToP4()
        {
            MoveInfo.NextMoveStep(StepEnum.II43_MiddleToP4);
            MoveInfo.TimeOutSeconds = 10;
            MoveLog($" 入料->A侧 {MoveInfo.SLog}: 暂存区为空， 旋转轴 到P4(A上暂存区放料点){Config.Middle_P4_AUpper}，等待{IO_Type.MAxis_Check_AreaA}信号亮");
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P4_AUpper, Config.Middle_P4_Speed);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_AreaA, IO_VALUE.HIGH));
        }
        private void ToShelfMove()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                MoveInfo.NextMoveStep(StepEnum.II02_MIddleToP2);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  旋转轴到P2（A料口取料点）{Config.Middle_P2_ATake}，等待{IO_Type.MAxis_Check_A}信号亮");
                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}:  旋转轴到P3（B料口取料点）{Config.Middle_P3_BTake}，等待{IO_Type.MAxis_Check_B}信号亮");
                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_UpdownToP8);
                MoveLog($"入库取料{shelf}{MoveInfo.SLog}:  NG料{lastPosInfo.ToStr()} 升降轴到P8（NG料区放料高点）{Config.Updown_P8_NGH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8_NGH, Config.Updown_P8_Speed);
            }
            else if (lastPosInfo.GetPosSide().Equals("A"))
            {
                MoveInfo.NextMoveStep(StepEnum.II40_UpdownToP4);
                MoveLog($" 入料->A侧 {MoveInfo.SLog}:  A侧入库料{lastPosInfo.ToStr()}, 升降轴 到P4(A上暂存区放料高点){Config.Updown_P4_AUpperH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P4_AUpperH, Config.Updown_P4_Speed);

            }
            else
            {
                MoveInfo.NextMoveStep(StepEnum.II60_UpdownToP10);
                MoveLog($" 入料->B侧 {MoveInfo.SLog}:  B侧入库料{lastPosInfo.ToStr()} ，升降轴 到P10（B上暂存区放料高点){Config.Updown_P10_BUpperH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P10_BUpperH, Config.Updown_P10_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，从服务器获取入库库位");
            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;

                        //从服务器获取库位号
                        GetPosResult result = SServerManager.GetPosId(Name, codeList, pos.PlateH, pos.PlateW, pos.rfid, DeviceID);
                        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);
        }
        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 出库
        public override bool StartOutstore(InOutParam param)
        {
            if (!NoAlarm())
            {
                LogInfo("报警中，无法开始出库：" + param.PosInfo.ToStr());
                return false;
            }

            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                //获取位置是左侧还是右侧。
                int startp = param.PosInfo.GetPosType();
                if (startp.Equals(1))
                {
                    runStatus = RunStatus.Busy;
                    MoveInfo.NewMove(MoveType.OutStore, param);
                    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.UnderArea_Check_A, IO_VALUE.HIGH));
                }
                else if (startp.Equals(2))
                {
                    runStatus = RunStatus.Busy;
                    MoveInfo.NewMove(MoveType.OutStore, param);
                    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.UnderArea_Check_B, IO_VALUE.HIGH)); 
                }
                else
                {
                    LogInfo("出库失败，未找到库位位置：" + param.PosInfo.ToStr());
                    return false;
                }

                return true;
            }
            return false;
        }

        private void TrayHasLeave()
        {
            int shelf = MoveInfo.MoveParam.ShelfType;
            if (shelf.Equals(1))
            {
                BatchMove_A.GetTrayLeave();
            }
            else if (shelf.Equals(2))
            {
                BatchMove_B.GetTrayLeave();
            }
        }
        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))
            {
                MoveInfo.NextMoveStep(StepEnum.IO02_UpdownToP6);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P6（A下暂存区取料高点）{Config.Updown_P6_AUnderH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P6_AUnderH, Config.Updown_P6_Speed);

                ShelfBatchAxisDown();
            }
            else if (MoveInfo.IsStep(StepEnum.IO02_UpdownToP6))
            {
                MoveInfo.NextMoveStep(StepEnum.IO03_MiddleToP7);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 旋转轴到P7（A下暂存区取料点）{Config.Middle_P7_AUnder}，等待{IO_Type.MAxis_Check_AreaA}信号亮");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P7_AUnder, Config.Middle_P7_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_AreaA, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(StepEnum.IO03_MiddleToP7))
            {
                MoveInfo.NextMoveStep(StepEnum.IO04_UpdownToP7);
                MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 升降轴到P7（A下暂存区取料低点）{Config.Updown_P7_AUnderL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P7_AUnderL, Config.Updown_P7_Speed);
            }
            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 (!MiddleToShelf())
                {
                    MoveInfo.NextMoveStep(StepEnum.IO21_WaitShelfReady);
                    MoveLog($"出库A->{shelf}料串 {MoveInfo.SLog}: 等待料串可放料");
                }

            }
            #endregion

            #region 出库B侧取料
            else if (MoveInfo.IsStep(StepEnum.IO11_ReelCheck))
            {
                MoveInfo.NextMoveStep(StepEnum.IO12_UpdownToP12);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P12（B下暂存区取料高点）{Config.Updown_P12_BUnderH}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P12_BUnderH, Config.Updown_P12_Speed);

                ShelfBatchAxisDown();
            }
            else if (MoveInfo.IsStep(StepEnum.IO12_UpdownToP12))
            {
                MoveInfo.NextMoveStep(StepEnum.IO13_MiddleToP8);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 旋转轴到P8（B下暂存区取料点）{Config.Middle_P8_BUnder}，等待{MiddleAxis.AxisName}原点信号亮");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P8_BUnder, Config.Middle_P8_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitAxisOrg(MiddleAxis.Config, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(StepEnum.IO13_MiddleToP8))
            {
                MoveInfo.NextMoveStep(StepEnum.IO14_UpdownToP13);
                MoveLog($"出库B->{shelf}料串 {MoveInfo.SLog}: 升降轴到P13（B下暂存区取料低点）{Config.Updown_P13_BUnderL}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P13_BUnderL, Config.Updown_P13_Speed);
            }
            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 (!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(60))
                {
                    MoveTimeOut(MoveInfo, "等待料串可放料");
                }
            }else if (MoveInfo.IsStep(StepEnum.IO23_MiddleToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IO24_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_UpdownToP3);
                MoveLog($"出库->A料串 {MoveInfo.SLog}: 升降轴到P3（B料口取料点）{Config.Updown_P3_BTake}");
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P3_BTake, Config.Updown_P3_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO24_UpdownToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IO31_ClampRelax);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 电卡爪放松   判断到位");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO28_UpdownToP3))
            {
                MoveInfo.NextMoveStep(StepEnum.IO31_ClampRelax);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 电卡爪放松   判断到位");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IO31_ClampRelax))
            {
                if (shelf.Equals(1))
                {
                    BatchMove_A.ReelPutOk();
                }
                else
                {
                    BatchMove_B.ReelPutOk();
                }
                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_MiddleToP1);
                MoveLog($"出库->料串 {MoveInfo.SLog}: 旋转轴 到P1（待机点） {Config.Middle_P1}");
                MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IO33_MiddleToP1))
            {
                MoveInfo.EndMove();
                runStatus = RunStatus.Runing;
                MoveLog($"出库->料串 {MoveInfo.SLog}: 放料完成");
            }

            #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}，等待{IO_Type.MAxis_Check_A}信号亮");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P2_ATake, Config.Middle_P2_Speed);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_A, IO_VALUE.HIGH));
                    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}，等待{IO_Type.MAxis_Check_B}信号亮");
                    MiddleAxis.AbsMove(MoveInfo, Config.Middle_P3_BTake, Config.Middle_P3_Speed);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.MAxis_Check_B, IO_VALUE.HIGH));
                    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
    } 
}