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

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 流水线自动料仓-入料装置类
    /// </summary>
    public partial class FeedingEquip : EquipBase
    {
        public FeedingEquip_Config Config;
        public bool OutEndSendShelfOut = false;
        public AxisBean BatchAxis = null;
        public FeedingEquip(string cid, FeedingEquip_Config config)
        {
            this.DeviceID = config.Id;
            baseConfig = config;
            this.Config = config;
            IsDebug = config.IsDebug.Equals(1);
            Name = (" " + "入料T" + DeviceID % 100 + " ").ToUpper();
            Init();
            UseAxis = true;

            UpdownAxis = new AxisBean(config.UpDown_Axis, Name);
            BatchAxis = new AxisBean(config.Batch_Axis, Name);
            MoveInfo = new LineMoveInfo(DeviceID, "[" + Name.Trim() + "-Move]");
            SecondMoveInfo = new LineMoveInfo(DeviceID, "[" + Name.Trim() + "-SMove]");
            RFIDIP = RFIDManager.GetRFIP(DeviceID);
        }

        public override bool StartRun(bool isDebug = false)
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            //if (isDebug)
            //{      //连接AGV调度
            //    if (!AgvClient.ISConnected())
            //    {
            //        AgvClient.Init();
            //    }
            //}
            if (IOValue(IO_Type.SL_SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg(Name + "启动失败：急停未开");
                return false;
            }
            if (RunAxis(true, BatchAxis) && RunAxis(true, UpdownAxis))
            {
                mainTimer.Enabled = false;
                MoveInfo.EndMove();
                SecondMoveInfo.EndMove(); 
                runStatus = LineRunStatus.HomeMoving;

                LogInfo("开始原点返回： ");
                MoveInfo.NewMove(LineMoveType.ReturnHome);

                StartReset();

                if (isDebug)
                {
                    LogInfo("开始调试，启动定时器 ");
                    mainTimer.Start();
                }
                return true;
            }
            return false;
        }

        public override bool Reset()
        { 
            runStatus = LineRunStatus.Reset; 
            StopMove(); 
            MoveInfo.NewMove(LineMoveType.Reset);
            SecondMoveInfo.EndMove();
            if (RunAxis(true, BatchAxis) && RunAxis(true, UpdownAxis))
            {
              
                alarmType = LineAlarmType.None;
                LogInfo("开始重置： ");
                runStatus = LineRunStatus.Reset;
                MoveInfo.NewMove(LineMoveType.Reset);
                StartReset();
                return true;
            }
            return false;
        }

        private void StartReset()
        {
            if (OutStoreHeight > 0)
            {
                LogInfo("复位前，清理出库高度：" + OutStoreHeight);
            }
            //复位时设置状态为none
            AgvClient.SetStatus(Config.AgvInName);
            AgvClient.SetStatus(Config.AgvOutName);

            OutStoreHeight = -1;
            //OutStoreCount = 0;
            BatchAxisStopCheck();
            ResetClearData(); 
            IOMove(IO_Type.SL_HddLed, IO_VALUE.HIGH);
            MoveInfo.NextMoveStep(LineMoveStep.FR_01_StopUp);

            IOMove(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW);
            IOMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW);
            IOMove(IO_Type.SL_Out_StopDown, IO_VALUE.LOW);
            //夹紧气缸放松
            CylinderMove(null, IO_Type.SL_ClampCylinder_Relax, IO_Type.SL_ClampCylinder_Work);
            if (Config.DOList.ContainsKey(IO_Type.SL_RollerLine_Run))
            { 
                IOMove(IO_Type.SL_RollerLine_Run, IO_VALUE.LOW);
            } 
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Out_StopDown, IO_VALUE.LOW));
            isInPro = false;
        }
        //复位时，应该先提升伺服回原点，然后提升伺服下降到P2点，放开定位气缸，顶升气缸下降，提升伺服在上升到P1点。
        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (!MoveInfo.IsInWait)
            {
                switch (MoveInfo.MoveStep)
                {
                    case LineMoveStep.Wait:
                        StartReset();
                        break;
                    case LineMoveStep.FR_01_StopUp:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_02_LineRun);
                        //阻挡上升
                        if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
                        {
                            LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：开始复位，放料顶升下降， 所有阻挡上升，检测到定位工位有信号，不转动链条");
                        }
                        else
                        {
                            LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：开始复位，放料顶升下降， 所有阻挡上升，链条先转动3秒钟 ");
                            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                            //线体开始转动
                            IOMove(IO_Type.SL_Line_Run, IO_VALUE.HIGH);
                            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.HIGH));
                            MoveInfo.OneWaitCanEndStep = true;
                        }
                        break;
                    case LineMoveStep.FR_02_LineRun:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_03_CylinderUp);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：链条停止转动，上料横移机构上升，顶升气缸下降，所有阻挡气缸上升");
                        //线体停止
                        IOMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
                        IOMove(IO_Type.SL_LocationSideWay_Run, IO_VALUE.LOW);
                        IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.LOW);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_Line_Run, IO_VALUE.LOW));
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationSideWay_Run, IO_VALUE.LOW));
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_OutSideWay_Run, IO_VALUE.LOW));
                        TopCylinderDown(MoveInfo);
                 
                        break;
                    case LineMoveStep.FR_03_CylinderUp:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_04_UpdownAxisHome);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 升降伺服回原点");
                        UpdownAxis.HomeMove(MoveInfo);
                        break;

                    case LineMoveStep.FR_04_UpdownAxisHome:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_05_UpdownAxis_P1);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 升降伺服到P1");
                        UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP1, Config.UpdownAxis_P1Speed);
                        break;
                    case LineMoveStep.FR_05_UpdownAxis_P1:
                        if (UpdownIsInP1())
                        { 
                            MoveInfo.NextMoveStep(LineMoveStep.FR_06_CylinderGive);
                            if (Config.IsCanOut.Equals(1))
                            {
                                LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 上料横移气缸取料端SOL");
                                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Give, IO_Type.SL_MoveCylinder_Take);
                            }
                            else
                            {
                                LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 上料横移气缸放料端SOL");
                                CylinderMove(MoveInfo, IO_Type.SL_MoveCylinder_Take, IO_Type.SL_MoveCylinder_Give);
                            }
                        }
                        else
                        {
                            MoveInfo.NextMoveStep(LineMoveStep.FR_05_UpdownAxis_P1);
                            LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：上料横移机构取料端  前升降轴先到P1");
                            UpdownAxis.AbsMove(MoveInfo, Config.UpDownAxisP1, Config.UpdownAxis_P1Speed);
                        }
                        break;
                    case LineMoveStep.FR_06_CylinderGive:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_11_BatchAxisHome);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                        MoveInfo.TimeOutSeconds = 120;
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：提升伺服回原点");
                        BatchAxis.HomeMove(MoveInfo);
                        break;
                    case LineMoveStep.FR_11_BatchAxisHome:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_12_BatchAxisToP2);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：提升伺服下降到P2点，");
                        MoveInfo.TimeOutSeconds = 120;
                        BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP2, Config.BatchAxis_P2Speed);
                        break;
                    case LineMoveStep.FR_12_BatchAxisToP2:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_13_LocationDown);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 托盘定位气缸后退，升降伺服到P1");
                        TrayLCylinderAfter(MoveInfo);
                        Thread.Sleep(50);
                        break;

                    case LineMoveStep.FR_13_LocationDown:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_14_FixedUp);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：固定气缸上升");
                        FixedCylinderUp(MoveInfo);
                        break;
                    case LineMoveStep.FR_14_FixedUp:
                        MoveInfo.NextMoveStep(LineMoveStep.FR_15_TopDown);
                        LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "： 定位气缸下降 ，夹紧气缸放松");
                        LocationCylinderDown(MoveInfo);
                        //CylinderMove(MoveInfo, IO_Type.SL_OutTopCylinder_Up, IO_Type.SL_OutTopCylinder_Down);
                        CylinderMove(MoveInfo, IO_Type.SL_ClampCylinder_Work, IO_Type.SL_ClampCylinder_Relax );
                        break; 
                    case LineMoveStep.FR_15_TopDown:

                        MoveInfo.NextMoveStep(LineMoveStep.FR_16_BatchAxisToP1);
                        //判断定位工位是否有料架
                        if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
                        {
                            LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：定位工位有料架，提升伺服不需要到P1");
                        }
                        else
                        {
                            LogInfo(MoveInfo.MoveType + "：" + MoveInfo.SLog + "：定位工位无料架，提升伺服上升到P1点");
                            BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Config.BatchAxis_P1Speed);
                        }
                        break;
                    case LineMoveStep.FR_16_BatchAxisToP1: 
                        MoveInfo.NextMoveStep(LineMoveStep.FR_17_ClampCheck);
                        DebugInfo(MoveInfo.MoveType + " : 等待夹爪料盘检测信号无料");
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ClampCylinder_Check, IO_VALUE.LOW));
                        break;

                    case LineMoveStep.FR_17_ClampCheck: 
                        LogInfo("重置完成！");
                        if (IOValue(IO_Type.SL_Out_Check).Equals(IO_VALUE.HIGH))
                        {
                            ClientLevel level = ClientLevel.Low;
                            if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH))
                            {
                                level = ClientLevel.Middle;
                            }
                            if (Config.IsCanOut.Equals(1))
                            {
                                level = ClientLevel.High;
                            }
                            LogInfo("重置完成，出口检测到有料架，调用 " + Config.AgvOutName + " AgvClient.NeedLeave");
                            AgvClient.NeedLeave(Config.AgvOutName, LastOutShelfId, level);
                        }
                        MoveEndS();
                        break;
                    default: break;
                }
            }
        }

        internal override void StopMove()
        {
            MoveInfo.EndMove();
            SecondMoveInfo.EndMove();
            //StopMove时设置状态为none
            AgvClient.SetStatus(Config.AgvInName,"",ClientAction.None,ClientLevel.Low,true);
            AgvClient.SetStatus(Config.AgvOutName, "", ClientAction.None, ClientLevel.Low, true);

            BatchAxisStopCheck();
            BatchAxis.SuddenStop();
            UpdownAxis.SuddenStop();

            CloseAxis(BatchAxis);
            CloseAxis(UpdownAxis); 
            CheckAndMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SL_LocationSideWay_Run, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SL_OutLine_Run, IO_VALUE.LOW);
            if (Config.DOList.ContainsKey(IO_Type.SL_RollerLine_Run))
            {
                IOMove(IO_Type.SL_RollerLine_Run, IO_VALUE.LOW);
            }
            CheckAndMove(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SL_Buffer_StopDown, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SL_Out_StopDown, IO_VALUE.LOW);
        }

        /// <summary>
        /// 停止运行
        /// </summary>
        public override void StopRun()
        {
            runStatus = LineRunStatus.Wait; 
            if (mainTimer != null)
            {
                mainTimer.Enabled = false;
            }
            StopMove();
           
            AgvClient.SetStatus(Config.AgvInName, "", ClientAction.None, ClientLevel.Low, true);
            AgvClient.SetStatus(Config.AgvOutName, "", ClientAction.None, ClientLevel.Low, true);
        }


        protected override void BaseTimerProcess()
        {
            if (IOValue(IO_Type.SL_SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                if (!isInSuddenDown)
                {
                    LogUtil.error(Name + "收到急停信号，等待300后再次验证急停");

                    Thread.Sleep(300);
                    if (IOValue(IO_Type.SL_SuddenStop_BTN).Equals(IO_VALUE.LOW))
                    {
                        SetWarnMsg(Name + "收到急停信号，急停报警");
                        if (isInSuddenDown.Equals(false))
                        {
                            Alarm(LineAlarmType.SuddenStop);
                        }
                        return;
                    }
                }
            }
            else if (IOValue(IO_Type.SL_Reset_BTN).Equals(IO_VALUE.HIGH))
            {
                if (NoAlarm())
                {
                    if (MoveInfo.MoveType.Equals(LineMoveType.None))
                    {
                        LogUtil.error(Name + "收到复位信号，当前无报警，不需要复位");
                    }
                    else
                    {
                        LogUtil.error(Name + "收到复位信号，当前无报警,正在" + MoveInfo.MoveType + "处理中，不需要复位");
                    }
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，开始复位");
                    Reset();
                }
                return;
            }
            if (isInSuddenDown || isNoAirCheck)
            {
                return;
            }
            BusyMoveProcess();
            IOTimeOutProcess();
            //判断流水线打开了才可以运行 
            if (MoveInfo.MoveType.Equals(LineMoveType.None) && NoErrorAlarm() && (!MoveStop))
            {
                if (Config.IsCanOut.Equals(0))
                {
                    StartInStoreP();
                }
                else
                {
                    StartOutStoreP();
                }
            }
          
            if (NoErrorAlarm())
            {
                if (IOValue(IO_Type.SL_Out_Check).Equals(IO_VALUE.HIGH))
                {
                    if (CheckStopWatch(needLeaveWatch, 3000))
                    {
                        ClientLevel level = ClientLevel.Low;
                        if (Config.IsCanOut.Equals(1))
                        {
                            level = ClientLevel.High;
                        }
                        else if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.HIGH) || (!MoveInfo.MoveType.Equals(LineMoveType.None)))
                        {
                            level = ClientLevel.Middle; 
                        }
                        //线体出口检测到料架，需要通知AGV小车
                        AgvClient.NeedLeave(Config.AgvOutName, LastOutShelfId, level); 
                    }
                }
                else
                {
                    needLeaveWatch.Stop();
                    AgvClient.SetToNone(Config.AgvOutName);
                }
                //入口无料架，mayEnter
                if (IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.LOW))
                {
                    if (CheckStopWatch(needEnterWatch, 3000))
                    {
                        ClientLevel level = ClientLevel.Low;
                        if (Config.IsCanOut.Equals(1))
                        {
                            //如果是出料模块且当前无料架
                            if (IOValue(IO_Type.SL_Location_Check).Equals(IO_VALUE.LOW) && MoveInfo.MoveType.Equals(LineMoveType.None))
                            {
                                level = ClientLevel.High;
                            }
                        }
                        AgvClient.NeedEnter(Config.AgvInName, "", level);
                    }
                }
                else
                {
                    needEnterWatch.Stop();
                    AgvClient.SetToNone(Config.AgvInName);
                }

            }
            else
            {
                needLeaveWatch.Stop();
                AgvClient.SetToNone(Config.AgvOutName); 
                needEnterWatch.Stop();
                AgvClient.SetToNone(Config.AgvInName);
            }
        }
        private Stopwatch needEnterWatch = new Stopwatch();
        private Stopwatch needLeaveWatch = new Stopwatch();


        #region 气缸判断及动作 

        public void TopCylinderUp(LineMoveInfo moveinfo = null)
        { 
            CylinderMove(moveinfo, IO_Type.SL_TopCylinder_Down, IO_Type.TopCylinder_Up);
            if (moveinfo != null)
            { 
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_OutTopCylinder_Down, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_OutTopCylinder_Up, IO_VALUE.HIGH));
            }
        }

        public void TopCylinderDown(LineMoveInfo moveinfo = null)
        {
            CylinderMove(moveinfo, IO_Type.SL_TopCylinder_Up, IO_Type.SL_TopCylinder_Down); 
            if (moveinfo != null)
            { 
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_OutTopCylinder_Up, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_OutTopCylinder_Down, IO_VALUE.HIGH));
            }
        } 

        public void LocationCylinderUp(LineMoveInfo moveinfo = null)
        {
            IOMove(IO_Type.SL_LocationCylinder_Down, IO_VALUE.LOW);
            IOMove(IO_Type.SL_LocationCylinder_Up, IO_VALUE.HIGH);
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Down1, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Up1, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Down2, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Up2, IO_VALUE.HIGH));
            }
        }

        public void LocationCylinderDown(LineMoveInfo moveinfo = null)
        {
            IOMove(IO_Type.SL_LocationCylinder_Up, IO_VALUE.LOW);
            IOMove(IO_Type.SL_LocationCylinder_Down, IO_VALUE.HIGH);
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Up1, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Down1, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Up2, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_LocationCylinder_Down2, IO_VALUE.HIGH));
            }
        } 
        public void FixedCylinderUp(LineMoveInfo moveinfo = null)
        {
            IOMove(IO_Type.SL_FixedCylinder_Down, IO_VALUE.LOW);
            IOMove(IO_Type.SL_FixedCylinder_Up, IO_VALUE.HIGH);
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_FixedCylinder_Up1, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_FixedCylinder_Up2, IO_VALUE.HIGH));
            }
        }

        public void FixedCylinderDown(LineMoveInfo moveinfo = null)
        {
            IOMove(IO_Type.SL_FixedCylinder_Up, IO_VALUE.LOW);
            IOMove(IO_Type.SL_FixedCylinder_Down, IO_VALUE.HIGH);
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_FixedCylinder_Up1, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_FixedCylinder_Up2, IO_VALUE.LOW));
            } 
        }

        public void TrayLCylinderBefore(LineMoveInfo moveinfo = null)
        {
            IOMove(IO_Type.SL_TrayLocation_After, IO_VALUE.LOW);
            IOMove(IO_Type.SL_TrayLocation_Before, IO_VALUE.HIGH);
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation1_After, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation1_Before, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation2_After, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation2_Before, IO_VALUE.HIGH));
            }
        }
       
        public void TrayLCylinderAfter(LineMoveInfo moveinfo = null)
        {
            if (TrayLCylinderCanAfter())
            {
                IOMove(IO_Type.SL_TrayLocation_After, IO_VALUE.HIGH);
                IOMove(IO_Type.SL_TrayLocation_Before, IO_VALUE.LOW);
            }
            else
            {
                if (IOValue(IO_Type.SL_TrayLocation1_After).Equals(IO_VALUE.HIGH) &&
                    IOValue(IO_Type.SL_TrayLocation1_Before).Equals(IO_VALUE.LOW) &&
                    IOValue(IO_Type.SL_TrayLocation2_After).Equals(IO_VALUE.HIGH) &&
                    IOValue(IO_Type.SL_TrayLocation2_Before).Equals(IO_VALUE.LOW))
                {

                }
                else
                {
                    WarnMsg = Name + "TrayLCylinderAfter：提升轴当前不在下降位置P2，不后退定位气缸";
                    Alarm(LineAlarmType.IoSingleTimeOut);
                    LogUtil.error(Name + "TrayLCylinderAfter：提升轴当前不在下降位置P2，不后退定位气缸");
                }
            }
            if (moveinfo != null)
            {
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation1_After, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation1_Before, IO_VALUE.LOW));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation2_After, IO_VALUE.HIGH));
                moveinfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SL_TrayLocation2_Before, IO_VALUE.LOW));
            }
        }

        public bool TrayLCylinderCanAfter()
        {
            int currP = BatchAxis.GetAclPosition();
            int chaz = Config.BatchAxisP2 - currP;
            if ((Math.Abs(chaz) < Math.Abs(Config.Height_ChangeValue * 2)))
            {
                return true;
            }
            return false;
        }
 
        public bool IsTrayLCylinderAfter()
        { 
            if (IOValue(IO_Type.SL_TrayLocation1_After).Equals(IO_VALUE.HIGH) &&
                IOValue(IO_Type.SL_TrayLocation1_Before).Equals(IO_VALUE.LOW) &&
                IOValue(IO_Type.SL_TrayLocation2_After).Equals(IO_VALUE.HIGH) &&
                IOValue(IO_Type.SL_TrayLocation2_Before).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            return false;
        }

        public bool IsFixedCylinderUp()
        { 
            if (IOValue(IO_Type.SL_FixedCylinder_Up1).Equals(IO_VALUE.HIGH) &&
                IOValue(IO_Type.SL_FixedCylinder_Up2).Equals(IO_VALUE.HIGH))
            {
                return true;
            }
            return false;
        }

 
        public bool UpdownIsInP1()
        {
            if (UpdownAxis.IsInPosition(Config.UpDownAxisP1))
            {
                return true;
            }
            return false;
        }


        #endregion

        #region 提升轴匀速上升处理 
        private System.Timers.Timer axisCheckTimer = null;
        private string TargetIoType = IO_Type.SL_AxisLocationCheck;
        private IO_VALUE TargetIoValue = IO_VALUE.HIGH;
        private bool BatchAxisStartCheck(string targetIo = "", IO_VALUE value = IO_VALUE.HIGH)
        {
            if (String.IsNullOrEmpty(targetIo))
            {
                targetIo = IO_Type.SL_AxisLocationCheck;
            }
            if (axisCheckTimer == null)
            {
                axisCheckTimer = new System.Timers.Timer();
                axisCheckTimer.AutoReset = true;
                axisCheckTimer.Interval += 30;
                axisCheckTimer.Elapsed += CheckTimer_Elapsed;
                axisCheckTimer.Enabled = false;
            }
            TargetIoValue = value;
            TargetIoType = targetIo;
            axisCheckTimer.Start();
            return true;
        }

        private bool BatchAxisStopCheck()
        {
            if (!(axisCheckTimer == null))
            {
                axisCheckTimer.Stop();
            }
            return true;
        }
        private bool IsInProcess = false;
        private DateTime lastOkTime = DateTime.Now;
        private void CheckTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            TimeSpan pan = DateTime.Now - lastOkTime;
            if (IsInProcess && pan.TotalMilliseconds < 300) { return; }
            try
            {

                IsInProcess = true;
                lastOkTime = DateTime.Now;
                if (IOValue(TargetIoType).Equals(TargetIoValue))
                {
                    LogUtil.info(Name + "上料轴，检测到 " + TargetIoType + "=" + TargetIoValue + "，停止运动");
                    BatchAxis.SuddenStop();
                    BatchAxisStopCheck();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("CheckTimer_Elapsed出错：", ex);
            }
            finally
            {
                IsInProcess = false;
            }
        }


        #endregion

        #region AGV 
      
        internal void AgvArrive(string nodeId, string rfid)
        {
            string logN = Name + "收到 AgvArrive 事件 [" + nodeId + "] [" + rfid + "] ";
            if (nodeId.Equals(Config.AgvInName))
            {
            }
            else if (nodeId.Equals(Config.AgvOutName))
            {
            }
            LogUtil.info(logN + "：" + "暂无处理");
        }

        internal void AgvReady(string nodeId, string rfid)
        {
            string logN = Name + "收到 AgvReady 事件 [" + nodeId + "] [" + rfid + "] ";

            if (nodeId.Equals(Config.AgvInName))
            {
                if (IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.HIGH))
                {
                    LogUtil.info(logN + " ，入口有料架，暂不处理，重置 [" + nodeId + "] 状态为None");
                    AgvClient.SetStatus(nodeId);
                    return;
                }
                ShelfEnterProcess();

            }
            else if (nodeId.Equals(Config.AgvOutName))
            {
                if (IOValue(IO_Type.SL_Out_Check).Equals(IO_VALUE.LOW))
                {
                    LogUtil.info(logN + " ，未检测到出口有料架，暂不处理，重置 [" + nodeId + "] 状态为None");
                    AgvClient.SetStatus(nodeId);
                    return;
                }
                ShelfOutProcess();
            }
        }
        private bool ProcessShelfEnter = false;
        private bool ProcessShelfOut = false;

        internal void ShelfOutProcess()
        {
            //AGV已到达，将料架送入AGV中
            Task.Factory.StartNew(delegate
            {
                string logName = Name + "[" + Config.AgvOutName + "] 料架送入AGV ";
                try
                {
                    LogUtil.info(logName + "开始，先设置状态为None");
                    AgvClient.SetStatus(Config.AgvOutName, LastOutShelfId, ClientAction.None, ClientLevel.High, true);
                    if (IOValue(IO_Type.SL_Out_Check).Equals(IO_VALUE.HIGH))
                    {
                        //    AgvClient.SetStatus(Config.AgvOutName,"",ClientAction.MayLeave,ClientLevel.High);
                        ProcessShelfOut = true;
                        //出口阻挡下降，出口线体转动 
                        IOMove(IO_Type.SL_Out_StopDown, IO_VALUE.HIGH);
                        IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.HIGH);

                        bool result = WaitIo(IO_Type.SL_Out_Check, IO_VALUE.LOW, 60000);
                        if (!result)
                        {
                            LogUtil.info(logName + "  等待SL_Out_Check=LOW超时，等待8000后停止转动，发送FinishLeave");
                        }
                        else
                        {
                            LogUtil.info(logName + "  已收到SL_Out_Check=LOW ，等待8000后停止转动，发送FinishLeave");
                        }
                        //再转动2000
                        Thread.Sleep(8000);
                        //停止转动 ,阻挡上升
                        IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.LOW);
                        IOMove(IO_Type.SL_Out_StopDown, IO_VALUE.LOW);
                        AgvClient.SetStatus(Config.AgvOutName, LastOutShelfId, ClientAction.FinishLeave, ClientLevel.High, true);

                        Thread.Sleep(1000);
                        AgvClient.SetStatus(Config.AgvOutName, "", ClientAction.None, ClientLevel.High, true);

                        ProcessShelfOut = false;
                        LogUtil.info(logName + ",停止转动，清空料架[" + LastOutShelfId + "]，  结束");
                    }
                    else
                    {
                        LogUtil.info(logName + "开始，未检测到料架信号，不处理");
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + " 超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + " 出错：", ex);
                }
                finally
                {
                    IOMove(IO_Type.SL_OutSideWay_Run, IO_VALUE.LOW);
                    ProcessShelfOut = false;
                }
            });
        }
        internal void ShelfEnterProcess()
        { 
            Task.Factory.StartNew(delegate
            {
                string logName = Name + "AGV料架进入 [" + Config.AgvInName + "] ";
                try
                {
                    if (IOValue(IO_Type.SL_Entry_Check).Equals(IO_VALUE.LOW))
                    {
                        LogUtil.info(logName + "   开始");
                        //AgvClient.SetStatus(Config.AgvInName,"",ClientAction.MayEnter,ClientLevel.High);
                        ProcessShelfEnter = true;
                        ////进料阻挡上升
                        //IOMove(IO_Type.SL_Entry_StopDown, IO_VALUE.LOW);

                        //转动线体
                        IOMove(IO_Type.SL_Line_Run, IO_VALUE.HIGH);

                        //等待进料检测信号
                        bool result = WaitIo(IO_Type.SL_Entry_Check, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.info(logName + " 等待 SL_Entry_Check=High 超时， 等待 SL_Stop_Check 信号");
                        }
                        else
                        {
                            LogUtil.info(logName + "已收到 SL_Entry_Check=High ， 等待 SL_Stop_Check 信号");
                        }
                        result = WaitIo(IO_Type.SL_Stop_Check, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.info(logName + " 等待 SL_Stop_Check=High 超时，等待3000后停止转动，发送  FinishEnter");
                        }
                        else
                        {
                            LogUtil.info(logName + "已收到 SL_Stop_Check=High ，等待5000后停止转动，发送   FinishEnter");
                        }
                        //等待200毫秒后停止转动
                        Thread.Sleep(5000);
                        if (MoveInfo.IsStep(LineMoveStep.FI_05_LineStart))
                        {
                            LogUtil.info(logName + " 等待5000后, MoveInfo.MoveType= FI_03_LineStart  不需要停止链条转动");
                        }
                        else
                        {
                            LogUtil.info(logName + "等待5000后，停止链条转动");
                            IOMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
                        }
                        //料架可离开
                        AgvClient.SetStatus(Config.AgvInName, "", ClientAction.FinishEnter, ClientLevel.High, true);

                        Thread.Sleep(1000);
                        AgvClient.SetStatus(Config.AgvInName, "", ClientAction.None, ClientLevel.High, true);
                        ProcessShelfEnter = false;
                        LogUtil.info(logName + "   结束");
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + "  超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + "   出错：", ex);
                }
                finally
                {
                    IOMove(IO_Type.SL_Line_Run, IO_VALUE.LOW);
                    ProcessShelfEnter = false;
                }
            });
        }

        private bool ReadShelfId()
        {
            try
            {
                //判断料架的编码是否正确
                RFIDData rfidD = RFIDManager.GetShelfId(DeviceID);
                CurrShelfId = rfidD.NumStr();

                //发送料架信息给调度系统
                //  AgvClient.SendRFID(Config.AgvInName, CurrShelfId);
                LogUtil.info(Name + "读取到料架编号：" + CurrShelfId);
                if (CurrShelfId.EndsWith("00"))
                {
                    string saveShelf = GetShelfID();
                    if ((!String.IsNullOrEmpty(saveShelf)) && (!saveShelf.EndsWith("00")))
                    {
                        LogUtil.info(Name + "读取到的料架号【" + CurrShelfId + "】无效，使用 缓存料架RFID：" + saveShelf);
                        CurrShelfId = saveShelf;
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "UpdateShelfId出错：", ex);
            }
            return true;
        }

        #region 料架号保存

        private void UpdateLastShelfID(string currRfid = "")
        {
            string configStr = Setting_Init.Feed_LastShelfID_ + DeviceID;
            ConfigAppSettings.SaveValue(configStr, currRfid);
            LogUtil.info(Name + " UpdateLastShelfID 缓存料架RFID更改：【" + configStr + "】=【" + currRfid + "】");
        }
        private string GetShelfID()
        {
            string configStr = Setting_Init.Feed_LastShelfID_ + DeviceID;
            return ConfigAppSettings.GetValue(configStr);
        }

        #endregion
        #endregion

        private string lastcode = "";
        public override string GetMoveStr()
        {
            string msg = "";
            int tLength = 15;
            string leftTask = "";
            if (taskData != null)
            {
                leftTask = "剩余任务：" + taskData.ToStr();
            }
            msg += "料架：" + CurrShelfId   + "    "+leftTask + "\r\n";
            if (LastOutParam.rfid != "")
            {
                msg += "出库信息：" + LastOutParam.ToShortStr() + "\r\n";
            }

            msg += "当前托盘：" + currTrayNum + "  上个托盘：" + preTrayNum + "\n";
            msg += "runS：  " + runStatus + "\n"; 
            msg += "alarm：  " + alarmType + "\n";
            msg += "MoveT：" + MoveInfo.MoveType + " "  + MoveInfo.SLog + "\n"; 
            return msg;
        }
        public string GetLastTrayInfo()
        {
            return   "" + LastWidth + "X" + LastHeight + "=" + lastcode + "";
        }
    }
}