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

namespace DeviceLibrary
{
    public class WorkStation
    {
        internal MoveInfo MoveInfo = null;
        public string Name = "";
        internal string AgvName = "";
        private string rfidIp = "";
        public ShelfInfo CurrShelf = new ShelfInfo();
        public int StationId = 0;
        public string WarnMsg = "";
        public AlarmType alarmType = AlarmType.None;
        public WorkStation(int id, string name, string agvName, string rfidip)
        {
            this.rfidIp = rfidip;
            MoveInfo = new MoveInfo(1);
            this.Name = "" + name;
            this.AgvName = agvName;
            this.StationId = id;
            Shelf_Back_Check = name + Shelf_Back_Check;
            Shelf_Front_Check = name + Shelf_Front_Check; 
            Moto_Fwd = name + Moto_Fwd;
            Moto_Rwd = name + Moto_Rwd;
            Location_Up = name + Location_Up;
            Location_Down = name + Location_Down;
        }


        internal bool IsReady()
        {
            if (IsDis())
            {
                return false;
            }
            if (!alarmType.Equals(AlarmType.None))
            {
                return false;
            }
            if (CheckShelf(IO_VALUE.HIGH))
            {
                if (!CurrShelf.IsNeedLeave && (!String.IsNullOrEmpty(CurrShelf.rfid)))
                {
                    if (LocationIsUp())
                    {
                        if (WarnMsg.Contains("定位气缸上升不到位"))
                        {
                            WarnMsg = "";
                        }
                        return true;
                    }
                    else
                    {

                        WarnMsg = Name + "定位气缸上升不到位";
                    }
                }
            }
            //料架准备好可以放料
            return false;
        }
        internal bool CheckNeedLeave(bool IsReset = true)
        {
            if (IsDis())
            {
                return false;
            }

            if (CurrShelf.EmptyPos <= 0)
            {
                CurrShelf.IsNeedLeave = true;
                LogUtil.info(Name + "  " + CurrShelf.ToStr() + " 没有空位需要离开 ");
                if (IsReset)
                {
                    Reset();
                }
                return true;
            }
            return false;
        }
        private string ReadShelfId()
        {
            string rfid = RFIDManager.ReadRFID(rfidIp).NumStr();
            CurrShelf = new ShelfInfo(rfid);
            LogUtil.info(Name + "读取料架号：" + CurrShelf.ToStr());
            return CurrShelf.rfid;
        }


        public void Reset()
        {
            if (IsDis())
            {
                alarmType = AlarmType.None;
                WarnMsg = "";
                MoveInfo.EndMove();
                return;
            }
            if (CurrShelf.IsBusy)
            {
                LogUtil.error(Name + "复位失败，料架忙碌中");
                return;
            }
            alarmType = AlarmType.None;
            WarnMsg = "";
            MoveInfo.EndMove();
            MoveInfo.NewMove(StoreMoveType.StoreReset);
            MoveInfo.NextMoveStep(MoveStep.SR_01_LocationDown);
            if (ProcessShelfEnter || ProcessShelfOut)
            {
                LogUtil.info(Name + " 开始复位:顶升下降");
            }
            else
            {
                LogUtil.info(Name + " 开始复位:顶升下降，设置状态为None");
                AgvClient.SetToNone(AgvName);
            }
            LocationDown(MoveInfo);

        }
        private void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }

            if (MoveInfo.IsStep(MoveStep.SR_01_LocationDown))
            {
                if (CheckShelf(IO_VALUE.HIGH))
                {
                    //有料架
                    if (CurrShelf.rfid.Equals("").Equals(false) && CurrShelf.IsNeedLeave)
                    {
                        AgvClient.NeedLeave(AgvName, CurrShelf.rfid);
                        LogUtil.info(Name + "复位：" + CurrShelf.ToStr() + "需要离开，发送NeedLeave");
                        MoveInfo.EndMove();
                    }
                    else
                    {
                        SR_03_LineRunWait();
                    }
                }
                else
                {
                    SR_02_LineRun();
                }
            }
            else if (MoveInfo.IsStep(MoveStep.SR_02_LineRun))
            {
                if (CheckShelf(IO_VALUE.HIGH))
                {
                    SR_03_LineRunWait();
                }
                else if (CheckShelf(IO_VALUE.LOW))
                {
                    ResetEnd();
                }
                else
                {
                    //有一个信号亮，再次转动链条
                    SR_02_LineRun();
                }
            }
            else if (MoveInfo.IsStep(MoveStep.SR_03_LineRunWait))
            {
                if (CheckShelf(IO_VALUE.HIGH))
                {
                    SR_04_LocationUp();
                }
                else if (CheckShelf(IO_VALUE.LOW))
                {
                    ResetEnd();
                }
                else
                {
                    //有一个信号亮，再次转动链条
                    SR_02_LineRun();
                }
            }
            else if (MoveInfo.IsStep(MoveStep.SR_04_LocationUp))
            {
                LineStop();
                if (LocationIsUp())
                {
                    LogUtil.info(Name + "复位：" + CurrShelf.ToStr() + "准备完成，可以放料 ");
                    MoveInfo.EndMove();
                }
                else
                {
                    MoveInfo.NextMoveStep(MoveStep.SR_04_LocationUp);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                    LocationUp(MoveInfo);
                    LogUtil.info(Name + "复位：料架" + CurrShelf.ToStr() + "定位气缸不到位，再次顶升上升 ");
                }
            }
        }
        private void ResetEnd()
        {
            LineStop();
            CurrShelf = new ShelfInfo();
            LogUtil.info(Name + "复位完成，当前无料架");
            MoveInfo.EndMove();
        }
        private void SR_04_LocationUp()
        {
            //MoveInfo.NewMove(StoreMoveType.StoreReset);

            MoveInfo.NextMoveStep(MoveStep.SR_04_LocationUp);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
            ReadShelfId();

            if (CheckNeedLeave(false))
            {
                AgvClient.NeedLeave(AgvName, CurrShelf.rfid);
                LogUtil.info(Name + "复位：当前" + CurrShelf.ToStr() + "需要离开，发送NeedLeave");
                MoveInfo.EndMove();
            }
            else
            {
                //MoveInfo.NextMoveStep(MoveStep.SR_04_LocationUp);
                LocationUp(MoveInfo);
                LogUtil.info(Name + "复位：读取到新料架：" + CurrShelf.ToStr() + "，顶升上升 ");
            }
        }
        private void SR_03_LineRunWait()
        {
            MoveInfo.NextMoveStep(MoveStep.SR_03_LineRunWait);
            LineRun(MoveInfo);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(5000));
            LogUtil.info(Name + "复位： 检测到料架，继续线体转动5秒 ");
        }
        private void SR_02_LineRun()
        {
            MoveInfo.NextMoveStep(MoveStep.SR_02_LineRun);
            LineRun(MoveInfo);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(5000));
            LogUtil.info(Name + "复位： 线体转动5秒 ");
        }
        public bool IsDis()
        {
            if (EquipManager.DisStationList.Contains(StationId))
            {
                return true;
            }
            return false;
        }
        public void TimerProcess()
        {
            if (IsDis())
            {
                return;
            }
            if (MoveInfo.MoveType.Equals(StoreMoveType.StoreReset))
            {
                ResetProcess();
            }
            else
            {
                if (ProcessShelfEnter || ProcessShelfOut)
                {

                }
                else
                {
                    if (CheckShelf(IO_VALUE.HIGH) && (CurrShelf.rfid.Equals("")))
                    {
                        LogUtil.info(Name + "检测到料架信号，但是没有料架号，自动复位");
                        Reset();
                    }
                    else if (CheckShelf(IO_VALUE.LOW) && (!CurrShelf.rfid.Equals("")))
                    {
                        LogUtil.info(Name + "未检测到料架信号，但是有料架号，自动复位");
                        Reset();
                    }
                    else if (IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.HIGH) && (CurrShelf.rfid.Equals("")))
                    {
                        LogUtil.info(Name + "检测到入口料架信号，但是没有料架号，自动复位");
                        Reset();
                    }
                    else
                    {
                        AgvStatusPro();
                    }
                }
            }
        }
        internal bool IsRightShelf(TrayInfo CurrTray, out string ShelfPosId)
        {
            ShelfPosId = "";
            if (IsDis())
            {
                return false;
            }
            if (IsReady())
            {
                if (CurrShelf.rfid.Equals(CurrTray.realRFID))
                {
                    if (String.IsNullOrEmpty(CurrShelf.XNShelf))
                    {
                        CurrShelf.XNShelf = CurrTray.rfid;
                        LogUtil.info(Name + "增加虚拟料架号绑定：" + CurrShelf.ToStr());
                    }
                    ShelfPosId = Name + CurrTray.shelfP;
                    return true;
                }
                else if (String.IsNullOrEmpty(CurrTray.realRFID))
                {
                    if ((!CurrShelf.XNShelf.Equals("")) && CurrShelf.XNShelf.Equals(CurrTray.rfid))
                    {
                        CurrTray.realRFID = CurrShelf.rfid;
                        ShelfPosId = Name + CurrTray.shelfP;
                        return true;
                    }
                    if (!String.IsNullOrEmpty(CurrTray.usedRfidList))
                    {
                        string[] array = CurrTray.usedRfidList.Split(',');
                        //若料架已使用过，直接返回false
                        if (array.Contains(CurrShelf.rfid))
                        {
                            return false;
                        }
                    }
                    if (CurrShelf.XNShelf.Equals(""))
                    {
                        CurrShelf.XNShelf = CurrTray.rfid;
                        CurrTray.realRFID = CurrShelf.rfid;
                        LogUtil.info(Name + "增加虚拟料架号绑定：" + CurrShelf.ToStr());
                        ShelfPosId = Name + CurrTray.shelfP;
                        return true;
                    }
                }
            }

            return false;
        }

        #region 出料结果验证

        private DateTime preRWTime = DateTime.Now;
        public void CheckWait(MoveInfo checkmove)
        {
            List<WaitResultInfo> list = checkmove.WaitList;
            //当等待超过一分钟时，需要打印提示 
            TimeSpan span = DateTime.Now - checkmove.LastSetpTime;
            string NotOkMsg = "";
            if (list.Count <= 0)
            {
                checkmove.EndStepWait();
                return;
            }
            bool isOk = true;
            if (checkmove.OneWaitCanEndStep)
            {
                isOk = false;
            }
            foreach (WaitResultInfo wait in list)
            {
                if (wait.IsEnd)
                {
                    continue;
                }
                NotOkMsg = wait.ToStr();
                if (wait.WaitType == 1)
                {
                }
                else if (wait.WaitType == 2)
                {
                    wait.IsEnd = IOManager.IOValue(wait.IoType).Equals(wait.IoValue);
                    int timeOutMs = EquipManager.Equip.Config.IOSingle_TimerOut;

                    if ((!wait.IsEnd) && span.TotalMilliseconds > timeOutMs)
                    {
                        ConfigIO io = EquipManager.Equip.Config.getWaitIO(wait.IoType);
                        WarnMsg = Name + "[" + checkmove.MoveType + "][" + checkmove.MoveStep + "] 等待" + io.DisplayStr + "=" + wait.IoValue + "超时 ";

                        alarmType = AlarmType.IoSingleTimeOut;
                        LogUtil.error(Name + wait.IoType + "等待信号(" + io.DisplayStr + "=" + wait.IoValue + ") 超时", 14);
                        isOk = false;
                        break;
                    }


                    TimeSpan rwSpan = DateTime.Now - preRWTime;
                    if (!wait.IsEnd && rwSpan.TotalSeconds > 5 && span.TotalSeconds > 6)
                    {
                        preRWTime = DateTime.Now;
                        string msg = Name + "  " + NotOkMsg + "已等待 " + Math.Abs(span.TotalSeconds) + "秒，重写DO：";
                        bool isLog = false;
                        foreach (WaitResultInfo ww in list)
                        {
                            if (ww != null && ww.WaitType.Equals(2) && EquipManager.Equip.Config.DOList.ContainsKey(ww.IoType))
                            {
                                isLog = true;
                                EquipManager.Equip.IOMove(ww.IoType, ww.IoValue);
                                msg += ww.ToStr() + "，";
                            }
                        }
                        if (isLog)
                        {
                            LogUtil.error(msg);
                        }
                        isOk = false;
                        break;
                    }
                }
                else if (wait.WaitType == 3)
                {
                    wait.IsEnd = (span.TotalMilliseconds >= wait.TimeMSeconds);
                }

                if (wait.IsEnd)
                {
                    if (checkmove.OneWaitCanEndStep)
                    {
                        isOk = true;
                        break;
                    }
                }
                else
                {
                    if (!checkmove.OneWaitCanEndStep)
                    {
                        isOk = false;
                        break;
                    }
                }
            }
            if (isOk)
            {
                checkmove.EndStepWait();
            }
            else if (span.TotalSeconds > checkmove.TimeOutSeconds)
            {
                WarnMsg = Name + "[" + checkmove.MoveType + "][" + checkmove.MoveStep + "] 等待超时  [" + NotOkMsg
                    + "]已等待[" + Math.Round(span.TotalSeconds, 1) + "]秒";

                LogUtil.error(WarnMsg, 100);
                alarmType = AlarmType.IoSingleTimeOut;
            }
        }
        private static DateTime lastComRHomeTime = DateTime.Now;


        #endregion

        #region AGV 


        #region AGV状态处理


        private void AgvStatusPro()
        {
            if (IsReady())
            {
                if (CheckNeedLeave())
                {
                    return;
                }
                AgvClient.SetToNone(AgvName);
            }
            else if (CurrShelf.rfid.Equals("") && IOManager.IOValue(Shelf_Back_Check).Equals(IO_VALUE.LOW) && IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.LOW))
            {
                if (LocationIsDown())
                {
                    AgvClient.NeedEnter(AgvName, "");
                }
                else
                {
                    LocationDown();
                    AgvClient.SetToNone(AgvName);
                }
            }
            else if (IOManager.IOValue(Shelf_Back_Check).Equals(IO_VALUE.HIGH) && IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.HIGH) && CurrShelf.IsNeedLeave)
            {
                if (LocationIsDown())
                {
                    AgvClient.NeedLeave(AgvName, CurrShelf.rfid);
                }
                else
                {
                    LocationDown();
                    AgvClient.SetToNone(AgvName);
                }
            }
            else
            {
                AgvClient.SetToNone(AgvName);
            }
        }

        #endregion

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

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

            if (nodeId.Equals(AgvName))
            {
                if (IOManager.IOValue(Shelf_Back_Check).Equals(IO_VALUE.HIGH) || IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.HIGH))
                {
                    LogUtil.info(logN + " ，已有料架，暂不处理，重置 [" + nodeId + "] 状态为None");
                    AgvClient.SetStatus(nodeId);
                    return;
                }
                ShelfEnterProcess();
            }
        }
        internal void AgvReadyLeave(string nodeId, string rfid = "")
        {
            string logN = Name + "收到 AgvReady 事件 [" + nodeId + "] [" + rfid + "] ";

            if (nodeId.Equals(AgvName))
            {
                if (IOManager.IOValue(Shelf_Back_Check).Equals(IO_VALUE.LOW) && IOManager.IOValue(Shelf_Front_Check).Equals(IO_VALUE.LOW))
                {
                    LogUtil.info(logN + " ，未检测到料架，暂不处理，重置 [" + nodeId + "] 状态为None");
                    AgvClient.SetStatus(nodeId);
                    return;
                }
                ShelfLeaveProcess();
            }
        }
        private bool ProcessShelfEnter = false;
        private bool ProcessShelfOut = false;

        internal void ShelfLeaveProcess()
        {
            //AGV已到达，将料架送入AGV中
            Task.Factory.StartNew(delegate
            {
                string logName = Name + "[" + AgvName + "] 料架送入AGV ";
                try
                {
                    LogUtil.info(logName + "开始，先设置状态为 MayLeave");
                    //AgvClient.SetStatus(AgvName, CurrShelf.rfid, ClientAction.None, ClientLevel.High);
                    AgvClient.SetStatus(AgvName, CurrShelf.rfid, ClientAction.MayLeave, ClientLevel.High);

                    ProcessShelfOut = true;
                    LineBackRun();

                    bool result = WaitIo(Shelf_Back_Check, IO_VALUE.LOW, 60000);
                    if (!result)
                    {
                        LogUtil.info(logName + "  等待 " + Shelf_Back_Check + "=LOW超时，等待60000后停止线体转动，发送FinishLeave");
                    }
                    else
                    {
                        LogUtil.info(logName + "  已收到" + Shelf_Back_Check + "=LOW ，等待60000后停止线体转动，发送FinishLeave");
                    }
                    result = WaitIo(Shelf_Front_Check, IO_VALUE.LOW, 60000);
                    if (!result)
                    {
                        LogUtil.info(logName + "  等待 " + Shelf_Front_Check + "=LOW超时，等待60000后停止线体转动，发送FinishLeave");
                    }
                    else
                    {
                        LogUtil.info(logName + "  已收到" + Shelf_Front_Check + "=LOW ，等待60000后停止线体转动，发送FinishLeave");
                    }
                    Thread.Sleep(8000);
                    LineStop();
                    AgvClient.SetStatus(AgvName, CurrShelf.rfid, ClientAction.FinishLeave, ClientLevel.High);

                    Thread.Sleep(2000);
                    AgvClient.SetStatus(AgvName, "", ClientAction.None, ClientLevel.High);

                    ProcessShelfOut = false;
                    LogUtil.info(logName + ",停止转动，清空" + CurrShelf.ToStr() + "，  结束");
                    CurrShelf = new ShelfInfo();

                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + " 超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + " 出错：", ex);
                }
                finally
                {
                    AgvClient.SetStatus(AgvName, "", ClientAction.None, ClientLevel.High);
                    LineStop();
                    ProcessShelfOut = false;
                }
            });
        }
        internal void ShelfEnterProcess()
        {
            Task.Factory.StartNew(delegate
            {
                string logName = Name + "AGV料架进入 [" + AgvName + "] ";
                try
                {
                    CurrShelf = new ShelfInfo();
                    LogUtil.info(logName + "   开始，清空料架信息，设置状态=MayEnter");
                    AgvClient.SetStatus(AgvName, "", ClientAction.MayEnter, ClientLevel.High, true);
                    ProcessShelfEnter = true;

                    LineRun();
                    bool result = false;

                    //等待进料检测信号
                    result = WaitIo(Shelf_Front_Check, IO_VALUE.HIGH, 600000, logName + "等待" + Shelf_Front_Check + "信号");

                    LogUtil.info(logName + " 等待 " + Shelf_Front_Check + "=High 结果： " + result + "， 开始等待 " + Shelf_Back_Check + " 信号");

                    result = WaitIo(Shelf_Back_Check, IO_VALUE.HIGH, 600000, logName + "等待" + Shelf_Back_Check + "信号");

                    //LogUtil.info(logName + " 等待  " + Shelf_Back_Check + "=High 结果： " + result + "，开始等待 FinishEnter 超时10分钟");
                    //try
                    //{
                    //    result = WaitUtil.Wait(600000, delegate ()
                    //    {
                    //        return AgvClient.GetAction(AgvName).Equals(ClientAction.FinishEnter);
                    //    }, logName + "等待FinishEnter超时");
                    //}
                    //catch (TimeoutException te)
                    //{
                    //    LogUtil.error(logName + "  超时：" + te);
                    //}
                    LogUtil.info(logName + "，完成，信号已到位");
                    LineStop();
                    Thread.Sleep(2000);
                    AgvClient.SetStatus(AgvName, "", ClientAction.None, ClientLevel.High, true);
                    ProcessShelfEnter = false;
                    Reset();

                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + "  超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + "   出错：", ex);
                }
                finally
                {
                    AgvClient.SetStatus(AgvName, "", ClientAction.None, ClientLevel.High, true);
                    LineStop();
                    ProcessShelfEnter = false;
                }
            });
        }


        #endregion


        #region IO操作

        private bool CheckShelf(IO_VALUE value)
        {
            if (IOManager.IOValue(Shelf_Back_Check).Equals(value) && IOManager.IOValue(Shelf_Front_Check).Equals(value))
            {
                return true;
            }
            return false;
        }

        protected bool WaitIo(string ioType, IO_VALUE value, int timeOut, string errName = "")
        {
            try
            {
                return WaitUtil.Wait(timeOut, delegate ()
                {
                    return value.Equals(IOManager.IOValue(ioType));
                }, errName);
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "等待" + ioType + "=" + value + "超时：" + ex.ToString());
                return false;
            }
        }


        public void LineRun(MoveInfo moveInfo = null)
        {
            EquipManager.Equip.CylinderMove(Moto_Rwd, Moto_Fwd, moveInfo);
        }
        public void LineBackRun(MoveInfo moveInfo = null)
        {
            EquipManager.Equip.CylinderMove(Moto_Fwd, Moto_Rwd, moveInfo);
        }
        public void LineStop(MoveInfo moveInfo = null)
        {
            IOManager.IOMove(Moto_Fwd, IO_VALUE.LOW);
            IOManager.IOMove(Moto_Rwd, IO_VALUE.LOW);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Moto_Fwd, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Moto_Rwd, IO_VALUE.LOW));
            }
        }
        public void LocationDown(MoveInfo moveInfo = null)
        {
            IOManager.IOMove(Location_Up, IO_VALUE.LOW);
            IOManager.IOMove(Location_Down, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Up1, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Down1, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Up2, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Down2, IO_VALUE.HIGH));
            }
        }
        public void LocationUp(MoveInfo moveInfo = null)
        {
            IOManager.IOMove(Location_Down, IO_VALUE.LOW);
            IOManager.IOMove(Location_Up, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Down1, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Up1, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Down2, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_LocationCylinder_Up2, IO_VALUE.HIGH));
            }
        }

        public bool LocationIsDown()
        {
            if (IOManager.IOValue(DI_LocationCylinder_Up1).Equals(IO_VALUE.LOW) &&
                    IOManager.IOValue(DI_LocationCylinder_Down1).Equals(IO_VALUE.HIGH) &&
                    IOManager.IOValue(DI_LocationCylinder_Up2).Equals(IO_VALUE.LOW) &&
                    IOManager.IOValue(DI_LocationCylinder_Down2).Equals(IO_VALUE.HIGH)
                    )
            {
                return true;
            }
            return false;
        }
        public bool LocationIsUp()
        {
            if (IOManager.IOValue(DI_LocationCylinder_Down1).Equals(IO_VALUE.LOW) &&
                    IOManager.IOValue(DI_LocationCylinder_Up1).Equals(IO_VALUE.HIGH) &&
                    IOManager.IOValue(DI_LocationCylinder_Down2).Equals(IO_VALUE.LOW) &&
                    IOManager.IOValue(DI_LocationCylinder_Up2).Equals(IO_VALUE.HIGH)
                    )
            {
                return true;
            }
            return false;
        }


        private string Shelf_Back_Check = "FrontCheck";
        private string Shelf_Front_Check = "InCheck";
        private string DI_LocationCylinder_Up1 = "LocationCylinder_Up1";
        private string DI_LocationCylinder_Down1 = "LocationCylinder_Down1";
        private string DI_LocationCylinder_Up2 = "LocationCylinder_Up2";
        private string DI_LocationCylinder_Down2 = "LocationCylinder_Down2";
        private string Moto_Fwd = "LineRun";
        private string Moto_Rwd = "LineBackRun";
        private string Location_Up = "LocationCylinder_Up";
        private string Location_Down = "LocationCylinder_Down";
        #endregion
    }
   
}