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

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 流水线自动料仓-出料装置类
    /// </summary>
    public partial class DischargeLine : EquipBase
    {
        public int Line3MaxPosition = 13;
        public DischargeLine_Config Config;
        public OutTrayLineBean TrayLine1 = null;
        public OutTrayLineBean TrayLine2 = null;

        private StationTrayInfo StationInfo_Scan = new StationTrayInfo();
        private StationTrayInfo StationInfo_NG = new StationTrayInfo(IO_VALUE.HIGH);
        private StationTrayInfo StationInfo_Move = new StationTrayInfo();
        private bool IsInScanCode = false;
        private bool IsNewType = false;

        internal LineTurnBean Line3Turn = null;
        //皮带线3最后一盘料的位置
        public int Line3LastTrayP = 0;
        private string hengyiName = "皮带线_1";
        public DischargeLine(string cid, DischargeLine_Config config)
        {
            baseConfig = config;
            this.DeviceID = config.Id;
            this.Config = config;
            IsDebug = config.IsDebug.Equals(1);
            baseConfig = config;
            Name = (" " + "_皮带线_" + (DeviceID.Equals(301) ? "123" : "456") + " ").ToUpper();
            Init();
            UseAxis = false;
            int id = DeviceID % 100;
            hengyiName = "皮带线_" + ((id - 1) * 3 + 3) + " ";
            MoveInfo = new LineMoveInfo(DeviceID, "[" + hengyiName + "-Move]");
            SecondMoveInfo = new LineMoveInfo(DeviceID, "[" + hengyiName + "-SMove]");
            if (id.Equals(1))
            {
                IsNewType = true;
                TrayLine1 = new OutTrayLineBean(330 + ((id - 1) * 3 + 1) , "皮带线" + "_" + ((id - 1) * 3 + 1) + " ",  IO_Type.ExitLocation_Check1, IO_Type.ExitTray_Check1, IO_Type.DLine_Run1, IO_Type.EntryTray_Check3, this.DeviceID);
                TrayLine2 = new OutTrayLineBean(330 + ((id - 1) * 3 + 2),"皮带线" + "_" + ((id - 1) * 3 + 2) + " ",  IO_Type.ExitLocation_Check2, IO_Type.ExitTray_Check2, IO_Type.DLine_Run2, IO_Type.MiddleTray_Check3, this.DeviceID);
            }
            else
            {
                IsNewType = true;
                TrayLine1 = new OutTrayLineBean(330+ ((id - 1) * 3 + 1),"皮带线" + "_" + ((id - 1) * 3 + 1) + " ",  IO_Type.ExitLocation_Check1, IO_Type.ExitTray_Check1, IO_Type.DLine_Run1, IO_Type.MiddleTray_Check3, this.DeviceID);
                TrayLine2 = new OutTrayLineBean(330+((id - 1) * 3 + 2),"皮带线" + "_" + ((id - 1) * 3 + 2) + " ",  IO_Type.ExitLocation_Check2, IO_Type.ExitTray_Check2, IO_Type.DLine_Run2, IO_Type.EntryTray_Check3, this.DeviceID);
            }
            Line3Turn = new LineTurnBean(DeviceID);
            if ((DeviceID % 100).Equals(1))
            {
                Line3MaxPosition = 13;
            }
            else
            {
                Line3MaxPosition = 22;
            }
            TimerMaxSeconds = 3;
        }

        /// <summary>
        /// 开始运行
        /// </summary>
        public override bool StartRun(bool isDebug = false)
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            if (IOValue(IO_Type.DLine_SuddenStop).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg(Name + "启动失败：急停未开");
                return false;
            }
            StationInfo_Move = new StationTrayInfo();
            StationInfo_NG = new StationTrayInfo();
            StationInfo_Scan = new StationTrayInfo();
            mainTimer.Stop();
            MoveInfo.EndMove();
            SecondMoveInfo.EndMove();
            lineStatus = LineStatus.StoreOnline;
            runStatus = LineRunStatus.HomeMoving;
            MoveInfo.NewMove(LineMoveType.ReturnHome);
           
            StartReset();
            if (isDebug)
            {
                mainTimer.Enabled = true;
            }
            return true;
        }

        /// <summary>
        /// 出料装置重置
        /// </summary>
        public override bool Reset()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            if (IOValue(IO_Type.DLine_SuddenStop).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg(Name + "复位失败：急停未开");
                return false;
            }
            StopMove();
            runStatus = LineRunStatus.Reset;
            MoveInfo.NewMove(LineMoveType.Reset);
            StartReset();
            return true;
        }
        private void StartReset()
        {
            LogInfo("StartReset： 重置灯状态，关闭所有皮带线，定位气缸下降   开始；");

            //复位时默认为有托盘
            IsInScanCode = false;
            TrayLine1.LastTrayPosition = 1;
            TrayLine2.LastTrayPosition = 1;
            Line3LastTrayP = 1;
            ResetClearData(); 
            lineStatus = LineStatus.ResetMove;
            MoveInfo.NextMoveStep(LineMoveStep.DL_R_CylinderDown);
            CylinderMove(null, IO_Type.SeparateDevice_Up, IO_Type.SeparateDevice_Down);
            IOMove(IO_Type.DLine_RunStatus, IO_VALUE.HIGH);
            IOMove(IO_Type.DLine_RunAlarm, IO_VALUE.LOW);


            CheckAndMove(IO_Type.DLine_Run1, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run2, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run3, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SeparateDevice_Run, IO_VALUE.LOW);
            if (DeviceID.Equals(302))
            {
                LogInfo("后退NG气缸，后退扫码NG气缸");
                CylinderMove(MoveInfo, IO_Type.NGCylinder_Before, IO_Type.NGCylinder_After);
            }
            if (IsNewType)
            {
                ScanNgBack(MoveInfo);
            }
            if (IsDebug)
            {
                mainTimer.Start();
            }

            isInPro = false;
        }

        /// <summary>
        /// 复位处理
        /// </summary>
        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            else if (SecondMoveInfo.IsInWait)
            {
                CheckWait(SecondMoveInfo);
            }
            if (!MoveInfo.IsInWait && !SecondMoveInfo.IsInWait)
            {
                switch (MoveInfo.MoveStep)
                {
                    case LineMoveStep.DL_R_CylinderDown:
                        IOMove(IO_Type.SeparateDevice_Run, IO_VALUE.HIGH);
                        LogInfo(MoveInfo.MoveType + "完成，接驳台皮带线常转 ");
                        if (MoveInfo.MoveType.Equals(LineMoveType.ReturnHome))
                        {
                            //启动时，出口定位信号亮，需要主动扫码一次
                            if (IOValue(IO_Type.Location_Check3).Equals(IO_VALUE.HIGH))
                            {
                                LogUtil.info(Name + "启动时长皮带线定位信号亮，触发一次扫码");
                                NewTypeScan(true);
                            }
                            else
                            {

                            }
                        }
                        MoveEndS();
                        SecondMoveInfo.EndMove();
                        break;

                    default: break;
                }
            }
        }

        /// <summary>
        /// 停止运动
        /// </summary>
        internal override void StopMove()
        {
            runStatus = LineRunStatus.Busy;
            MoveInfo.EndMove();
            SecondMoveInfo.EndMove();

            TrayLine1.StopRun();
            TrayLine2.StopRun();
            Line3Turn.StopLineRun();

            LogInfo("停止运动：（定位气缸下降，皮带线停转 ）开始 ");
            CylinderMove(null, IO_Type.SeparateDevice_Up, IO_Type.SeparateDevice_Down);

            CheckAndMove(IO_Type.DLine_Run1, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run2, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run3, IO_VALUE.LOW);
            //  CheckAndMove(IO_Type.SeparateDevice_Run, IO_VALUE.LOW);
            SeparateStopRun();
        }

        /// <summary>
        /// 停止运行
        /// </summary>
        public override void StopRun()
        {
            if (mainTimer != null)
            {
                mainTimer.Enabled = false;
            }
            StopMove();
            //停止运行时，把所有IO 置零
            CheckAndMove(IO_Type.DLine_RunStatus, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_RunAlarm, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run1, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run2, IO_VALUE.LOW);
            CheckAndMove(IO_Type.DLine_Run3, IO_VALUE.LOW);
            //   CheckAndMove(IO_Type.SeparateDevice_Run, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SeparateDevice_Up, IO_VALUE.LOW);
            CheckAndMove(IO_Type.SeparateDevice_Down, IO_VALUE.LOW);
            runStatus = LineRunStatus.Wait;
        }

        protected override void BaseTimerProcess()
        {
            if (IOValue(IO_Type.DLine_SuddenStop).Equals(IO_VALUE.LOW))
            {
                LogUtil.error(Name + "收到急停信号，等待300后再次验证急停");
                Task.Factory.StartNew(delegate
                {
                    Thread.Sleep(300);
                    if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                    {
                        SetWarnMsg(Name + "收到急停信号，急停报警");
                        Alarm(LineAlarmType.SuddenStop);
                        return;
                    }
                });
            }

            if (IOValue(IO_Type.DLine_Reset).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();

            if (TrayLine1.MoveInfo.MoveType.Equals(LineMoveType.OutStore))
            {
                TrayLine1.OutStoreProcess();
            }

            if (TrayLine2.MoveInfo.MoveType.Equals(LineMoveType.OutStore))
            {
                TrayLine2.OutStoreProcess();
            }

            IOTimeOutProcess();
            //判断流水线打开了才可以运行 
            if (runStatus.Equals(LineRunStatus.Runing) && NoErrorAlarm() && MoveInfo.MoveType.Equals(LineMoveType.None) && Line3TurnIsStop() && IOValue(IO_Type.SeparateDevice_Check).Equals(IO_VALUE.LOW))
            {
                if (IsNewType)
                {
                    if (Line3TurnIsStop() && IOValue(IO_Type.SeparateDevice_Check).Equals(IO_VALUE.LOW) && StationInfo_NG.TrayValue.Equals(IO_VALUE.HIGH))
                    {
                        if (ScanIsEnd() || DeviceID.Equals(302))
                        {
                            StartNOutStoreMove(new InOutParam());
                        }
                    }
                }
                else 
                {
                    //皮带线3出口有料,分盘定位装置无料
                    if (Line3TurnIsStop() && IOValue(IO_Type.SeparateDevice_Check).Equals(IO_VALUE.LOW) && StationInfo_NG.TrayValue.Equals(IO_VALUE.HIGH)&& ScanIsEnd())
                    {
                        StartOutStoreMove(new InOutParam());
                    }
                }
            }
            if ((runStatus.Equals(LineRunStatus.Runing) || runStatus.Equals(LineRunStatus.Busy)))
            {
                TrayLine1.TimerPro();
                if (InStoreNgISBack())
                {
                    TrayLine2.TimerPro();
                }

                Line3TimerPro();

                //小皮带线常转

                if (IOValue(IO_Type.SeparateDevice_Run).Equals(IO_VALUE.LOW) && MoveInfo.MoveType.Equals(LineMoveType.None) && NoErrorAlarm())
                {
                    SeparateLineRun();
                }
            }

            //判断红灯状态
            if (NoAlarm())
            {
                IOMove(IO_Type.DLine_RunAlarm, IO_VALUE.LOW);
            }
            else if (IOValue(IO_Type.DLine_RunAlarm).Equals(IO_VALUE.LOW))
            {
                IOMove(IO_Type.DLine_RunAlarm, IO_VALUE.HIGH);
            }

        }
        internal bool InStoreNgISBack()
        {
            if (DeviceID.Equals(302))
            {
                if (IOValue(IO_Type.NGCylinder_After).Equals(IO_VALUE.HIGH) && IOValue(IO_Type.NGCylinder_Before).Equals(IO_VALUE.LOW))
                {
                    return true;
                }
            }
            else
            {
                return true;
            }
            return false;
        }
        internal bool ScanNgIsBack()
        {
            if (IsNewType && IOValue(IO_Type.ScanNGCylinder_Back).Equals(IO_VALUE.LOW))
            {
                return false;
            }
            return true;
        }
        internal bool Line3TurnIsStop()
        {
            if (Line3Turn.InTurn.Equals(false) && NoAlarm())
            {
                if (IOValue(IO_Type.DLine_Run3).Equals(IO_VALUE.LOW))
                {
                    if (Line3Turn.CanStart(500))
                    {
                        return true;
                    }
                }
                else
                {
                    IOMove(IO_Type.DLine_Run3, IO_VALUE.LOW);
                }
            }
            return false;
        }
        private void Line3TimerPro()
        {
            bool ngNoTray = IOValue(IO_Type.ExitTray_Check3).Equals(IO_VALUE.LOW);
            if (IsNewType)
            {
                ngNoTray = StationInfo_NG.TrayValue.Equals(IO_VALUE.LOW);
            }
            //判断皮带线3出口无料，皮带线无操作
            if (
                ScanNgIsBack() &&
                Line3TurnIsStop() &&
                Line3Turn.CanStart() &&
                MoveInfo.MoveType.Equals(LineMoveType.None) &&
                TrayLine1.Line3CanRun &&
                TrayLine2.Line3CanRun &&
                ngNoTray &&
                Line3HasTray()
                  && (ScanIsEnd())
                )
            {
                //判断皮带三还有料盘，需要转动一个工位 
                UpdateLastP();
                LogUtil.debug(hengyiName + "空闲，且流水线还有料盘，转动一个工位");
                Line3Turn.StartLineRun(IO_Type.DLine_Run3, IO_Type.Location_Check3, Line3EndProcess);
            }
        }
        private void UpdateLastP()
        {
            if (IOValue(IO_Type.EntryTray_Check3).Equals(IO_VALUE.HIGH))
            {
                Line3LastTrayP = 1;
            }
            else if (IOValue(IO_Type.MiddleTray_Check3).Equals(IO_VALUE.HIGH))
            {
                if (DeviceID.Equals(301))
                {
                    if (Line3LastTrayP < 1 || Line3LastTrayP > 12)
                    {
                        Line3LastTrayP = 12;
                    }
                }
                else if (DeviceID.Equals(302))
                {
                    if (Line3LastTrayP < 1 || Line3LastTrayP > 11)
                    {
                        Line3LastTrayP = 11;
                    }
                }
            }
        }

        private bool Line3HasTray()
        {
            if (Line3LastTrayP > 0 && Line3LastTrayP <= Line3MaxPosition * 10)
            {
                return true;
            }
            if (IOValue(IO_Type.EntryTray_Check3).Equals(IO_VALUE.HIGH))
            {
                return true;
            }
            if (IOValue(IO_Type.MiddleTray_Check3).Equals(IO_VALUE.HIGH))
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 转动结束，最后一盘料的位置+1
        /// </summary>
        /// <param name="result"></param>
        public void Line3EndProcess(bool result)
        {
            if (result)
            {
                if (Line3LastTrayP > 0)
                {
                    Line3LastTrayP++;
                }
                NewTypeScan();
            }
        }
        private bool ScanIsEnd()
        {
            TimeSpan span = DateTime.Now - LastScanTime;
            if (IsInScanCode && span.TotalMinutes < 1)
            { 
                return false ;
            }
            return true;
        }

        private DateTime LastScanTime = DateTime.Now;
        private void NewTypeScan(bool isfirst = false)
        {
            TimeSpan span = DateTime.Now - LastScanTime;
            if (!ScanIsEnd())
            {
                LogInfo("NewTypeScan return ");
                return;
            }

            IsInScanCode = true;
            LastScanTime=DateTime.Now;
            string LastCode = ""; 
            Task.Factory.StartNew(delegate
            {
                if (isfirst)
                {
                    StationInfo_NG = new StationTrayInfo(IO_VALUE.HIGH);
                }
                else
                {
                    StationInfo_NG = new StationTrayInfo(StationInfo_Scan.TrayValue, StationInfo_Scan.CodeStr);
                }
                Thread.Sleep(300);
                if (IOValue(IO_Type.ExitTray_Check3).Equals(IO_VALUE.LOW))
                {
                    StationInfo_Scan = new StationTrayInfo(IO_VALUE.LOW);
                    if (DeviceID.Equals(301))
                    {
                        StationInfo_NG = new StationTrayInfo(StationInfo_Scan.TrayValue, StationInfo_Scan.CodeStr);
                    }
                    IsInScanCode = false;
                }
                else
                {
                    try
                    {
                        LastCode = "";
                        StationInfo_Scan = new StationTrayInfo(IO_VALUE.HIGH, LastCode);

                        if (DeviceID.Equals(301))
                        {
                            if (Line3LastTrayP > Line3MaxPosition) { Line3LastTrayP = Line3MaxPosition; }
                            StationInfo_NG = new StationTrayInfo(StationInfo_Scan.TrayValue, StationInfo_Scan.CodeStr);
                        }
                        else
                        {
                            if (Line3LastTrayP > Line3MaxPosition - 1)
                            {
                                Line3LastTrayP = Line3MaxPosition - 1;
                            }
                        }
                        LogUtil.info(hengyiName + "扫码工位：开始扫码，IsInScanCode=" + IsInScanCode);
                        List<string> LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), hengyiName);
                        if (LastCodeList.Count <= 0)
                        {
                            LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), hengyiName);
                        }
                        //if (LastCodeList.Count <= 0)
                        //{
                        //    Thread.Sleep(300);
                        //    LastCodeList = CodeManager.CameraScan(Config.GetCameraList(), Name);
                        //}
                        LastCode = SServerManager.ProcessCodeList(LastCodeList);
                            //   Thread.Sleep(5000);
                        }
                    catch (Exception ex)
                    {
                        LogUtil.error(Name + "扫码错误：" + ex.ToString());
                    }
                    finally
                    {
                        StationInfo_Scan = new StationTrayInfo(IO_VALUE.HIGH, LastCode);
                        if (DeviceID.Equals(301))
                        {
                            StationInfo_NG = new StationTrayInfo(StationInfo_Scan.TrayValue, StationInfo_Scan.CodeStr);
                        }
                        IsInScanCode = false;

                        LogUtil.info(hengyiName + " 扫码工位 : 扫码结束 ，" + StationInfo_Scan.ToStr + "  IsInScanCode = " + IsInScanCode);
                    }
                } 
            }); 
        }
        protected override void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 1 && alarmType.Equals(LineAlarmType.IoSingleTimeOut))
                {
                    preIoTimerOutTime = DateTime.Now;

                    if (runStatus < LineRunStatus.Runing || isInSuddenDown || isNoAirCheck)
                    {
                        return;
                    }
                    //若BOX和出料都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    if (MoveInfo.MoveType.Equals(LineMoveType.None) && MoveInfo.IsInWait.Equals(false)
                        && TrayLine1.MoveInfo.MoveType.Equals(LineMoveType.None) && TrayLine1.MoveInfo.IsInWait.Equals(false)
                        && TrayLine2.MoveInfo.MoveType.Equals(LineMoveType.None) && TrayLine2.MoveInfo.IsInWait.Equals(false)
                        )
                    {
                        LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                        alarmType = LineAlarmType.None;
                        SetWarnMsg("");
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("IOTimeOutProcess出错：", ex);
            }
        }
        public override string GetMoveStr()
        {
            string msg = "";
            //     int tLength = 10;
            msg += "runS：" + runStatus + "\n";
            msg += "lineS：" + lineStatus + "\n";
            msg += "alarm：  " + alarmType + "\n";
            msg += "L1-M：" + TrayLine1.MoveInfo.MoveType + "    " + TrayLine1.MoveInfo.MoveStep + "\n";
            msg += "L2-M：" + TrayLine2.MoveInfo.MoveType + "    " + TrayLine2.MoveInfo.MoveStep + "\n";
            msg += "LastTP：" + TrayLine1.LastTrayPosition + "    " + TrayLine2.LastTrayPosition + "    " + Line3LastTrayP + "    " + "\n";
            msg += "LIsRun：" + TrayLine1.IsInTurn() + "    " + TrayLine2.IsInTurn() + "    " + Line3Turn.InTurn + "    " + "\n";
            msg += "L3CanRun：" + TrayLine1.Line3CanRun + "    " + TrayLine2.Line3CanRun + "    " + "\n";
            //msg += "LastWidth：" + LastWidth+"\n";
            //if (IsNewType)
            //{
            msg += "Move：" + MoveInfo.MoveType + "    " + MoveInfo.MoveStep + "    " + LastWidth + "=" + StationInfo_Move.CodeStr + "\n";
            //}
            //else
            //{ 
            //    msg += "Move：" + MoveInfo.MoveType + "    " + MoveInfo.MoveStep + "    " + LastWidth + "=" + StationInfo_Move.CodeStr + "\n";
            //}
            //msg += "NG 工位：" + StationInfo_NG.ToStr + "\n";
            //msg += "扫码工位：" + StationInfo_Scan.ToStr + "\n";
            //msg += "IsInScanCode：" + IsInScanCode;
            //    msg += "LastWidth：" + LastWidth + "\n";

            return msg;
        }
        public override bool StartInStoreMove(InOutParam param)
        {
            return false;
        }
        protected override void InStoreProcess()
        {
        }

        protected override void CheckFixtureProcess()
        {
        }

        public void SeparateLineRun(LineMoveInfo moveInfo = null)
        {
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_Run, IO_VALUE.HIGH));
            }
            if (DeviceID.Equals(301))
            {
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_BackRun, IO_VALUE.LOW));
                }
                IOMove(IO_Type.SeparateDevice_BackRun, IO_VALUE.LOW);
            }
            IOMove(IO_Type.SeparateDevice_Run, IO_VALUE.HIGH);

        }
        public void SeparateBackRun(LineMoveInfo moveInfo = null)
        {
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_Run, IO_VALUE.LOW));
            }
            IOMove(IO_Type.SeparateDevice_Run, IO_VALUE.LOW);
            if (DeviceID.Equals(301))
            {
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_BackRun, IO_VALUE.HIGH));
                }
                IOMove(IO_Type.SeparateDevice_BackRun, IO_VALUE.HIGH);
            }
        }
        public void SeparateStopRun(LineMoveInfo moveInfo = null)
        {
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_Run, IO_VALUE.LOW));
            }
            IOMove(IO_Type.SeparateDevice_Run, IO_VALUE.LOW);
            if (DeviceID.Equals(301))
            {
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SeparateDevice_BackRun, IO_VALUE.LOW));
                }
                IOMove(IO_Type.SeparateDevice_BackRun, IO_VALUE.LOW);
            }
        }
        public void ScanNgForward(LineMoveInfo moveInfo = null)
        {
            if (IsNewType)
            {
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ScanNGCylinder_Back, IO_VALUE.LOW));
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ScanNGCylinder_Forward, IO_VALUE.HIGH));
                }
                IOMove(IO_Type.ScanNGCylinder_Back, IO_VALUE.LOW);
                IOMove(IO_Type.ScanNGCylinder_Forward, IO_VALUE.HIGH);
            }
        }
        public void ScanNgBack(LineMoveInfo moveInfo)
        {
            if (IsNewType)
            {
                if (moveInfo != null)
                {
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ScanNGCylinder_Back, IO_VALUE.HIGH));
                    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.ScanNGCylinder_Forward, IO_VALUE.LOW));
                }
                IOMove(IO_Type.ScanNGCylinder_Forward, IO_VALUE.LOW);
                IOMove(IO_Type.ScanNGCylinder_Back, IO_VALUE.HIGH);
            }
        }
    }

    public class StationTrayInfo
    {
        public StationTrayInfo(IO_VALUE value = IO_VALUE.LOW, string codes = "")
        {
            this.TrayValue = value;
            this.CodeStr = codes;
        }
        public IO_VALUE TrayValue = IO_VALUE.LOW;
        public string CodeStr = "";

        public string ToStr
        {
            get
            {
                return TrayValue + "=" + CodeStr;
            }
        }
    }
}