update robot cycle

CyberX8_MainPages/ViewModels/RobotCycleViewModel.cs

@@ -164,7 +164,18 @@ namespace CyberX8_MainPages.ViewModels
                 MessageBox.Show("Selected at least on module between srd and dummy!");
                 return;
             }
-            InvokeClient.Instance.Service.DoOperation($"EFEM.{EfemOperation.RobotCycle}",SelectedLPName, SelectedAlignerName,SelectedDummyName, SelectedSrdName, InPutCycleTimes, InPutAlignDegree);
+            List<string> sequences = new List<string>();
+            sequences.Add(SelectedLPName.ToString());
+            sequences.Add(SelectedAlignerName.ToString());
+            if (SelectedSrdName != ModuleName.Unknown)
+            {
+                sequences.Add(SelectedSrdName.ToString());
+            }
+            if (SelectedDummyName != ModuleName.Unknown)
+            {
+                sequences.Add(SelectedDummyName.ToString());
+            }
+            InvokeClient.Instance.Service.DoOperation($"EFEM.{EfemOperation.RobotCycle}",string.Join("-",sequences), InPutCycleTimes, InPutAlignDegree);
         }
         private void RobotCycleAbortAction(object param)
         {
@@ -219,7 +230,7 @@ namespace CyberX8_MainPages.ViewModels
         public void LoadData(string systemName)
         {
             _rtDataKeys.Clear();
-            _rtDataKeys.Add($"EFEM.CurrentRobotCycleTime");
+            _rtDataKeys.Add("EFEM.CurrentRobotCycleTime");
             if (_timer == null)
             {
                 _timer = new DispatcherTimer();

CyberX8_RT/CyberX8_RT.csproj

@@ -259,9 +259,12 @@
     <Compile Include="Devices\TransPorter\TransporterDeviceTimer.cs" />
     <Compile Include="Dispatch\WaferHolderTaskDispatcher.cs" />
     <Compile Include="Modules\Dryer\DryerLotTrackUtil.cs" />
+    <Compile Include="Modules\EFEM\CycleRobotCycleNewRoutine.cs" />
     <Compile Include="Modules\EFEM\CycleRobotCycleRoutine.cs" />
     <Compile Include="Modules\EFEM\EfemAutoMessageProcessor.cs" />
+    <Compile Include="Modules\EFEM\EfemCycleAction.cs" />
     <Compile Include="Modules\EFEM\EfemRobotMapRoutine.cs" />
+    <Compile Include="Modules\EFEM\RobotCycleMoveRoutine.cs" />
     <Compile Include="Modules\EFEM\RobotCycleRoutine.cs" />
     <Compile Include="Modules\FaModuleNotifier.cs" />
     <Compile Include="Modules\Loader\LoaderLoadSideRoutine.cs" />

CyberX8_RT/Modules/EFEM/CycleRobotCycleNewRoutine.cs

@@ -0,0 +1,184 @@
+using Aitex.Core.Common;
+using Aitex.Core.RT.Log;
+using Aitex.Core.RT.Routine;
+using CyberX8_Core;
+using CyberX8_RT.Devices.EFEM;
+using CyberX8_RT.Modules.Rinse;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.Routine;
+using MECF.Framework.Common.Schedulers;
+using MECF.Framework.Common.SubstrateTrackings;
+using MECF.Framework.Common.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CyberX8_RT.Modules.EFEM
+{
+    public class CycleRobotCycleNewRoutine : ModuleRoutineBase, IRoutine
+    {
+        private enum CycleRobotCycleStep
+        {
+            LoopStart,
+            LoopRunRobotCycle,
+            LoopRunRobotCycleWait,
+            LoopEnd,
+            End
+
+        }
+        /// <summary>
+        /// Cycle次数
+        /// </summary>
+        private int _cycleTimes;
+        /// <summary>
+        /// 当前处于第几次Cycle
+        /// </summary>
+        private int _currentCycle;
+        private object[] param;
+        private RobotCycleMoveRoutine _cycleMoveRoutine;
+        private List<ModuleName> _sequences;
+        private int _alignerAngle;
+        private List<EfemCycleAction> _actions;
+
+        public CycleRobotCycleNewRoutine(EfemBase efem) : base(ModuleName.EfemRobot)
+        {
+            _cycleMoveRoutine = new RobotCycleMoveRoutine(efem);
+        }
+
+        public RState Start(params object[] objs)
+        {
+            string str = objs[0].ToString();
+            _sequences = new List<ModuleName>();
+            foreach(string item in str.Split('-'))
+            {
+                _sequences.Add((ModuleName)Enum.Parse(typeof(ModuleName), item));
+            }
+            _cycleTimes=(int)objs[1];
+            _alignerAngle = (int)objs[2];
+            _actions = new List<EfemCycleAction>();
+            GenerateCycleAction();
+            if (_cycleTimes < 1)
+            {
+                LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $"Input Robot Cycle Times{_cycleTimes} error");
+                return RState.Failed;
+            }
+            return Runner.Start(Module, "Start CycleRobotCycleRoutine");
+        }
+        private void GenerateCycleAction()
+        {
+            if (!ModuleHelper.IsLoadPort(_sequences[0]))
+            {
+                return;
+            }
+            WaferInfo[] waferInfos = WaferManager.Instance.GetWafers(_sequences[0]);
+            int count = 0;
+            foreach (WaferInfo item in waferInfos)
+            {
+                if (item.IsEmpty)
+                {
+                    continue;
+                }
+                _actions.AddRange(GenerateCycle(_sequences[0], item.Slot, _sequences[1], ModuleHelper.IsDummy(_sequences[1]) ? count : 0));
+                for (int i = 1; i < _sequences.Count; i++)
+                {
+                    if (i == 1)
+                    {
+                        _actions.AddRange(GenerateCycle(_sequences[i], ModuleHelper.IsDummy(_sequences[i]) ? count : 0, _sequences[i + 1],
+                            ModuleHelper.IsDummy(_sequences[i + 1]) ? count : 0));
+                    }
+                    else if (i == _sequences.Count - 1)
+                    {
+                        _actions.AddRange(GenerateCycle(_sequences[i], ModuleHelper.IsDummy(_sequences[i]) ? count : 0, _sequences[0],
+                            item.Slot));
+                    }
+                }
+                count++;
+            }
+        }
+
+        private List<EfemCycleAction> GenerateCycle(ModuleName source,int sourceSlot,ModuleName destModule,int destSlot)
+        {
+            List<EfemCycleAction> actions = new List<EfemCycleAction>();
+            if (source == ModuleName.Aligner1)
+            {
+                EfemCycleAction action = new EfemCycleAction();
+                action.Action = "Align";
+                action.Parameter = _alignerAngle;
+                actions.Add(action);
+            }
+            EfemCycleAction pick = new EfemCycleAction();
+            MoveItem pickMoveItem = new MoveItem();
+            pickMoveItem.SourceModule = source;
+            pickMoveItem.SourceSlot = sourceSlot;
+            pick.Parameter = pickMoveItem;
+            pick.Action = "Pick";
+            actions.Add(pick);
+            EfemCycleAction place = new EfemCycleAction();
+            MoveItem placeMoveItem = new MoveItem();
+            placeMoveItem.DestinationModule = destModule;
+            placeMoveItem.DestinationSlot = destSlot;
+            place.Parameter = placeMoveItem;
+            place.Action = "Place";
+            actions.Add(place);
+            return actions;
+        }
+        public RState Monitor()
+        {
+            Runner.LoopStart(CycleRobotCycleStep.LoopStart, "Loop StartCycleRobotCycleRoutine", _cycleTimes, NullFun, _delay_1ms)
+                .LoopRun(CycleRobotCycleStep.LoopRunRobotCycle, () => _cycleMoveRoutine.Start(_actions) == RState.Running,_delay_1ms)
+                .LoopRunWithStopStatus(CycleRobotCycleStep.LoopRunRobotCycleWait, () => { return CommonFunction.CheckRoutineEndState(_cycleMoveRoutine); },
+                 () => CheckRoutineStopStatus(_cycleMoveRoutine, "CycleRobotCycleRoutine failed"))
+                .LoopEnd(CycleRobotCycleStep.LoopEnd, UpdateCycleCount, _delay_1ms)
+                .End(CycleRobotCycleStep.End, AchievedCycleCount, _delay_1ms);
+            return Runner.Status;
+        }
+
+        private bool CheckRoutineStopStatus(IRoutine routine, string error)
+        {
+            bool result = CommonFunction.CheckRoutineStopState(routine);
+            if (result)
+            {
+                Stop($"{error}");
+            }
+            return result;
+        }
+        
+        /// <summary>
+        /// Abort
+        /// </summary>
+        public void Abort()
+        {
+            Runner.Stop("CycleRobotCycleRoutine Abort");
+        }
+
+        /// <summary>
+        /// 统计完成的Cycle次数
+        /// </summary>
+        /// <returns></returns>
+        private bool UpdateCycleCount()
+        {
+            _currentCycle += 1;
+            return true;
+        }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        private bool AchievedCycleCount()
+        {
+            _currentCycle -= 1;
+            return true;
+        }
+        /// <summary>
+        /// 获取当前Cycle次数
+        /// </summary>
+        /// <returns></returns>
+        public int GetCurrentCycle()
+        {
+            return _currentCycle;
+        }
+    }
+}
+

CyberX8_RT/Modules/EFEM/EfemCycleAction.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CyberX8_RT.Modules.EFEM
+{
+    public class EfemCycleAction
+    {
+        public string Action { get; set; }
+
+        public object Parameter { get; set; }
+    }
+}

CyberX8_RT/Modules/EFEM/EfemEntity.cs

@@ -210,7 +210,7 @@ namespace CyberX8_RT.Modules
         private readonly EfemMapDummyRoutine _mapDummyRoutine;
         private readonly EfemRobotMapRoutine _robotMapRoutine;
         private readonly EfemVacuumRoutine _vacuumRoutine;
-        private readonly CycleRobotCycleRoutine _cycleRobotCycleRoutine;
+        private readonly CycleRobotCycleNewRoutine _cycleRobotCycleRoutine;
 
         private string LiftMessage;
 
@@ -241,7 +241,7 @@ namespace CyberX8_RT.Modules
             _alignRoutine = new EFEMAlignRoutine(_efem);
             _mapDummyRoutine = new EfemMapDummyRoutine(_efem);
             _vacuumRoutine = new EfemVacuumRoutine(_efem);
-            _cycleRobotCycleRoutine =   new CycleRobotCycleRoutine(_efem);
+            _cycleRobotCycleRoutine =   new CycleRobotCycleNewRoutine(_efem);
             _autoMessageProcessor =new EfemAutoMessageProcessor(_efem);
         }
         public LoadPortModule GetLoadportModule(int lpNumber)
@@ -277,7 +277,8 @@ namespace CyberX8_RT.Modules
 
 
             OP.Subscribe($"{ModuleName.EFEM}.{EfemOperation.Home}",             (cmd, args) => { PostMsg(MSG.HomeAll); return true; });
-            OP.Subscribe($"{ModuleName.EFEM}.{EfemOperation.RobotCycle}",             (cmd, args) => { PostMsg(MSG.RobotCycle,args); return true; });
+            OP.Subscribe($"{ModuleName.EFEM}.{EfemOperation.RobotCycle}",             (cmd, args) => { 
+                PostMsg(MSG.RobotCycle,args); return true; });
             OP.Subscribe($"{ModuleName.EFEM}.{EfemOperation.ClearError}",       (cmd, args) => { PostMsg(MSG.Recover); return true; });
             OP.Subscribe($"{ModuleName.EFEM}.{EfemOperation.TurnOffBuzzer}", (cmd, args) => { PostMsg(MSG.CloseBuzzer); return true; });
             OP.Subscribe($"{ModuleName.EFEM}.Online",                           (cmd, args) => 

CyberX8_RT/Modules/EFEM/RobotCycleMoveRoutine.cs

@@ -0,0 +1,97 @@
+using Aitex.Core.RT.Routine;
+using CyberX8_Core;
+using CyberX8_RT.Devices.EFEM;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.Routine;
+using MECF.Framework.Common.Schedulers;
+using MECF.Framework.Common.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CyberX8_RT.Modules.EFEM
+{
+    public class RobotCycleMoveRoutine : RoutineBase, IRoutine
+    {
+        private enum CycleStep
+        {
+            LoopStart,
+            LoopRun,
+            LoopCheck,
+            LoopEnd,
+            End
+        }
+
+        private EfemPickRoutine _efemPickRoutine;
+        private EfemPlaceRoutine _efemPlaceRoutine;
+        private EFEMAlignRoutine _efemAlignRoutine;
+        private IRoutine _currentRoutine;
+        private List<EfemCycleAction> _moveActionQueue;
+        /// <summary>
+        /// 构建函数
+        /// </summary>
+        /// <param name="module"></param>
+        public RobotCycleMoveRoutine(EfemBase efem) : base(ModuleName.EfemRobot.ToString())
+        {
+            _efemPickRoutine = new EfemPickRoutine(efem);
+            _efemPlaceRoutine = new EfemPlaceRoutine(efem);
+            _efemAlignRoutine = new EFEMAlignRoutine(efem);
+        }
+        /// <summary>
+        /// 中止
+        /// </summary>
+        public void Abort()
+        {
+            Runner.Stop("Manual abort");
+        }
+        /// <summary>
+        /// 中止
+        /// </summary>
+        /// <returns></returns>
+        public RState Monitor()
+        {
+            Runner.LoopStart(CycleStep.LoopStart, "start efem cycle action", _moveActionQueue.Count, NullFun, _delay_1ms)
+                .LoopRun(CycleStep.LoopRun, RunAction, _delay_1ms)
+                .LoopRunWithStopStatus(CycleStep.LoopCheck, () => CommonFunction.CheckRoutineEndState(_currentRoutine),
+                    () => CommonFunction.CheckRoutineStopState(_currentRoutine))
+                .LoopEnd(CycleStep.LoopEnd, NullFun, _delay_1ms)
+                .End(CycleStep.End, NullFun, _delay_1ms);
+            return Runner.Status;
+        }
+
+        private bool RunAction()
+        {
+            EfemCycleAction action = _moveActionQueue[Runner.LoopCounter];
+            switch(action.Action)
+            {
+                case "Pick":
+                    Queue<MoveItem> moveItems = new Queue<MoveItem>();
+                    moveItems.Enqueue((MoveItem)action.Parameter);
+                    _currentRoutine = _efemPickRoutine;
+                    return _efemPickRoutine.Start(moveItems) == RState.Running;
+                case "Place":
+                    Queue<MoveItem> placeMoveItems = new Queue<MoveItem>();
+                    placeMoveItems.Enqueue((MoveItem)action.Parameter);
+                    _currentRoutine= _efemPlaceRoutine;
+                    return _efemPlaceRoutine.Start(placeMoveItems) == RState.Running;
+                case "Align":
+                    _currentRoutine = _efemAlignRoutine;
+                    return _efemAlignRoutine.Start(action.Parameter)==RState.Running;
+
+            }
+            return false;
+        }
+        /// <summary>
+        /// 启动
+        /// </summary>
+        /// <param name="objs"></param>
+        /// <returns></returns>
+        public RState Start(params object[] objs)
+        {
+            _moveActionQueue = (List<EfemCycleAction>)objs[0];
+            return Runner.Start(Module, "Robot Cycle move");
+        }
+    }
+}