Rs.ThressTemprature/Rs.ThreeTemprature/Flow/SubFlow/CleanOutFlow.cs

using Rs.Framework;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Entitys.Trays;
using Rs.MotionPlat.Recipe;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Rs.MotionPlat.Flow.SubFlow
{
    enum ECleanOutFlowStep
    {
        排料吸嘴检测,
        等待排料吸嘴处理完成,
        周转盘检测,
        等待周转盘处理完成,
        周转吸嘴测试治具检测,
        等待周转吸嘴测试治具处理完成,
    }
    /// <summary>
    /// 清料处理流程
    /// </summary>
    public class CleanOutFlow
    {
        string logInfo = string.Empty;
        bool run = false;
        ECleanOutFlowStep step = ECleanOutFlowStep.排料吸嘴检测;
        private static CleanOutFlow _instance;
        public static CleanOutFlow Instance
        {
            get
            {
                if(_instance==null)
                    _instance = new CleanOutFlow();
                return _instance;
            }
        }
        private CleanOutFlow() { }

        public void CleanOut()
        {
            if (run)
                return;
            else
                run = true;
            ECleanOutFlowStep step = ECleanOutFlowStep.排料吸嘴检测;
            Task.Run(() => {
                while (run)
                {
                    switch (step)
                    {
                        case ECleanOutFlowStep.排料吸嘴检测:
                            if(MachineManage.Instance.MachineStatus== EMachineStatus.Working)
                            {
                                List<Nozzle> unloadNozzles = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload);
                                if (unloadNozzles != null && unloadNozzles.Count > 0)
                                {
                                    LogHelper.Debug(GetClassName() + $"检测到排料吸嘴有料{unloadNozzles.Count}");
                                    GlobalVar.DischargeNozzleHasProduct = true;
                                    //生成下料任务
                                    LoadAndUnloadTask.Instance.CreateDischargeNozzleCleanOutTask();
                                    Thread.Sleep(100);
                                    step = ECleanOutFlowStep.等待排料吸嘴处理完成;
                                }
                                else
                                {
                                    LogHelper.Debug(GetClassName() + $"检测到排料吸嘴无料");
                                    step = ECleanOutFlowStep.周转盘检测;
                                }
                            }
                            break;
                        case ECleanOutFlowStep.等待排料吸嘴处理完成:
                            if(DischargeFlow.Instance.GetCurStep()=="等待任务")
                            {
                                GlobalVar.DischargeNozzleHasProduct = false;
                                step = ECleanOutFlowStep.周转盘检测;
                            }
                            break;
                        case ECleanOutFlowStep.周转盘检测:
                            //检测周转盘是否有任务
                            int num = TurnoverTrayManager.Instance.Slots.Where(s => s.IsHasProduct).Count();
                            if (num > 0)
                            {
                                LogHelper.Debug(GetClassName() + $"检测到周转盘有料{num}");
                                LoadAndUnloadTask.Instance.CreateTurnoverTrayCleanTask();
                                Thread.Sleep(1000);
                                step = ECleanOutFlowStep.等待周转盘处理完成;
                            }
                            else
                            {
                                LogHelper.Debug(GetClassName() + $"检测到周转盘无料");
                                //检测周转吸嘴是否有料
                                if (TransitNozzleManager.Instance.GetHasProductNozzles().Count > 0 || TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0)
                                {
                                    step = ECleanOutFlowStep.周转吸嘴测试治具检测;
                                }
                                else
                                {
                                    //清料结束
                                    run = false;
                                    logInfo = $"CleanOut finished";
                                    MessageQueue.Instance.Insert(logInfo);
                                    //清料结束
                                    GlobalVar.CleanOut = false;
                                    GlobalVar.DischargeNozzleHasProduct = false;
                                    GlobalVar.TurnoverNozzleHasProduct = false;
                                    Ops.Stop();
                                    MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
                                }
                            }
                            break;
                        case ECleanOutFlowStep.等待周转盘处理完成:
                            if(DischargeFlow.Instance.GetCurStep()=="等待任务")
                            {
                                //检测周转吸嘴是否有料
                                if (TransitNozzleManager.Instance.GetHasProductNozzles().Count > 0 || TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0)
                                {
                                    step = ECleanOutFlowStep.周转吸嘴测试治具检测;
                                }
                                else
                                {
                                    logInfo = $"CleanOut finished";
                                    MessageQueue.Instance.Insert(logInfo);
                                    //清料结束
                                    GlobalVar.CleanOut = false;
                                    GlobalVar.DischargeNozzleHasProduct = false;
                                    GlobalVar.TurnoverNozzleHasProduct = false;
                                    Ops.Stop();
                                    run = false;
                                    MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
                                }
                            }
                            break;
                        case ECleanOutFlowStep.周转吸嘴测试治具检测:
                            //检测周转吸嘴是否有料
                            if (TransitNozzleManager.Instance.GetHasProductNozzles().Count > 0 || TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0)
                            {
                                if(TransitNozzleManager.Instance.GetHasProductNozzles().Count > 0)
                                {
                                    GlobalVar.TurnoverNozzleHasProduct = true;
                                }
                                LogHelper.Debug(GetClassName() + $"检测到周转吸嘴有料{TransitNozzleManager.Instance.GetHasProductNozzles().Count}");
                                LoadAndUnloadTask.Instance.CreateTurnoverNozzleTestTrayCleanTask();
                                Thread.Sleep(1000);
                                step = ECleanOutFlowStep.等待周转吸嘴测试治具处理完成;
                            }
                            else
                            {
                                LogHelper.Debug(GetClassName() + $"检测到周转吸嘴无料");
                                step = ECleanOutFlowStep.周转盘检测;
                            }
                            break;
                        case ECleanOutFlowStep.等待周转吸嘴测试治具处理完成:
                            if (TurnoverFlow.Instance.GetStep() == "等待任务")
                            {
                                step = ECleanOutFlowStep.周转盘检测;
                            }
                            break;
                        default:
                            break;
                    }
                }
            });
        }

        private string GetClassName()
        {
            return "CleanOutFlow_";
        }

        public void Quit()
        {
            run = false;
        }
    }
}