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.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    partial class FeedingEquip
    {        
        protected override bool CheckWaitResult(LineMoveInfo moveInfo, WaitResultInfo wait)
        {
            if (wait.WaitType.Equals(WaitEnum.W101_BatchAxisMove))
            {
                //等待信号亮或者走到绝对位置才停止
                if (IOValue(TargetIoType).Equals(TargetIoValue))
                {
                    LogUtil.debug(Name + "CheckWaitResult 检测到" + TargetIoType + "=" + TargetIoValue + ",停止运行");
                    BatchAxisStopCheck();
                    if (ACServerManager.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(1))
                    {
                        BatchAxis.SuddenStop();
                    }
                    return true;
                }
                else
                {
                    bool isOk = ACServerManager.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(0);
                    if (isOk)
                    {
                        //TODO 判断是否达到高度，如果未达到，继续上升
                        BatchAxisStopCheck();
                        return true;
                    }
                }
            }
            else if (wait.WaitType.Equals(WaitEnum.W102_FeedScanCode))
            {
                if (LastCodeList.Count > 0)
                {
                    return true;
                }
            }
            return false;
        }
        public override void CheckAlarmProcess(LineMoveInfo moveInfo, LineAlarmType alarmType)
        {
            if (moveInfo.MoveStep.Equals(LineMoveStep.FI_18_WaitNoLocationCheck) && alarmType.Equals(LineAlarmType.IoSingleTimeOut))
            {
                string code = CodeManager.ProcessCode(NextCodeList);
                if (!String.IsNullOrEmpty(code))
                {
                    LogUtil.error(moveInfo.Name + " [" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "]等待 SL_AxisLocationCheck=LOW 超时，清空缓存预条码：" + code);
                    NextCodeList = new List<string>();
                }
            }
        }
        public event TrayProcessEnd TrayPEndEvent;
        #region 托盘检测
        private InOutParam CheckParam = new InOutParam();


        internal DateTime lastStopDown = DateTime.Now;
        private Stopwatch swWaitWatch = new Stopwatch();

        private object lockObj = "";
        private void StartCheckFixture()
        {
            if (Monitor.TryEnter(lockObj, TrayManager.mTimeOut))
            {
                try
                {
                    if (SecondMoveInfo.MoveType.Equals(LineMoveType.None).Equals(false))
                    {
                        LogUtil.error(Name + "  StartCheckFixture " + " 不在空闲中，直接返回 ");
                        return;
                    }
                    if (!LineManager.Line.CanProcessLine())
                    {
                        swWaitWatch.Stop();
                        return;
                    }

                    if (Config.SidesWayNum > 0)
                    {
                        if (IOValue(IO_Type.SW_TrayCheck).Equals(IO_VALUE.HIGH))
                        {
                            bool canProcess = (LineManager.Line.SwNoProcess(Config.SidesWayNum));
                            if (TrayManager.checkWatch(swWaitWatch, TrayManager.SwTrayWaitTime, false) && canProcess)
                            {
                                swWaitWatch.Stop();
                                UpdateTrayNum();
                                //判断是否是需要的托盘
                                if (CurrTrayIsNeed(currTrayNum, true))
                                {
                                    SecondMoveInfo.NewMove(LineMoveType.CheckFixture, CheckParam);
                                    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_06_TopUp);
                                    IOMove(IO_Type.SW_StopDown, IO_VALUE.LOW);
                                    LogUtil.info(Name + " [" + trayCount + "] 检测到SW_TrayCheck：" + SecondMoveInfo.SLog + "横移顶升气缸上升 ）");
                                    CylinderMove(SecondMoveInfo, IO_Type.SW_TopCylinder_Down, IO_Type.SW_TopCylinder_Up);
                                }
                                else
                                {
                                    SMoveEnd();
                                }
                            }
                        }
                        else if (Config.SidesWayNum.Equals(2) && IOValue(IO_Type.SW_StopCheck).Equals(IO_VALUE.HIGH)
                             && (DateTime.Now - lastStopDown).TotalSeconds > 3)
                        {
                            bool canProcess = (LineManager.Line.SwNoProcess(Config.SidesWayNum));
                            if (TrayManager.checkWatch(swWaitWatch, TrayManager.SwTrayWaitTime, false) && canProcess)
                            {
                                swWaitWatch.Stop();
                                lastStopDown = DateTime.Now;
                                SecondMoveInfo.NewMove(LineMoveType.CheckFixture, CheckParam);
                                SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_00_Stop1Down); 
                                LogUtil.debug(Name + " [" + trayCount + "] 检测到SW_StopCheck：" + SecondMoveInfo.SLog + "阻挡气缸下降 ，等待 SW_StopCheck=0，清理托盘RFID");
                                ClearTrayRFID(); 
                                IOMove(IO_Type.SW_StopDown, IO_VALUE.HIGH, 1200);
                                SecondMoveInfo.OneWaitCanEndStep = true; 
                                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_StopCheck, IO_VALUE.LOW));
                                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_TrayCheck, IO_VALUE.HIGH));  
                            }
                        }
                        else
                        {
                            swWaitWatch.Stop();
                        }
                    }
                    else
                    {
                        //托盘在两个阻挡内
                        if (IOValue(IO_Type.FL_TrayCheck).Equals(IO_VALUE.HIGH))
                        {
                            if (TrayManager.checkWatch(swWaitWatch, TrayManager.SwTrayWaitTime, true))
                            {
                                SecondMoveInfo.NewMove(LineMoveType.CheckFixture);
                                CheckLog("检测到FL_TrayCheck：" + SecondMoveInfo.SLog + " FL阻挡1上升）");
                                SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_03_Stop2Down);
                                IOMove(IO_Type.FL_StopCylinder_Down1, IO_VALUE.LOW);
                                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_StopCylinder_Down1, IO_VALUE.LOW));
                            }
                        }
                        else if (IOValue(IO_Type.FL_StopCheck).Equals(IO_VALUE.HIGH))
                        {
                            if (TrayManager.checkWatch(swWaitWatch, TrayManager.SwTrayWaitTime, true))
                            {
                                //托盘在第一个阻挡处
                                SecondMoveInfo.NewMove(LineMoveType.CheckFixture);
                                SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_00_Stop1Down);
                                CheckLog(" 检测到FL_StopCheck：" + SecondMoveInfo.SLog + "  FL阻挡1下降 ，等待 FL_StopCheck=0");
                                IOMove(IO_Type.FL_StopCylinder_Down1, IO_VALUE.HIGH, 1200);
                                SecondMoveInfo.OneWaitCanEndStep = true;
                                //SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_StopCylinder_Down1, IO_VALUE.HIGH));
                                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_StopCheck, IO_VALUE.LOW));
                                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_TrayCheck, IO_VALUE.HIGH));
                                ///  SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(TrayManager.StopDownWaitTime));
                            }
                        }
                        else
                        {
                            swWaitWatch.Stop();
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "  StartCheckFixture " + " 出错：" + ex.ToString());
                }
                finally
                {
                    Monitor.Exit(lockObj);
                }
            }
            else
            {
                LogUtil.error(Name + "  StartCheckFixture " + "失败，未得到锁");
            }
        }

        protected override void CheckFixtureProcess()
        {
            if (!LineManager.Line.LineCanRun())
            {
                return;
            }
            if (SecondMoveInfo.IsInWait)
            {
                CheckWait(SecondMoveInfo);
            }
            if (SecondMoveInfo.IsInWait)
            {
                return;
            }

            #region 托盘检测
            if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_00_Stop1Down))
            {
                if (Config.SidesWayNum <= 0)
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_03_Stop2Down);
                    CheckLog("托盘检测：" + SecondMoveInfo.SLog + "阻挡1上升，等待FL_TrayCheck=1 ");
                    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_TrayCheck, IO_VALUE.HIGH));
                }
                else
                {
                    TimeSpan span = DateTime.Now - SecondMoveInfo.LastSetpTime;
                    //去掉延迟
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_03_Stop2Down);
                    LogUtil.debug(Name + "托盘阻挡：" + SecondMoveInfo.SLog + "阻挡气缸上升，下降耗时（" + FormUtil.GetSpanStr(span) + "），等待SW_TrayCheck=1）");
                    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_TrayCheck, IO_VALUE.HIGH));
                }
            }
            //else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_01_FixtureCheck))
            //{
            //    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_02_WaitFixture);
            //    CheckLog("托盘检测：" + SecondMoveInfo.SLog + "再次等待SW_TrayCheck=1 ："); 
            //    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_TrayCheck, IO_VALUE.HIGH));  
            //}
            //else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_02_WaitFixture))
            //{
            //    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_03_Stop2Down);
            //    CheckLog("托盘检测：" + SecondMoveInfo.SLog + "阻挡气缸上升，等待SW_TrayCheck=1）");
            //    CheckAndMove(IO_Type.SW_StopDown, IO_VALUE.LOW);
            //    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_TrayCheck, IO_VALUE.HIGH));
            //}
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_03_Stop2Down))
            {
                UpdateTrayNum();
                //出料中，需要拦盘
                if (CurrTrayIsNeed(currTrayNum, true))
                {
                    SecondMoveInfo.MoveParam = CheckParam;
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_06_TopUp);
                    if (Config.SidesWayNum <= 0)
                    {
                        CheckLog("托盘检测： " + SecondMoveInfo.SLog + " 顶升气缸上 升 ）");
                        CylinderMove(SecondMoveInfo, IO_Type.FL_TopCylinder_Down, IO_Type.FL_TopCylinder_Up);
                    }
                    else
                    {
                        CylinderMove(SecondMoveInfo, IO_Type.SW_TopCylinder_Down, IO_Type.SW_TopCylinder_Up);

                        if (Config.SidesWayNum.Equals(2) && LineManager.Line.SwCanUpMove(3))
                        {
                            CheckLog("托盘检测：" + SecondMoveInfo.SLog + " 需要此托盘，横移顶升气缸上升，同时横移3处的顶升也可以上升  ");
                            LineManager.Line.CylinderMove(null, IO_Type.SW3_TopCylinder_Down, IO_Type.SW3_TopCylinder_Up);
                        }
                        else
                        {
                            CheckLog("托盘检测：" + SecondMoveInfo.SLog + " 需要此托盘，横移顶升气缸上 升  ");
                        }
                    }
                }
                else
                {
                    if (Config.SidesWayNum <= 0)
                    {
                        SecondMoveInfo.NextMoveStep(LineMoveStep.MO_15_WaitCanGo);
                        TrayInfo tray = TrayManager.GetTrayInfo(currTrayNum);
                        CheckLog(SecondMoveInfo.MoveNum + "***************上个托盘号【" + preTrayNum + "】，当前 【" + tray.ToStr() + "】没有出入料任务，放盘通过~");
                        //CheckLog("托盘放行  " + SecondMoveInfo.SLog + " ，移栽2，需要判断是否可以放盘通过,最多等待10000）");
                        CheckLog("托盘放行  " + SecondMoveInfo.SLog + " ，等待 NextStopCheck=0");
                        //   SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.NextStopCheck, IO_VALUE.LOW));
                    }
                    else
                    {
                        CheckLog("托盘检测：不需要此托盘，写一下顶升上升，结束处理");
                        if (Config.SidesWayNum.Equals(2))
                        {
                            CylinderMove(null, IO_Type.SW_TopCylinder_Down, IO_Type.SW_TopCylinder_Up);
                            if (LineManager.Line.SwCanUpMove(3))
                            {
                                LineManager.Line.CylinderMove(null, IO_Type.SW3_TopCylinder_Down, IO_Type.SW3_TopCylinder_Up);
                            }
                        }
                        SMoveEnd();
                    }
                }
            }

            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_06_TopUp))
            {
                //    SecondMoveInfo.NextMoveStep(LineMoveStep.MIO_07_LocationUp);
                //    CheckLog("托盘检测： " + SecondMoveInfo.SLog + " , 定位气缸上升 ）");
                //    if (Config.SidesWayNum > 0)
                //    {
                //        CylinderMove(SecondMoveInfo, IO_Type.SW_LocationCylinder_Down, IO_Type.SW_LocationCylinder_Up);
                //    }
                //}
                //else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MIO_07_LocationUp))
                //{
                CheckLog("托盘阻挡*************** 托盘号【" + currTrayNum + "】");

                //判断盘是空盘,空盘并且编号正确才需要放料盘过去
                if (MoveInfo.MoveType.Equals(LineMoveType.InStore))
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_11_CodeRember);
                    LogInfo(SecondMoveInfo.MoveNum + SecondMoveInfo.SLog + "*************** 托盘号【" + currTrayNum + "】 ，需要入料，移栽料盘");
                    SecondMoveInfo.EndStepWait();
                    if (Config.SidesWayNum > 0)
                    {
                        //  CylinderMove(null, IO_Type.SW_LocationCylinder_Down, IO_Type.SW_LocationCylinder_Up);
                    }
                }
                else
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_200_WaitInoutParam);
                    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
                    //  SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitFeedNoMove());
                    LogInfo(SecondMoveInfo.MoveNum + SecondMoveInfo.SLog + "  ，托盘号【" + currTrayNum + "】需要出库，等待开始出库");
                    if (Config.SidesWayNum > 0)
                    {
                        //CylinderMove(null, IO_Type.SW_LocationCylinder_Down, IO_Type.SW_LocationCylinder_Up);
                    }
                }

            }

            #endregion

            #region 不需要托盘或移栽入库料盘完成
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_12_MoveOk))
            {
                if (Config.SidesWayNum > 0)
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_13_LoactionDown);
                    SInLog("托盘放行，  " + SecondMoveInfo.SLog + "  托盘开始放行，环形线定位气缸下降");
                    CylinderMove(SecondMoveInfo, IO_Type.SW_LocationCylinder_Up, IO_Type.SW_LocationCylinder_Down);
                }
                else
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_14_TopDown);
                    CheckLog("托盘放行，  " + SecondMoveInfo.SLog + " ， 顶升气缸下降）");
                    CylinderMove(SecondMoveInfo, IO_Type.FL_TopCylinder_Up, IO_Type.FL_TopCylinder_Down);
                }
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_13_LoactionDown))
            {
                if (Config.SidesWayNum.Equals(2))
                {
                    //preTrayNum = currTrayNum;
                    CheckLog("托盘放行： 此处为环形线横移2，顶升气缸不需要下降， (托盘放行结束） ");

                    SMoveEnd();
                }
                else
                {
                    if (CylinderIsOk(IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down))
                    {
                        MO_15_WaitCanGo();
                    }
                    else
                    {
                        SecondMoveInfo.NextMoveStep(LineMoveStep.MO_14_TopDown);
                        CheckLog("托盘放行，  " + SecondMoveInfo.SLog + " ，环形线顶升气缸下降）");
                        CylinderMove(SecondMoveInfo, IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down);
                    }
                }
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_14_TopDown))
            {
                MO_15_WaitCanGo();
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_15_WaitCanGo))
            {
                if (Config.SidesWayNum > 0)
                {
                    if (Config.SidesWayNum.Equals(3) || Config.SidesWayNum.Equals(1))
                    {
                        CylinderMove(null, IO_Type.SW_TopCylinder_Down, IO_Type.SW_TopCylinder_Up);
                    }
                    CheckLog("托盘放行  SecondStoreMove：(托盘放行结束）横移顶升先上升 ");
                    SMoveEnd();
                }
                else
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_16_Stop2Down);
                    CheckLog("托盘放行   " + SecondMoveInfo.SLog + " ，阻挡气缸1-2下降，等待");
                    IOMove(IO_Type.FL_StopCylinder_Down2, IO_VALUE.HIGH);
                    SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_StopCylinder_Down2, IO_VALUE.HIGH));
                    // SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(TrayManager.StopDownWaitTime));
                }
                //  SecondMoveInfo.EndStepWait();
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_16_Stop2Down))
            {
                SecondMoveInfo.NextMoveStep(LineMoveStep.MO_17_Stop2Check);
                CheckLog("托盘放行   " + SecondMoveInfo.SLog + " ，等待FL_TrayCheck=0");
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_TrayCheck, IO_VALUE.LOW));

            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_17_Stop2Check))
            {
                SecondMoveInfo.NextMoveStep(LineMoveStep.MO_18_WaitTime);
                CheckLog("托盘放行  " + SecondMoveInfo.SLog + " ， 等待500ms后阻挡2上升");
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_18_WaitTime))
            {
                SecondMoveInfo.NextMoveStep(LineMoveStep.MO_19_StopCylinder_Back);
                CheckLog("托盘放行   " + SecondMoveInfo.SLog + " ，等待托盘离开 ）");
                IOMove(IO_Type.FL_StopCylinder_Down2, IO_VALUE.LOW);
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.FL_StopCylinder_Down2, IO_VALUE.LOW));
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(200));
            }
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_19_StopCylinder_Back))
            {
                //preTrayNum = currTrayNum;
                CheckLog("托盘放行  SecondStoreMove：(托盘放行结束） ");
                SMoveEnd();
            }
            #endregion
            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_11_CodeRember))
            {
                if (MoveInfo.MoveStep < LineMoveStep.FI_25_WaitTray)
                { 
                    if (SecondMoveInfo.IsTimeOut(15))
                    {
                        WarnMsg = SecondMoveInfo.Name + "[" + SecondMoveInfo.MoveStep + "] 等待入库托盘超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                        LogUtil.error(WarnMsg + "，暂时放托盘离开");
                        TrayMoveOk();
                    }
                }
            }

            else if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_200_WaitInoutParam))
            {
                if (StartTrayOut(SecondMoveInfo.MoveParam))
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_201_WaitOutEnd);
                }

                //如果当前无料串，或者料串已离开，直接放行 托盘

                else if (SecondMoveInfo.IsTimeOut(30))
                {
                    WarnMsg = SecondMoveInfo.Name + "[" + SecondMoveInfo.MoveStep + "] 等待出库移栽超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg + "，暂时放托盘离开");
                    TrayMoveOk();
                }
                else if (SecondMoveInfo.IsTimeOut(20))
                {
                    WarnMsg = SecondMoveInfo.Name + "[" + SecondMoveInfo.MoveStep + "] 等待出库移栽超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, DeviceID * 1000 + 21);
                    Alarm(LineAlarmType.IoSingleTimeOut);
                }
            }
        }
        private void TrayMoveOk(bool needCheck = false)
        {
            if (needCheck && (!SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_11_CodeRember)))
            {
                return;
            }
            SecondMoveInfo.NextMoveStep(LineMoveStep.MO_12_MoveOk);
            InLog("料盘移栽" + MoveInfo.SLog + "，"+SecondMoveInfo.SLog+"：托盘开始放行");
            if (Config.SidesWayNum > 0)
            {
                if (CylinderIsOk(IO_Type.SW_LocationCylinder_Up, IO_Type.SW_LocationCylinder_Down))
                {
                    if (Config.SidesWayNum.Equals(2))
                    {
                        //preTrayNum = currTrayNum;
                        CheckLog("托盘放行： 此处为环形线横移2，顶升气缸不需要下降， (托盘放行结束） ");
                        SMoveEnd();
                    }
                    else
                    {
                        if (CylinderIsOk(IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down))
                        {
                            MO_15_WaitCanGo();
                        }
                        else
                        {
                            SecondMoveInfo.NextMoveStep(LineMoveStep.MO_14_TopDown);
                            CheckLog("托盘放行，  " + SecondMoveInfo.SLog + " ，环形线顶升气缸下降）");
                            CylinderMove(SecondMoveInfo, IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down);
                        }
                    }
                }
                else
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_13_LoactionDown);
                    SInLog("托盘放行，  " + SecondMoveInfo.SLog + "  托盘开始放行，环形线定位气缸下降，判断顶升是否需要同时下降");
                    CylinderMove(SecondMoveInfo, IO_Type.SW_LocationCylinder_Up, IO_Type.SW_LocationCylinder_Down);

                    if (!Config.SidesWayNum.Equals(2))
                    {
                        CylinderMove(SecondMoveInfo, IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down);
                    }
                }
            }
            else
            {
                if (CylinderIsOk(IO_Type.FL_TopCylinder_Up, IO_Type.FL_TopCylinder_Down))
                {
                    MO_15_WaitCanGo();
                }
                else
                {
                    SecondMoveInfo.NextMoveStep(LineMoveStep.MO_14_TopDown);
                    CheckLog("托盘放行，  " + SecondMoveInfo.SLog + " ， 顶升气缸下降）");
                    CylinderMove(SecondMoveInfo, IO_Type.FL_TopCylinder_Up, IO_Type.FL_TopCylinder_Down);
                }
            }
        }

        private void MO_15_WaitCanGo()
        {
            SecondMoveInfo.NextMoveStep(LineMoveStep.MO_15_WaitCanGo);
            if (Config.SidesWayNum > 0)
            {
                CheckLog("托盘放行   " + SecondMoveInfo.SLog + " ，等待托盘离开");
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SW_TrayCheck, IO_VALUE.LOW));
            }
            else
            {
                CheckLog("托盘放行  " + SecondMoveInfo.SLog + " ，等待 NextStopCheck=0");
                //   SecondMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.NextStopCheck, IO_VALUE.LOW));
            }
        }
        private void SMoveEnd()
        {
            lastStopDown = DateTime.Now.AddSeconds(-1);
            SecondMoveInfo.EndMove();
            this.TrayPEndEvent?.Invoke(Config.SidesWayNum, currTrayNum);
        }
        #endregion

        #region 入料流程


        private bool StartInStoreP()
        {
            //若定位工位，阻挡工位，有 料架，需要进行处理
            if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.SL_Stop_Check).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.HIGH))
            { 
                //升降盘需要在后退端
                if (IsTrayLCylinderAfter())
                { 
                    StartInStoreMove(null);
                }
            }
            else if (IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.HIGH))
            {
                //小车到达，开始处理 
                if (runStatus >= (LineRunStatus.Runing) &&
                    MoveInfo.MoveType.Equals(LineMoveType.None) &&
                    ProcessShelfEnter.Equals(false) &&
                    IOValue(IO_Type.SL_Stop_Check).Equals(IO_VALUE.LOW))
                {
                    ShelfEnterProcess();
                }
            }

            return false;
        }
        public override bool StartInStoreMove(InOutParam param)
        {
            runStatus = LineRunStatus.Busy;
            lineStatus = LineStatus.InStoreExecute;
            MoveInfo.NewMove(LineMoveType.InStore);
            MoveInfo.MoveParam = new InOutParam();
            //判断是哪个工位有料架
            if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
            {
                FI_04_WaitTime();
            }
            else
            {
                if (IsTrayLCylinderAfter())
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_01_TrayLocation_After);
                    InLog("检测到料架， " + MoveInfo.MoveStep + "  ：升降盘定位气缸下降");
                    TrayLCylinderAfter(MoveInfo);
                }else
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_00_BatchAxisToP2);
                    OutLog("检测到料架，升降盘不在后退端 " + MoveInfo.SLog + "  ：提升伺服先回到P2");
                    BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP2, Config.BatchAxis_P2Speed);
                }
            }
            return true;
        }

        private void FI_04_WaitTime()
        {
            //定位工位有料架，等待1秒后再次检测
            MoveInfo.NextMoveStep(LineMoveStep.FI_04_WaitTime);
            InLog("定位工位检测到料架： " + MoveInfo.SLog + "，进料阻挡上升，缓冲阻挡上升， 等待3秒再次检测");
            IOMove(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW);
            IOMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW);
            IOMove(IO_Type.SL_Line_Run, IO_VALUE.HIGH);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
        }

        private void LineInStoreProcess()
        {
         
            //判断是哪个工位有料架
            if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
            {
                FI_04_WaitTime();
            }
            //阻挡工位有料架，流水线转动一个工位
            else if (IOValue(IO_Type.SL_Stop_Check).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_03_LineStart);
                InLog("入料检测： " + MoveInfo.SLog + "   阻挡工位有新料架，清理缓存料架RFID ，进料阻挡下降500，缓冲阻挡前进1000，流水线转动 1000");
                UpdateLastShelfID();
                IOMove(IO_Type.SL_Entry_StopDown, IO_VALUE.HIGH, 500);//进料阻挡下降
                IOMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.HIGH, 1000);//缓冲阻挡前进1000
                //  IOMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW);//缓冲阻挡下降
                IOMove(IO_Type.SL_Line_Run, IO_VALUE.HIGH);
                //等待指定时间
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Location_Check, IO_VALUE.HIGH));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Line_Run, IO_VALUE.HIGH));
            } else if (IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_03_LineStart);
                InLog("入料检测： " + MoveInfo.SLog + "   进料口有新料架，进料阻挡上升，缓冲阻挡前进1000，流水线转动 1000");
                IOMove(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW);//进料阻挡上升
                IOMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.HIGH, 1000);//缓冲阻挡前进1000
                IOMove(IO_Type.SL_Line_Run, IO_VALUE.HIGH);
                //等待指定时间
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Stop_Check, IO_VALUE.HIGH));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Line_Run, IO_VALUE.HIGH));
            }
            else
            {
                if (!ProcessShelfEnter)
                {
                    IOMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
                }
                MoveEndS();
                LogUtil.info(" 未检测到料架，入料结束");
            }
        }

        protected override void InStoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            #region 入料：料架进入并开始检测托盘
            if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_00_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_01_TrayLocation_After);
                InLog("料架入库" + MoveInfo.SLog + " ：升降盘定位气缸下降");
                TrayLCylinderAfter(MoveInfo);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_01_TrayLocation_After))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_02_LocationCylinder_Down);
                InLog("料架入库" + MoveInfo.SLog + "：定位气缸下降，提升伺服移动到P1");
                CylinderMove(MoveInfo, IO_Type.SL_LocationCylinder_Up, IO_Type.SL_LocationCylinder_Down);
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Config.BatchAxis_P1Speed);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_02_LocationCylinder_Down))
            {
                LineInStoreProcess();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_03_LineStart))
            {
                LineInStoreProcess();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_04_WaitTime))
            {
                if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
                {
                    ReadShelfId();

                    if (CurrShelfId.EndsWith("00"))
                    {
                        MoveInfo.NextMoveStep(LineMoveStep.FI_53_BatchAxisToP1);
                        InLog("料架号【" + CurrShelfId + "】无效，送出料架，" + MoveInfo.SLog + "：提升伺服到P1点，定位气缸下降");
                        BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Config.BatchAxis_P1Speed);
                        CylinderMove(MoveInfo, IO_Type.SL_LocationCylinder_Up, IO_Type.SL_LocationCylinder_Down);
                    }
                    else
                    {
                        MoveInfo.ShelfNoTray = false;
                        //定位工位有料架，直接开始入料
                        MoveInfo.NextMoveStep(LineMoveStep.FI_05_LocationCylinder_Up);
                        InLog("定位工位检测到料架： " + MoveInfo.SLog + " 缓冲阻挡上升， 定位气缸上升，读取并缓存料架RFID" + CurrShelfId);
                        UpdateLastShelfID(CurrShelfId);
                        CylinderMove(MoveInfo, IO_Type.SL_LocationCylinder_Down, IO_Type.SL_LocationCylinder_Up);
                    }
                }
                else
                {
                    MoveEndS();
                    InLog(" 未检测到料架，入料结束");
                }
            }

            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_05_LocationCylinder_Up))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_06_BatchAxisToP2);
                InLog("料架入库" + MoveInfo.SLog + "：提升轴下降到位P2，定位气缸上升");
                if (!ProcessShelfEnter)
                {
                    IOMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
                }
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP2, Config.BatchAxis_P2Speed);
                CylinderMove(MoveInfo, IO_Type.SL_LocationCylinder_Down, IO_Type.SL_LocationCylinder_Up);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_06_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_07_TrayLocation_Before);
                InLog("料架入库" + MoveInfo.SLog + "：升降盘定位气缸第一次前进 2秒，清空条码信息");
                LastCodeList = new List<string>();
                NextCodeList = new List<string>();
                TrayLCylinderBefore(null);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_07_TrayLocation_Before))
            {

                MoveInfo.NextMoveStep(LineMoveStep.FI_08_TrayLocation_Back);
                InLog("料架入库" + MoveInfo.SLog + "：升降盘定位气缸后退，等待再次前进");
                TrayLCylinderAfter(MoveInfo);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_08_TrayLocation_Back))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_09_TrayLocation_Before);
                InLog("料架入库" + MoveInfo.SLog + "：升降盘定位气缸前进，清空条码信息");
                LastCodeList = new List<string>();
                NextCodeList = new List<string>();
                TrayLCylinderBefore(MoveInfo);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_09_TrayLocation_Before))
            {
                LoopCount = 0;
                MoveInfo.NextMoveStep(LineMoveStep.FI_10_AxisUpMove);
                InLog("料架入库" + MoveInfo.SLog + "：上料轴开始慢速上升到P3点，等待检测到料盘，设置LoopCount = 0");
                MoveInfo.ShelfNoTray = false;
                BatchAxisToP3();
            }
            #endregion

            #region 检测到托盘，扫码，取料并放入托盘 
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_10_AxisUpMove))
            {
                CheckHasTray();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_11_CylinderUp))
            {
                FI_12_MoveCylinder_Give();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_12_CylinderGive))
            {
                FI_13_ScanCode();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_13_ScanCode))
            {
                if (ScanCodeTask == null || ScanCodeTask.IsCompleted)
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_14_CylinderTake);
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料横移取料端");
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Give, IO_Type.SL_MoveCylinder_Take);
                    ClearTimeoutAlarm("扫码执行结束超时");
                }
                else if (MoveInfo.IsTimeOut(60))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 扫码执行结束超时 [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, DeviceID * 1000 + 30);
                    Alarm(LineAlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_14_CylinderTake))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_15_UpdownAxisToP3);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                InLog("料盘移栽" + MoveInfo.SLog + "：升降轴到P3");
                UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP3, Config.UpdownAxis_P3Speed);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_15_UpdownAxisToP3))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_16_CylinderTighten);
                InLog("料盘移栽" + MoveInfo.SLog + "：上料横移机构夹紧");
                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Slack, IO_Type.SL_MoveCylinder_Tighten);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_16_CylinderTighten))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_17_UpdownAxisToP1);
                InLog("料盘移栽" + MoveInfo.SLog + "：升降伺服到P1点");
                UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP1, Config.UpdownAxis_P1Speed);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_17_UpdownAxisToP1))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_18_WaitNoLocationCheck);
                InLog("料盘移栽" + MoveInfo.SLog + "：等待 SL_AxisLocationCheck=LOW");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_AxisLocationCheck, IO_VALUE.LOW));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_18_WaitNoLocationCheck))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_19_BatchAxisToP3);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                LastWidth = GetWidth();
                InLog("料盘移栽" + MoveInfo.SLog + "：提升伺服运动到P3，盘宽【" + LastWidth + "】，横移气缸上升 ");
                if (!CylinderIsOk(IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up))
                {
                    CylinderMove(null, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
                }
                else
                {
                    CylinderMove(null, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
                }
                BatchAxisToP3(false);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_19_BatchAxisToP3))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_20_SaveSize);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                LastHeight = GetHeight();
                if (LastWidth.Equals(7))
                {
                    if (LastHeight > 16)
                    {
                        LogUtil.error(Name + "计算后高度" + LastWidth + "X" + LastHeight + "，七寸盘默认盘高最高=16，修改高度为16");
                        LastHeight = 16;
                    }
                }
                else
                {
                    if (LastHeight < 12)
                    {
                        LogUtil.error(Name + "计算后高度" + LastWidth + "X" + LastHeight + "，非七寸盘默认盘高最低=12，修改高度为12");
                        LastHeight = 12;
                    }
                }
                if (MoveCylineIsUp())
                {
                    //MoveInfo.NextMoveStep(LineMoveStep.FI_21_CylinderGive);
                    //InLog("料盘移栽" + MoveInfo.SLog + "：上料横移气缸放料SOL");
                    //CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
                    FI_21_CylinderGive();
                }
                else
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_20_SaveSize);
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料横移气缸放料SOL前先上升横移气缸");
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
                }
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                //LastHeight = GetHeight();
                //if (LastWidth.Equals(7))
                //{
                //    if (LastHeight > 16)
                //    {
                //        LogUtil.error(Name + "计算后高度" + LastWidth + "X" + LastHeight + "，七寸盘默认盘高最高=16，修改高度为16");
                //        LastHeight = 16;
                //    }
                //}
                //else
                //{
                //    if (LastHeight < 12)
                //    {
                //        LogUtil.error(Name + "计算后高度" + LastWidth + "X" + LastHeight + "，非七寸盘默认盘高最低=12，修改高度为12");
                //        LastHeight = 12;
                //    }
                //}
                //判断是否还有料盘
                if (IOValue(IO_Type.SL_AxisLocationCheck).Equals(IO_VALUE.LOW))
                {
                    int currP = BatchAxis.GetAclPosition();
                    int chaz = Math.Abs(currP - Config.BatchAxisP3);
                    if (chaz < BatchAxis.Config.CanErrorCountMax)
                    {
                        //   MoveInfo.NextMoveStep(LineMoveStep.FI_21_BatchAxisDown);
                        // MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                        InLog("料盘移栽" + MoveInfo.SLog + "：记录 高度【" + LastHeight + "】宽度【" + LastWidth + "】,已经没有料盘，且已达到P3：" + Config.BatchAxisP3 + "，提升轴开始回下降待机点P2");
                        MoveInfo.ShelfNoTray = true;
                        BatchAxis.AbsMove(null, Config.BatchAxisP2, Config.BatchAxis_P2Speed);
                    }
                    else
                    {
                        InLog("料盘移栽" + MoveInfo.SLog + "：记录 高度【" + LastHeight + "】宽度【" + LastWidth + "】,此时未检测到料盘，上料轴位置【" + currP + "】不在P3：" + Config.BatchAxisP3 + "，预扫码");
                        YuScanCode();
                    }

                }
                else
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：记录 高度【" + LastHeight + "】宽度【" + LastWidth + "】，预扫码");
                    YuScanCode();
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_20_SaveSize))
            {
                if (MoveCylineIsUp())
                {
                    //MoveInfo.NextMoveStep(LineMoveStep.FI_21_CylinderGive);
                    //InLog("料盘移栽" + MoveInfo.SLog + "：上料横移气缸放料SOL");
                    //CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
                    FI_21_CylinderGive();
                }
                else
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_20_SaveSize);
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料横移气缸放料SOL前先上升横移气缸");
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_21_CylinderGive))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_22_BatchAxisDown);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                if (!MoveInfo.ShelfNoTray)
                {
                    FI_BatchAxisDown();
                }
                int targetPositon = Config.GetUpdownP2Detial(LastHeight, LastWidth);
                string log = "：移栽伺服下降到P2:" + targetPositon;
                InLog("料盘移栽" + MoveInfo.SLog + "：  " + log + "");
                UpdownAxis.AbsMove(MoveInfo, targetPositon, Config.UpdownAxis_P2Speed);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_22_BatchAxisDown))
            {
                FI_25_WaitTray();
                //FI_24_GetPosID(); 
            }
            //else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_23_WaitReelCheck))
            //{
            //    FI_24_GetPosID();
            //}
            //else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_24_GetPosID))
            //{
            //    FI_25_WaitTray();
                //if (getPosTask.IsCompleted && LastPosParam != null)
                //{
                //    MoveInfo.NextMoveStep(LineMoveStep.FI_25_WaitTray);
                //    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                //    if ((!LastPosParam.PlateH.Equals(LastHeight)) || (!LastPosParam.PlateW.Equals(LastWidth)))
                //    {
                //        InLog(" " + MoveInfo.SLog + " 原有料盘尺寸：【" + LastWidth + "X" + LastHeight + "】更改为服务器返回尺寸【" + LastPosParam.PlateW + "X" + LastPosParam.PlateH + "】   ");
                //        LastWidth = LastPosParam.PlateW;
                //        LastHeight = LastPosParam.PlateH;
                //    }
                //    InLog(" " + MoveInfo.SLog + " 开始拦截空托盘  " + LastPosParam.ToStr() + "");
                //    getPosIdMsg = "";
                //    ClearTimeoutAlarm("获取库位号超时");
                //}
                //else if (MoveInfo.IsTimeOut(120))
                //{
                //    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 获取库位号超时 "+ getPosIdMsg + " [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                //    LogUtil.error(WarnMsg, DeviceID * 1000 + 30);
                //    Alarm(LineAlarmType.IoSingleTimeOut);
                //}
            //}
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray))//TODO
            {
                if (SecondMoveInfo.MoveStep.Equals(LineMoveStep.MO_11_CodeRember))
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_26_CylinderDown);
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Up, IO_Type.SL_MoveCylinder_Down);
                    if (Config.SidesWayNum > 0)
                    {
                        //  CylinderMove(MoveInfo, IO_Type.SW_LocationCylinder_Down, IO_Type.SW_LocationCylinder_Up);
                    }
                    LastPosParam.TrayNumber = currTrayNum;
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料机构下降，  托盘号【" + currTrayNum + "】，更新托盘信息 ：" + LastPosParam.ToShortStr());
                    TrayManager.UpdateTrayInfo(currTrayNum, true, ReelType.InStore, LastPosParam, LastPosParam.NgMsg);
                    SServerManager.SendPosToStoreCheck(Name, LastPosParam);

                    if (IOValue(IO_Type.SL_AxisLocationCheck).Equals(IO_VALUE.LOW) && MoveInfo.ShelfNoTray.Equals(false))
                    {
                        InLog("获取库位" + MoveInfo.SLog + "： 上料轴开始慢速上升到P3点，不等待结果");
                        BatchAxisToP3(false, false);
                    }
                }
                else if (MoveInfo.IsTimeOut(180))
                {
                    WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveType + "][" + MoveInfo.SLog + "]等待空托盘到达超时[" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, DeviceID * 1000 + 22);
                    Alarm(LineAlarmType.IoSingleTimeOut);
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_26_CylinderDown))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_27_CylinderRelax);
                InLog("料盘移栽" + MoveInfo.SLog + "：上料气缸放松");
                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Tighten, IO_Type.SL_MoveCylinder_Slack);
                ClearTimeoutAlarm("等待空托盘到达超时");
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_27_CylinderRelax))
            {
                if (LastWidth > 7)
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_28_CylinderWork);
                    InLog("料盘移栽" + MoveInfo.SLog + "：大料，夹爪气缸夹紧");
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Slack, IO_Type.SL_MoveCylinder_Tighten);
                }
                else
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_30_WaitCylinderUp);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_MoveCylinder_Down, IO_VALUE.LOW));
                    CylinderMove(null, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
                    TrayPreMove();
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_28_CylinderWork))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_29_CylinderRelax2);
                InLog("料盘移栽" + MoveInfo.SLog + "：大料，上料气缸再次放松");
                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Tighten, IO_Type.SL_MoveCylinder_Slack);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_29_CylinderRelax2))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_30_WaitCylinderUp);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_MoveCylinder_Down, IO_VALUE.LOW));
                CylinderMove(null, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
                TrayPreMove();
            }
             
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_30_WaitCylinderUp))
            {
                //判断是小盘就直接放行，
                if (LastWidth.Equals(7) || (Config.SidesWayNum != 2))
                {
                    TrayMoveOk();
                }
                FI_31_CylinderUp();
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_31_CylinderUp))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_32_UpDownAxisToP1);
                //   InLog("料盘移栽" + MoveInfo.SLog + "：升降伺服到P1点");
                TrayMoveOk(true);
                if (!UpdownAxis.IsInPosition(Config.UpDownAxisP1))
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：升降轴到P1点，托盘放行");
                    UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP1, Config.UpdownAxis_P1Speed);
                }
                else
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：升降轴已在P1点，托盘放行");
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_32_UpDownAxisToP1))
            {
                if (getPosTask == null || getPosTask.IsCompleted)
                {
                    if (axisCheckTimer != null && axisCheckTimer.Enabled)
                    {
                        InLog("料盘移栽" + MoveInfo.SLog + "：批量轴还未停止运动，停止批量轴运动  ");
                    }
                    BatchAxisStopCheck();
                    //如果批量轴还在运动中，停止运动
                    ACServerManager.SuddenStop(BatchAxis.Config);

                    LoopCount = 0;
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料横移机构上升已到位，设置LoopCount = 0  ");
                    CheckHasTray();
                }
                else
                {
                    LogUtil.error(Name + "[" + MoveInfo.MoveType + "][" + MoveInfo.SLog + "]  获取库位号还未完成，状态：" + getPosTask.Status);
                }
            }
            #endregion

            #region 未检测到托盘或放料完成

            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_51_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_52_TrayLocationCylinder_After);
                InLog("上料完成" + MoveInfo.SLog + "： 升降盘定位气缸后退,  清理料架信息clearPutInRfid[" + CurrShelfId + "]");
                TrayLCylinderAfter(MoveInfo);
                SServerManager.clearPutInRfid(Name, CurrShelfId);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_52_TrayLocationCylinder_After))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_53_BatchAxisToP1);
                InLog("上料完成" + MoveInfo.SLog + "：提升伺服到P1点，定位气缸下降");
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Config.BatchAxis_P1Speed);
                CylinderMove(MoveInfo, IO_Type.SL_LocationCylinder_Up, IO_Type.SL_LocationCylinder_Down);
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_53_BatchAxisToP1))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_54_OutCheck);
                InLog("上料完成" + MoveInfo.SLog + "，等待出料线体无料架");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Out_Check, IO_VALUE.LOW));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Out_StopDown, IO_VALUE.LOW));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_54_OutCheck))
            {
                if (!ProcessShelfOut)
                {
                    MoveInfo.NextMoveStep(LineMoveStep.FI_55_OutTopCylinder_Up);
                    InLog("上料完成" + MoveInfo.SLog + "，出口顶升气缸上升,出料缓冲阻挡上升");
                    CylinderMove(MoveInfo, IO_Type.SL_OutTopCylinder_Down, IO_Type.SL_OutTopCylinder_Up);
                    IOMove(IO_Type.SL_Out_StopDown, IO_VALUE.LOW);
                }
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_55_OutTopCylinder_Up))
            {
                //TODO 
                MoveInfo.NextMoveStep(LineMoveStep.FI_56_SideWayLineRun);
                InLog("上料完成" + MoveInfo.SLog + "， 线体横移电机运转，等待料架离开上料工位");
                IOMove(IO_Type.SL_LocationSideWay_Run, IO_VALUE.HIGH);
                IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.HIGH);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Location_Check, IO_VALUE.LOW));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_56_SideWayLineRun))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_57_WaitShelfGo);
                InLog("上料完成" + MoveInfo.SLog + "， 线体横移电机运转，等待料架到达出口");
                IOMove(IO_Type.SL_LocationSideWay_Run, IO_VALUE.HIGH);
                IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.HIGH);
                //MoveInfo.OneWaitCanEndStep = true;
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(10000));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Out_Check, IO_VALUE.HIGH));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_57_WaitShelfGo))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_58_LineStop);

                InLog("上料完成" + MoveInfo.SLog + "， 料架到达出口，线体横移电机停止 ");
                IOMove(IO_Type.SL_LocationSideWay_Run, IO_VALUE.LOW);
                IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.LOW);

            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_58_LineStop))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_59_TopDown);
                InLog("上料完成" + MoveInfo.SLog + "， 料架到达出口，出口顶升下降 ，清理缓存料架RFID ");
                UpdateLastShelfID();
                CylinderMove(MoveInfo, IO_Type.SL_OutTopCylinder_Up, IO_Type.SL_OutTopCylinder_Down);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
            }
            else if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_59_TopDown))
            {
                MoveEndS();
                //  MoveInfo.NextMoveStep(LineMoveStep.FI_39_OutLineRun);
                LastOutShelfId = CurrShelfId;
                InLog("上料完成，料架到达出口处, 通知AGV取空料架, 入料流程结束，更新LastOutShelfId=" + LastOutShelfId);
                AgvClient.NeedLeave(Config.AgvOutName, LastOutShelfId, ClientLevel.Low);
            }

            #endregion
        }

        private void FI_25_WaitTray()
        {
            if (getPosTask.IsCompleted && LastPosParam != null)
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_25_WaitTray);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                if ((!LastPosParam.PlateH.Equals(LastHeight)) || (!LastPosParam.PlateW.Equals(LastWidth)))
                {
                    InLog(" " + MoveInfo.SLog + " 原有料盘尺寸：【" + LastWidth + "X" + LastHeight + "】更改为服务器返回尺寸【" + LastPosParam.PlateW + "X" + LastPosParam.PlateH + "】   ");
                    LastWidth = LastPosParam.PlateW;
                    LastHeight = LastPosParam.PlateH;
                }
                InLog(" " + MoveInfo.SLog + " 开始拦截空托盘  " + LastPosParam.ToStr() + "");
                getPosIdMsg = "";
                ClearTimeoutAlarm("获取库位号超时");
            }
            else if (MoveInfo.IsTimeOut(15))
            {
                WarnMsg = MoveInfo.Name + "[" + MoveInfo.MoveStep + "] 获取库位号超时 " + getPosIdMsg + " [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                LogUtil.error(WarnMsg, DeviceID * 1000 + 30);
                Alarm(LineAlarmType.IoSingleTimeOut);
            }
        }

        private void FI_21_CylinderGive()
        {
            MoveInfo.NextMoveStep(LineMoveStep.FI_21_CylinderGive);
            InLog("料盘移栽" + MoveInfo.SLog + "：上料横移气缸放料SOL");
            CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
            FI_24_GetPosID();
        }
        private Task getPosTask = null;
        private InOutParam  LastPosParam = null;
        private string getPosIdMsg = "";
        private void FI_24_GetPosID()
        {
            //MoveInfo.NextMoveStep(LineMoveStep.FI_24_GetPosID);
            //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(200));
            InLog("清空LastPosResult，从服务器获取入库库位");
            LastPosParam = null;
            string code = CodeManager.ProcessCode(LastCodeList);
            lastcode = code;
            getPosTask = Task.Factory.StartNew(delegate
            {
                //更新托盘条码信息 
                try
                {
                    int count = 1;
                    while (MoveInfo.MoveType.Equals(LineMoveType.InStore))
                    {
                        int ms = 5000;
                        //从服务器获取库位号
                        GetPosResult result = SServerManager.GetPosId(Name, LastCodeList, LastHeight, LastWidth, CurrShelfId, DeviceID);
                        if (result.IsTimeOut)
                        { 
                            if (count < 5)
                            {
                                ms = 2000;
                            } 
                            Thread.Sleep(ms); 
                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 FI_23_GetPosID 超时，等待" + ms + "后重新获取");
                        }
                        else if (result.Result.Equals(99) || result.Result.Equals(100))
                        {  
                            if (count < 5)
                            {
                                ms = 3000;
                            }
                            Thread.Sleep(ms);
                            getPosIdMsg = result.Msg;
                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 FI_23_GetPosID 结果【" + result.Result + "】，等待" + ms + "后重新获取");
                        }
                        else if (!result.Msg.Equals(""))
                        {
                            LastPosParam = result.Param;
                            LogUtil.error(Name + "【" + code + "】第[" + count + "]次 FI_23_GetPosID 入库NG：" + result.Msg);
                            break;
                        }
                        else
                        {
                            LastPosParam = result.Param;
                            break;
                        }
                        count++;
                    }                    
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "【" + code + "】获取库位号报错：" + ex.ToString());
                }

            }); 
        }

        private void FI_31_CylinderUp()
        {
            MoveInfo.NextMoveStep(LineMoveStep.FI_31_CylinderUp);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
            CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
            //如果是小料盘，且升降轴需要上升，
            string upLog = "";
            if (LastWidth.Equals(7) && LastHeight.Equals(8))
            {
                upLog = " ，7X8盘，升降轴到待机位P1  ";
                UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP1, Config.UpdownAxis_P1Speed);
            } 
            InLog("料盘移栽" + MoveInfo.SLog + "：上料横移机构上升 " + upLog); 
        }
        private void TrayPreMove()
        {
            if (Config.SidesWayNum > 0)
            {
                InLog(MoveInfo.SLog + "  提前下降顶升气缸  ，环形线定位气缸先下降");
                CylinderMove(null, IO_Type.SW_LocationCylinder_Up, IO_Type.SW_LocationCylinder_Down);
                if (Config.SidesWayNum.Equals(1))
                {
                    Task.Factory.StartNew(delegate
                    {
                        //需要等待500再下降
                        Thread.Sleep(500);
                        CylinderMove(null, IO_Type.SW_TopCylinder_Up, IO_Type.SW_TopCylinder_Down);
                    });
                }
            }
            else
            {
                InLog(MoveInfo.SLog + " 提前顶升下降，  顶升气缸下降）");
                CylinderMove(null, IO_Type.FL_TopCylinder_Up, IO_Type.FL_TopCylinder_Down);
            }
        }
        private void FI_BatchAxisDown()
        { 
            //   MoveInfo.NextMoveStep(LineMoveStep.FI_21_BatchAxisDown);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(200));
            int maxtPosition = Config.BatchAxisP3 - Config.Height_ChangeValue * 30; //在上料位置基础上下降30mm
            int currPositon = BatchAxis.GetAclPosition();

            int targetPosition = currPositon - Config.Height_ChangeValue * 30;
            if (targetPosition <= Config.BatchAxisP2)
            {
                targetPosition = Config.BatchAxisP2;
            }
            else if (targetPosition > maxtPosition)
            {
                targetPosition = maxtPosition;
            }
            InLog("料盘移栽" + MoveInfo.SLog + "：提升轴下降到料盘不溢出(" + (currPositon - Config.Height_ChangeValue * 30) + ")：" + targetPosition+",速度："+Config.BatchAxis_P4Speed);
            BatchAxis.AbsMove(MoveInfo, targetPosition, Config.BatchAxis_P4Speed);
        }

        private void YuScanCode()
        {
            bool isScan = ConfigAppSettings.GetIntValue(Setting_Init.NeedScanCode).Equals(1);
            //TODO 此处需要等待空托盘 
            if (MoveInfo.ShelfNoTray.Equals(false) && isScan)
            {
                InLog("料盘移栽" + MoveInfo.SLog + "： ，预扫码");
                //还有料盘，直接扫码
                NextCodeList = new List<string>();
                List<string> bijiaoList = new List<string>(LastCodeList);
                try
                {
                    Task<List<string>> scanTask = Task.Factory.StartNew(delegate
                    {
                        Thread.Sleep(100);
                        NextCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name.Trim()+"预扫码");
                        bool isCanUse = true;
                        //判断是否可用
                        foreach (string nC in NextCodeList)
                        {
                            foreach (string n in bijiaoList)
                            {
                                if (nC.Length > 15 && nC.Equals(n))
                                {
                                    LogUtil.error(Name + "预扫码结果【" + nC + "】与上个条码【" + n + "】重复，预扫码不可用");
                                    isCanUse = false;
                                    break;
                                }
                            }
                        } 
                        if (!isCanUse)
                        {
                            NextCodeList = new List<string>();
                        }
                        if (!CodeManager.HasRightCode(NextCodeList.ToArray()))
                        {
                            NextCodeList = new List<string>();
                        }
                        return NextCodeList;
                    });
                }
                catch (Exception ex)
                {
                    LogUtil.error(" 为下一盘料扫码出错：", ex);
                }
            }
        }
        private void FI_12_MoveCylinder_Give()
        {
            if (MoveCylineIsUp())
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_12_CylinderGive);
                InLog("料盘移栽" + MoveInfo.SLog + "：上料机构检测到料盘，横移机构到放料端");
                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
            }
            else
            {
                //有料盘
                MoveInfo.NextMoveStep(LineMoveStep.FI_11_CylinderUp);
                InLog("料盘移栽" + MoveInfo.SLog + "：上料机构检测到料盘，横移机构上升");
                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Down, IO_Type.SL_MoveCylinder_Up);
            }
        }
        private Task ScanCodeTask = null;
        private void FI_13_ScanCode()
        {
            if (CylinderIsOk(IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give))
            {
                MoveInfo.NextMoveStep(LineMoveStep.FI_13_ScanCode);
                bool isScan = ConfigAppSettings.GetIntValue(Setting_Init.NeedScanCode).Equals(1);

                LastCodeList = new List<string>();

                ScanCodeTask = null;
                if (NextCodeList.Count > 0)
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：开始扫码：使用预扫码");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
                    LastCodeList = new List<string>(NextCodeList);
                    NextCodeList = new List<string>();
                    MoveInfo.NextMoveStep(LineMoveStep.FI_14_CylinderTake);
                    InLog("料盘移栽" + MoveInfo.SLog + "：上料横移取料端");
                    CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Give, IO_Type.SL_MoveCylinder_Take);
                }
                else if (isScan)
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：开始扫码");
                    MoveInfo.OneWaitCanEndStep = true;
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitFeedScanCode());
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(7000));
                    try
                    {
                        ScanCodeTask = Task.Factory.StartNew(delegate
                        {
                            LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name);
                            bool hasRightCode = CodeManager.HasRightCode(LastCodeList.ToArray());
                            if (!hasRightCode)
                            {
                                LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name, false, 3000);
                            }
                            return LastCodeList;
                        });
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("FI_13_ScanCode扫码出错：", ex);
                    }
                    //finally
                    //{
                    //    MoveInfo.EndStepWait();
                    //}
                }
                else
                {
                    InLog("料盘移栽" + MoveInfo.SLog + "：不需要扫码");
                }
            }
            else
            {
                FI_12_MoveCylinder_Give();
            }
        }
        private int LoopCount = 0;
        private void CheckHasTray()
        {
            if (IOValue(IO_Type.SL_AxisLocationCheck).Equals(IO_VALUE.HIGH) && MoveInfo.ShelfNoTray.Equals(false))
            {
                FI_13_ScanCode();
            }
            else
            {
                if (MoveInfo.ShelfNoTray.Equals(false))
                { 
                    //判断当前位置是否在指定的位置
                    int currP = BatchAxis.GetAclPosition();
                    int chaz = Math.Abs(currP - Config.BatchAxisP3);
                    if (chaz > BatchAxis.Config.CanErrorCountMax)
                    {
                        if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_10_AxisUpMove))
                        {
                            //如果是循环运动，记录次数，超过次数时报警
                            LoopCount++;
                        }
                        else
                        {
                            LoopCount = 0;
                        }

                        if (LoopCount < 10)
                        { 
                            MoveInfo.NextMoveStep(LineMoveStep.FI_10_AxisUpMove);
                            InLog("料架入库" + MoveInfo.SLog + "：CheckHasTray：上料轴开始慢速上升到P3点，等待检测到料盘，LoopCount="+LoopCount);
                            MoveInfo.ShelfNoTray = false;
                            BatchAxisToP3(false);
                        }
                        else
                        {
                            WarnMsg = Name + "提升轴运动报警。上升到P3点已重复" + LoopCount + "次，仍未检测到料盘信号";
                            LogUtil.error(WarnMsg);
                            Alarm(LineAlarmType.AxisMoveError);
                        }
                        return;
                    }
                }
                //无料盘
                MoveInfo.ShelfNoTray = true;
                LoopCount = 0;
                MoveInfo.NextMoveStep(LineMoveStep.FI_51_BatchAxisToP2);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                InLog("料盘移栽" + MoveInfo.SLog + "：未检测到料盘，提升伺服到P2点，设置 LoopCount = 0");
                BatchAxis.SuddenStop();
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP2, Config.BatchAxis_P2Speed);
            }
        }

        private void BatchAxisToP3(bool isFirstMove = true, bool isWait = true)
        {
            int targetP3 = Config.BatchAxisP3;
            int targetSpeed = Config.BatchAxis_P3Speed;
            if (!isFirstMove)
            {
                int currPosition = BatchAxis.GetAclPosition();
                if (currPosition != -1)
                {
                    targetP3 = currPosition + Config.Height_ChangeValue * 80;
                    if (targetP3 > Config.BatchAxisP3)
                    {
                        targetP3 = Config.BatchAxisP3;
                    }
                    LogUtil.info(Name + " BatchAxisToP3 目标P3: " + targetP3 + "(" + currPosition + ")");
                }
                //targetSpeed = Config.BatchAxis_P3Speed / 2;
            }
            //  需要增加定时器，获取验证信号并停止伺服
            StartMovePosition = BatchAxis.GetAclPosition();
            if (isWait)
            {
                MoveInfo.TimeOutSeconds = 200;
                MoveInfo.CanWhileCount = 0;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitBatchAxis(Config.Batch_Axis, targetP3, targetSpeed));
            }
            Config.Batch_Axis.TargetPosition = targetP3;
            BatchAxis.AbsMove(null, targetP3, targetSpeed);
            //开始检测信号
            BatchAxisStartCheck();
        }

        private int StartMovePosition = 0;
        private int EndMovePosition = 0;
        private int LastHeight = 0;
        private int LastWidth = 0;
        private List<string> LastCodeList = new List<string>();
        private List<string> NextCodeList = new List<string>();
        private int GetHeight()
        {
            LastHeight = 0;
            int AxisChangeValue = Config.Height_ChangeValue;
            //计算高度
            EndMovePosition = BatchAxis.GetAclPosition();
            bool isLast = false;
            int chaz = Math.Abs(EndMovePosition - Config.BatchAxisP3);
            if (chaz < BatchAxis.Config.CanErrorCountMax)
            {
                isLast = true;
            }
            float height = (float)Math.Ceiling(1F * Math.Abs(EndMovePosition - StartMovePosition) / AxisChangeValue);
            string buchongStr = "";
            if (isLast)
            {
                buchongStr = "(最后一盘料已补充5)";
                height += 5;
            }

            //如果检测出<=15,都按照8计算
            if (height <= 15)
            {
                LastHeight = 8;
            }
            else
            { 
                List<int> heightList = LineManager.GetTrayList();
                heightList = (from m in heightList orderby m descending select m).ToList<int>();
                float minCha = height;
                foreach (int h in heightList)
                {
                    //取差值最小的接近值
                    float cha = Math.Abs(h - (height - 4));
                    if (cha < minCha)
                    {
                        LastHeight = h;
                        minCha = cha;
                    }
                }
            }
            if (LastHeight <= 8) { LastHeight = 8; }
            string code = CodeManager.ProcessCode(LastCodeList);
            string msg = Name + " 计算盘高：上升前 [" + StartMovePosition + "]实时[ " + EndMovePosition + "]差值[" + (EndMovePosition - StartMovePosition) + "]系数[" + AxisChangeValue + "] 计算后"+buchongStr+"[" + height + "]" + ",归类为【" + LastHeight + "mm】条码【"+code+"】";
            LogUtil.info(msg);
            return LastHeight;
        }
        public  int GetWidth()
        {
            int width = 15;
            if (IOValue(IO_Type.SL_TrayCheck4).Equals(IO_VALUE.HIGH))
            {
                width = 15;
            }
            else if (IOValue(IO_Type.SL_TrayCheck3).Equals(IO_VALUE.HIGH))
            {
                width = 13;
            }
            else if (IOValue(IO_Type.SL_TrayCheck2).Equals(IO_VALUE.HIGH))
            {
                width = 11;
            }
            else if (IOValue(IO_Type.SL_TrayCheck1).Equals(IO_VALUE.HIGH))
            {
                width = 7;
            }else
            {
                LogUtil.error(Name + "GetWidth ：1234都未检测到，默认为7寸盘");
                width = 7;
            }
            return width;
        }
        #endregion

        #region 判断托盘是否需要

        internal bool CurrTrayIsNeed(int trayNum, bool NeedSaveParam)
        {
            try
            {
                if (IsDebug && runStatus <= LineRunStatus.Wait)
                {
                    return false;
                }
                if (trayNum <= 0)
                {
                    return false;
                }
                if (TrayDisableManager.DisableTray(currTrayNum))
                {
                    return false;
                }
                TrayInfo info = TrayManager.GetTrayInfo(trayNum);
                InOutParam param = info.InoutPar;

                //是出料的模块
                if (Config.IsCanOut.Equals(1))
                {
                    //此托盘是紧急出料盘，需要通过料架出库 
                    bool debugNeed = (runStatus >= LineRunStatus.Runing) && info.IsFull && info.InOrOutStore.Equals(2);
                    debugNeed = false;

                    bool isJinji = (param.cutReel) && info.InOrOutStore.Equals(2) && info.IsFull && runStatus >= LineRunStatus.Runing;
                    //bool isJinji = (param.urgentReel || param.cutReel) && info.InOrOutStore.Equals(2) && info.IsFull && runStatus >= LineRunStatus.Runing;

                    if (debugNeed || isJinji)
                    {

                        //判断是否有料架，是否可以出库
                        if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.LOW))
                        {
                            LogUtil.error(Name + " 【" + info.ToStr() + "】需要出库，定位工位无料架，暂不处理", DeviceID * 1000 + 16);
                            return false;
                        }
                        else if (OutStoreHeight < 0)
                        {
                            LogUtil.error(Name + " 【" + info.ToStr() + "】需要出库，料架未准备好，暂不处理", DeviceID * 1000 + 17);
                            return false;
                        }

                        //如果已经开始送出料架，暂不处理
                        if (MoveInfo.MoveType.Equals(LineMoveType.OutStore) && MoveInfo.MoveStep >= LineMoveStep.FO_30_BatchAxisToP2)
                        {
                            LogUtil.error(Name + " 【" + info.ToStr() + "】需要出库，正在送出料架，暂不处理", DeviceID * 1000 + 18);
                            return false;
                        }
                        string lastXuniRfid = LastOutParam.rfid;
                        if (String.IsNullOrEmpty(lastXuniRfid).Equals(false) && (!lastXuniRfid.Equals(param.rfid)))
                        {
                            //如果流水线还有次料架的任务，暂不送出
                            int count = TrayManager.GetOutTaskByRfid(lastXuniRfid);
                            if (count > 0)
                            {
                                LogUtil.error(Name + " 【" + info.ToStr() + "】需要出库，料架号不一致[" + lastXuniRfid + "][" + param.rfid + "]，当前料架还有【" + count + "】个任务，托盘先离开", DeviceID * 1000 + 19);
                                return false;
                            }
                        }
                        if (NeedSaveParam)
                        {
                            LogInfo(" 【" + info.ToStr() + "】需要出库 ，拦截托盘 ");
                            CheckParam = param;
                        }
                        return true;
                    }

                }
                else
                {
                    bool trayCanUse = LineManager.Line.runStatus <= LineRunStatus.Wait || (!info.IsFull);
                    if (trayCanUse && runStatus.Equals(LineRunStatus.Busy) && MoveInfo.MoveType.Equals(LineMoveType.InStore))
                    {
                        //入料执行中， 且需要空托盘
                        if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray) || 
                            MoveInfo.MoveStep.Equals(LineMoveStep.FI_22_BatchAxisDown)||
                            MoveInfo.MoveStep.Equals(LineMoveStep.FI_21_CylinderGive))
                        //if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray) && MoveInfo.IsInWait.Equals(false))
                        {
                             
                            if (!MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray))
                            {
                                //如果报警直接离开
                                if ((!alarmType.Equals(LineAlarmType.None)) || WarnMsg.Contains("获取库位号超时"))
                                {
                                    return false;
                                }
                            }

                            if (NeedEmptyTrayGo())
                            {
                                LogUtil.info(Name + "拦截到空托盘【" + trayNum + "】，后续料仓需要空托盘，放行托盘");
                                return false;
                            }

                            if (NeedSaveParam)
                            {
                                CheckParam = param;
                                LogUtil.info(Name + "拦截到空托盘【" + trayNum + "】，入料执行中，需要空托盘");
                            }
                            return true;
                        }
                    }
                }
                if (NeedSaveParam && LineManager.Line.runStatus >= LineRunStatus.HomeMoving && LineManager.Line.CanProcessLine())
                {
                    LogUtil.debug(" 【" + info.ToStr() + "】不需要出入库");
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "CurrTrayIsNeed出错：", ex);
            }

            return false;
        } 
        internal bool WaitEmptyTray()
        {
            try
            {
                if (IsDebug && runStatus <= LineRunStatus.Wait)
                {
                    return false;
                }
                if (Config.IsCanOut.Equals(0))
                {
                    if (runStatus.Equals(LineRunStatus.Busy) && MoveInfo.MoveType.Equals(LineMoveType.InStore))
                    {
                        //入料执行中， 且需要空托盘
                        if (MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray) ||
                       MoveInfo.MoveStep.Equals(LineMoveStep.FI_22_BatchAxisDown) ||
                       MoveInfo.MoveStep.Equals(LineMoveStep.FI_21_CylinderGive))
                        //if ((MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray))&& MoveInfo.IsInWait.Equals(false))
                        {
                            if (!MoveInfo.MoveStep.Equals(LineMoveStep.FI_25_WaitTray))
                            {
                                //如果报警直接离开
                                if ((!alarmType.Equals(LineAlarmType.None)) || WarnMsg.Contains("获取库位号超时"))
                                {
                                    return false;
                                }
                            }
                            return true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "WaitEmptyTray 出错：", ex);
            }
            return false;
        }

        private bool NeedEmptyTrayGo()
        {
            try
            {
                if (DeviceID.Equals(102))
                {
                    MoveEquip moveEquip7 = LineManager.Line.GetMoveByDId(7);
                    if (moveEquip7.IsWaitEmptyTray())
                    {
                        return true;
                    }
                    MoveEquip moveEquip8 = LineManager.Line.GetMoveByDId(8);
                    if (moveEquip8.IsWaitEmptyTray())
                    {
                        return true;
                    }
                }  //如果是入料三入库，且进仓19，进仓20需要空托盘，先放托盘经过
                if (DeviceID.Equals(103))
                {
                    MoveEquip moveEquip19 = LineManager.Line.GetMoveByDId(19);
                    if (moveEquip19.IsWaitEmptyTray())
                    {
                        return true;
                    }
                    MoveEquip moveEquip20 = LineManager.Line.GetMoveByDId(20);
                    if (moveEquip20.IsWaitEmptyTray())
                    {
                        return true;
                    }
                }

            }
            catch (Exception ex)
            {
                LogUtil.error("NeedEmptyTrayGo出错：" + ex.ToString());
            }
            return false;
        }

        #endregion

    }
}