HY_OutLine.cs 16.4 KB
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    public class HY_OutLine : HYEquipBase
    {
        public HY_OutLine(string cid, HYEquip_Config config) : base(cid, config)
        {
            Name = (" "+config.LineName+"HY" + (DeviceID % 100).ToString().PadLeft(2, '0') + " ").ToUpper();
            MoveInfo.Name = Name;
            SecondMoveInfo.Name = Name;
        } 
        public override bool StartRun(bool isDebug = false)
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            //mainTimer.Enabled = false;
            mainStop();
            MoveInfo.EndMove(); 
            runStatus = LineRunStatus.HomeMoving;
            MoveInfo.NewMove(LineMoveType.RHome);
            StartReset();
            if (isDebug)
            {
                //mainTimer.Enabled = true;
                mainStart();
            }
            return true;
        }
        public override bool Reset()
        {
            StopMove();
            runStatus = LineRunStatus.Reset; 
            MoveInfo.NewMove(LineMoveType.Reset);
            StartReset();
            return true;
        }

        private void StartReset()
        {
            ResetClearData(); 
            SecondMoveInfo.EndMove();
            MoveInfo.NextMoveStep(LineMoveStep.HY_R_01StopMove);
            LogInfo("开始" + MoveInfo.MoveType + ": 线体停止,顶升下降,阻挡上升 ");

            LineStop(MoveInfo);

            IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW);
            IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW);

            CylinderMove(null, IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down);
            isInPro = false;
        }

        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }

            if (!MoveInfo.IsInWait)
            {

                if (MoveInfo.IsStep(LineMoveStep.HY_R_01StopMove))
                { 
                    LogInfo(MoveInfo.MoveType + " 完成!");
                    runStatus = LineRunStatus.Runing;
                    MoveInfo.EndMove();  
                }
            }
        }

        internal override void StopMove(string stopDes = "")
        {
            MoveInfo.EndMove();
            SecondMoveInfo.EndMove(); 
            LogInfo("停止运动:关闭所有DO  ");
            CloseAllDO();

            //LineStop();  
            //IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW);
            //IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW);
            //CylinderMove(null, IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down); 
        }


        public override void StopRun()
        {
            //if (mainTimer != null)
            //{
            //    mainTimer.Enabled = false;
            //}
            mainStop();
            StopMove();

            runStatus = LineRunStatus.Wait;
        }


        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirCheck)
            {
                return;
            }
            IOTimeOutProcess();
            //判断流水线打开了才可以运行 
            if ((!MoveStop))
            {
                if (MoveInfo.MoveType.Equals(LineMoveType.None))
                {
                    if (LineManager.Line.OutHyCanProLine() && LineManager.Line.HYProcessNewTray())
                    {
                        CheckFixture();
                    }
                }
                else
                {
                    if (IOValue(IO_Type.HY_TrayCheck).Equals(IO_VALUE.HIGH))
                    {
                        trayCheck2LowWait.Stop();
                    }
                    else
                    {
                        CheckStopWatch(trayCheck2LowWait, 30000, false);
                    }
                    if (MoveInfo.MoveType.Equals(LineMoveType.RHome) || MoveInfo.MoveType.Equals(LineMoveType.Reset))
                    {
                        ResetProcess();
                    }
                    else
                    {
                        FixtureProcess();
                    }
                }
            }
        }


        private Stopwatch trayCheckWait = new Stopwatch();//检测到托盘的时间
        private Stopwatch trayCheck2LowWait = new Stopwatch();//上一个托盘离开的时间
        private object lockObj = "";
        private void CheckFixture()
        {
            if (Monitor.TryEnter(lockObj, TrayManager.mTimeOut))
            {
                try
                {
                    if (MoveInfo.MoveType.Equals(LineMoveType.None).Equals(false))
                    {
                        LogUtil.error(Name + "  CheckFixture " + " 不在空闲中,直接返回 ");
                        return;
                    }
                    if (MoveInfo.MoveType.Equals(LineMoveType.None) && IOValue(IO_Type.HY_OL_Full_Check).Equals(IO_VALUE.LOW))
                    {
                        if (IOValue(IO_Type.HY_TrayCheck).Equals(IO_VALUE.HIGH))
                        {
                            if (!CylinderIsOk(IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down))
                            {
                                CylinderMove(null, IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down);
                            }
                        }
                        else
                        {
                            if (Config.DIList.ContainsKey(IO_Type.HY_LongL_StopCheck) && IOValue(IO_Type.HY_LongL_StopCheck).Equals(IO_VALUE.HIGH))
                            {
                                bool check2IsOk = CheckStopWatch(trayCheck2LowWait, TrayWaitTime, false);
                                if (CheckStopWatch(trayCheckWait, TrayWaitTime, false) && check2IsOk)
                                {
                                    //托盘在前阻挡处
                                    trayCheckWait.Stop();
                                    trayCheck2LowWait.Stop();
                                    MoveInfo.NewMove(LineMoveType.Fixture);
                                    MoveInfo.NextMoveStep(LineMoveStep.OHY01_LongLCheck);
                                    LogInfo(" 出料线横移(长线):" + MoveInfo.SLog + ",长线阻挡检测到托盘");
                                    ClearTrayRFID();
                                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_LongL_StopCheck, IO_VALUE.HIGH));
                                }
                            }
                            else if (Config.DIList.ContainsKey(IO_Type.HY_ShortL_StopCheck) && IOValue(IO_Type.HY_ShortL_StopCheck).Equals(IO_VALUE.HIGH))
                            {
                                bool check2IsOk = CheckStopWatch(trayCheck2LowWait, TrayWaitTime, false);
                                if (CheckStopWatch(trayCheckWait, TrayWaitTime, false) && check2IsOk)
                                {
                                    //托盘在前阻挡处
                                    trayCheckWait.Stop();
                                    trayCheck2LowWait.Stop();
                                    MoveInfo.NewMove(LineMoveType.Fixture);
                                    MoveInfo.NextMoveStep(LineMoveStep.OHY11_ShortLCheck);
                                    LogInfo(" 出料线横移(长线):" + MoveInfo.SLog + ",短线阻挡检测到托盘");
                                    ClearTrayRFID();
                                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_ShortL_StopCheck, IO_VALUE.HIGH));
                                }
                            }
                            else
                            {
                                bool check2IsOk = CheckStopWatch(trayCheck2LowWait, TrayWaitTime, false);
                                trayCheckWait.Stop();
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "  CheckFixture " + " 出错:" + ex.ToString());
                }
                finally
                {
                    Monitor.Exit(lockObj);
                }
            }
            else
            {
                LogUtil.error(Name + "  CheckFixture " + "失败,未得到锁");
            }
        }

        protected override void FixtureProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            #region  托盘检测处理

            #region 长线阻挡放行

            if (MoveInfo.IsStep(LineMoveStep.OHY01_LongLCheck))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY02_TopDown);
                IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW);
                CheckLog("出料线横移(长线)" + MoveInfo.SLog + "   顶升气缸下降");
                CylinderMove(MoveInfo, IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down);
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY02_TopDown))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY03_LongLStopDown);
                CheckLog("出料线横移(长线)" + MoveInfo.SLog + "   长线体阻挡下降");
                IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.HIGH);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_LongL_StopDown, IO_VALUE.HIGH));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_LongL_StopCheck, IO_VALUE.LOW));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY03_LongLStopDown))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY04_WaitTray);
                IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW);
                CheckLog("出料线横移(长线)" + MoveInfo.SLog + "   等待托盘检测信号");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_TrayCheck, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY04_WaitTray))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY05_TrayCheck);
                CheckLog("出料线横移(长线)" + MoveInfo.SLog + "   再次等待托盘检测信号500ms");
                IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY05_TrayCheck))
            {
                if(IOValue(IO_Type.HY_TrayCheck).Equals(IO_VALUE.HIGH))
                {
                    MoveInfo.NextMoveStep(LineMoveStep.OHY21_WaitTrayLeave);
                    CheckLog("出料线横移(长线)" + MoveInfo.SLog + "   等待托盘离开");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_TrayCheck, IO_VALUE.LOW));

                }
                else if (MoveInfo.IsTimeOut())
                {
                    LogInfo("出料线横移(长线)" + MoveInfo.SLog + "   60秒超时,自动复位");
                    MoveInfo.EndMove();
                    Reset();
                }
                else if(MoveInfo.IsTimeOut(15))
                {
                    MoveInfo.NextMoveStep(LineMoveStep.OHY05_TrayCheck);
                    LogInfo("出料线横移(长线)" + MoveInfo.SLog + "   15秒超时,长线体阻挡下降1200");
                    IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.HIGH,1200);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                }
            }
            #endregion

            #region 短线阻挡放行
            else if (MoveInfo.IsStep(LineMoveStep.OHY11_ShortLCheck))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY12_TopUp);
                IOMove(IO_Type.HY_LongL_StopDown, IO_VALUE.LOW);
                CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   顶升气缸上升");
                CylinderMove(MoveInfo, IO_Type.HY_TopCylinder_Down, IO_Type.HY_TopCylinder_Up);
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY12_TopUp))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY13_ShortLStopDown);
                CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   短线阻挡下降,线体转动");
                LineRun(MoveInfo);
                IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.HIGH);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_ShortL_StopDown, IO_VALUE.HIGH));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_ShortL_StopCheck, IO_VALUE.LOW));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY13_ShortLStopDown))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY14_WaitTray);
                CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   等待托盘检测信号");
                IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_TrayCheck, IO_VALUE.HIGH));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY14_WaitTray))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY15_TrayCheck);
                CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   再次等待托盘检测信号500ms");
                IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.LOW);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY15_TrayCheck))
            {
                if (IOValue(IO_Type.HY_TrayCheck).Equals(IO_VALUE.HIGH))
                {
                    MoveInfo.NextMoveStep(LineMoveStep.OHY16_TopDown);
                    CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   顶升气缸下降,线体停止");
                    CylinderMove(MoveInfo, IO_Type.HY_TopCylinder_Up, IO_Type.HY_TopCylinder_Down);
                    LineStop(MoveInfo);
                }
                else if (MoveInfo.IsTimeOut())
                {
                    LogInfo("出料线横移(短线)" + MoveInfo.SLog + "   60秒超时,自动复位");
                    MoveInfo.EndMove();
                    Reset();
                }
                else if(MoveInfo.IsTimeOut(15))
                {
                    MoveInfo.NextMoveStep(LineMoveStep.OHY15_TrayCheck);
                    LogInfo("出料线横移(短线)" + MoveInfo.SLog + "   15秒超时,短线阻挡下降1200");
                    IOMove(IO_Type.HY_ShortL_StopDown, IO_VALUE.HIGH,1200);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                }
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY16_TopDown))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY21_WaitTrayLeave);
                CheckLog("出料线横移(短线)" + MoveInfo.SLog + "   等待托盘离开");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_TrayCheck, IO_VALUE.LOW));
            }
            #endregion 
            else if (MoveInfo.IsStep(LineMoveStep.OHY21_WaitTrayLeave))
            {
                MoveInfo.NextMoveStep(LineMoveStep.OHY22_TrayLeave);
                CheckLog("出料线横移" + MoveInfo.SLog + "   再次等待托盘检测信号500ms");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.HY_TrayCheck, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(LineMoveStep.OHY22_TrayLeave))
            {
                CheckLog("出料线横移" + MoveInfo.SLog + "   横移结束");
                MoveEndS();
            }
            else
            {
                LogUtil.error(Name + "FixtureProcess 未找到[" + MoveInfo.MoveType + "][" + MoveInfo.MoveStep + "]的处理");
            }
 
            #endregion 
        }

    }
}