add robot cycle(exclude srd)

CyberX8_Core/DeviceName.cs

@@ -58,7 +58,8 @@ namespace CyberX8_Core
         Speed,
         Vacuum,
         PowerOn,
-        Error
+        Error,
+        RobotCycle
     }
 
     public class EfemConstant

CyberX8_Core/RtState.cs

@@ -73,7 +73,8 @@ namespace CyberX8_Core
         Retrying,
         ConfirmCompleting,
         ErrorPicking,
-        ErrorPlacing
+        ErrorPlacing,
+        RobotCycleing
     }
     public enum PUFSTATE
     {

CyberX8_MainPages/CyberX8_MainPages.csproj

@@ -186,6 +186,7 @@
     <Compile Include="ViewModels\ReservoirsAnolyteViewModel.cs" />
     <Compile Include="ViewModels\ReservoirsCatholyteViewModel.cs" />
     <Compile Include="ViewModels\ReservoirsViewModel.cs" />
+    <Compile Include="ViewModels\RobotCycleViewModel.cs" />
     <Compile Include="ViewModels\SignalTowerConfigViewModel.cs" />
     <Compile Include="ViewModels\StandardHotReservoirsViewModel.cs" />
     <Compile Include="ViewModels\ResRecipeViewModel.cs" />
@@ -285,6 +286,9 @@
     <Compile Include="Views\ReservoirsView.xaml.cs">
       <DependentUpon>ReservoirsView.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Views\RobotCycleView.xaml.cs">
+      <DependentUpon>RobotCycleView.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Views\SignalTowerConfigView.xaml.cs">
       <DependentUpon>SignalTowerConfigView.xaml</DependentUpon>
     </Compile>
@@ -535,6 +539,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\RobotCycleView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\SignalTowerConfigView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>

CyberX8_MainPages/ViewModels/RobotCycleViewModel.cs

@@ -0,0 +1,248 @@
+using Aitex.Core.UI.MVVM;
+using CyberX8_Core;
+using CyberX8_MainPages.Roles;
+using CyberX8_MainPages.Views;
+using MECF.Framework.Common.ControlDataContext;
+using MECF.Framework.Common.DataCenter;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.OperationCenter;
+using MECF.Framework.Common.Utilities;
+using OpenSEMI.ClientBase.Command;
+using Prism.Mvvm;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using System.Windows.Input;
+using System.Windows.Threading;
+
+namespace CyberX8_MainPages.ViewModels
+{
+    public class RobotCycleViewModel : BindableBase
+    {
+
+        #region 内部变量
+        /// <summary>
+        /// 选择的LP
+        /// </summary>
+        private ModuleName _selectedLPName = ModuleName.LP1;
+        private ModuleName _selectedAlignerName = ModuleName.Aligner1;
+        /// <summary>
+        /// 选择的Dummy
+        /// </summary>
+        private ModuleName _selectedDummyName = ModuleName.Dummy1;
+        private ModuleName _selectedSrdName = ModuleName.SRD1;
+        /// <summary>
+        /// 输入的Cycle次数
+        /// </summary>
+        private int _inPutCycleTimes = 1;
+        /// <summary>
+        /// 当前正在执行第几次Cycle
+        /// </summary>
+        private int _currentCycle;
+        /// <summary>
+        /// 是否选中dummy
+        /// </summary>
+        private bool _isDummySelected = false;
+        /// <summary>
+        /// 是否选中srd
+        /// </summary>
+        private bool _isSrdSelected = false ;
+        #region 系统数据
+        /// <summary>
+        /// 定时器
+        /// </summary>
+        DispatcherTimer _timer;
+        /// <summary>
+        /// 查询后台数据集合
+        /// </summary>
+        private List<string> _rtDataKeys = new List<string>();
+        /// <summary>
+        /// rt查询key数值字典
+        /// </summary>
+        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
+        #endregion
+        #endregion
+
+        #region 属性
+        public ModuleName SelectedLPName
+        {
+            get { return _selectedLPName; }
+            set { SetProperty(ref _selectedLPName, value); }
+        }
+        public ModuleName SelectedAlignerName
+        {
+            get { return _selectedAlignerName; }
+            set { SetProperty(ref _selectedAlignerName, value); }
+        }
+        public ModuleName SelectedDummyName
+        {
+            get { return _selectedDummyName; }
+            set { SetProperty(ref _selectedDummyName, value); }
+        }
+        public ModuleName SelectedSrdName
+        {
+            get { return _selectedSrdName; }
+            set { SetProperty(ref _selectedSrdName, value); }
+        }
+        public int InPutCycleTimes
+        {
+            get { return _inPutCycleTimes; }
+            set { SetProperty(ref _inPutCycleTimes, value); }
+        }
+        public int CurrentCycle
+        {
+            get { return _currentCycle; }
+            set { SetProperty(ref _currentCycle, value); }
+        }
+        public bool IsDummySelected
+        {
+            get { return _isDummySelected; }
+            set { SetProperty(ref _isDummySelected, value); }
+        }
+        public bool IsSrdSelected
+        {
+            get { return _isSrdSelected; }
+            set { SetProperty(ref _isSrdSelected, value); }
+        }
+        #endregion
+
+        #region 命令
+
+        public ICommand RobotCycleStartCommand { get; set; }
+  
+        public ICommand RobotCycleAbortCommand { get; set; }
+
+        public ICommand LPChangeCommand { get; set; }
+ 
+        public ICommand AlignerChangeCommand { get; set; }
+   
+        public ICommand DummyChangeCommand { get; set; }
+        
+        public ICommand SrdChangeCommand { get; set; }
+        #endregion
+
+        /// <summary>
+        /// 构造器
+        /// </summary>
+        public RobotCycleViewModel() 
+        {
+            RobotCycleStartCommand = new DelegateCommand<object>(RobotCycleStartAction);
+            RobotCycleAbortCommand = new DelegateCommand<object>(RobotCycleAbortAction);
+            LPChangeCommand = new DelegateCommand<object>(LPChangeAction);
+            AlignerChangeCommand = new DelegateCommand<object>(AlignerChangeAction);
+            DummyChangeCommand = new DelegateCommand<object>(DummyChangeAction);
+            SrdChangeCommand = new DelegateCommand<object>(SrdChangeAction);
+        }
+
+        private void RobotCycleStartAction(object param)
+        {
+            if (!IsDummySelected)
+            {
+                SelectedDummyName = ModuleName.Unknown;
+            }
+            if (!IsSrdSelected)
+            {
+                SelectedSrdName = ModuleName.Unknown;
+            }
+            if(!IsDummySelected && !IsSrdSelected)
+            {
+                MessageBox.Show("Selected at least on module between srd and dummy!");
+                return;
+            }
+            InvokeClient.Instance.Service.DoOperation($"EFEM.{EfemOperation.RobotCycle}",SelectedLPName, SelectedAlignerName,SelectedDummyName, SelectedSrdName, InPutCycleTimes);
+        }
+        private void RobotCycleAbortAction(object param)
+        {
+            InvokeClient.Instance.Service.DoOperation($"EFEM.{EfemOperation.Abort}");
+        }
+        private void LPChangeAction(object param)
+        {
+            if ("LP1".Equals((string)param))
+            {
+                SelectedLPName = ModuleName.LP1;
+            }
+            else if ("LP2".Equals((string)param))
+            {
+                SelectedLPName = ModuleName.LP2;
+            }
+            else
+            {
+                SelectedLPName = ModuleName.LP3;
+            }
+            
+        }
+        private void AlignerChangeAction(object param)
+        {
+            
+        }
+        private void DummyChangeAction(object param)
+        {
+            if ("Dummy1".Equals((string)param))
+            {
+                SelectedDummyName = ModuleName.Dummy1;
+            }
+            else
+            {
+                SelectedDummyName = ModuleName.Dummy2;
+            }
+        }
+        private void SrdChangeAction(object param)
+        {
+            if ("SRD1".Equals((string)param))
+            {
+                SelectedSrdName = ModuleName.SRD1;
+            }
+            else
+            {
+                SelectedSrdName = ModuleName.SRD2;
+            }
+        }
+
+        /// <summary>
+        /// 加载数据
+        /// </summary>
+        public void LoadData(string systemName)
+        {
+            _rtDataKeys.Clear();
+            _rtDataKeys.Add($"EFEM.CurrentRobotCycleTime");
+            if (_timer == null)
+            {
+                _timer = new DispatcherTimer();
+                _timer.Interval = TimeSpan.FromMilliseconds(200);
+                _timer.Tick += Timer_Tick;
+            }
+            _timer.Start();
+        }
+
+        /// <summary>
+        /// 定时器执行
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void Timer_Tick(object sender, EventArgs e)
+        {
+            if (_rtDataKeys.Count != 0)
+            {
+                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
+                if (_rtDataValueDic != null)
+                {
+                    CurrentCycle = CommonFunction.GetValue<int>(_rtDataValueDic, $"EFEM.CurrentRobotCycleTime");
+                }
+
+            }
+
+        }
+        /// <summary>
+        /// 隐藏
+        /// </summary>
+        public void Hide()
+        {
+
+        }
+    }
+}

CyberX8_MainPages/Views/RobotCycleView.xaml

@@ -0,0 +1,120 @@
+<UserControl x:Class="CyberX8_MainPages.Views.RobotCycleView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:CyberX8_MainPages.Views"
+             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
+             xmlns:prism="http://prismlibrary.com/"
+             xmlns:customControls="clr-namespace:CyberX8_Themes.CustomControls;assembly=CyberX8_Themes"
+             xmlns:unity="clr-namespace:CyberX8_MainPages.Unity" 
+             xmlns:Converters="clr-namespace:CyberX8_Themes.Converters;assembly=CyberX8_Themes"
+             prism:ViewModelLocator.AutoWireViewModel="True"
+             mc:Ignorable="d" 
+             d:DesignHeight="1000" d:DesignWidth="2000">
+    <Canvas>
+        <Grid Height="600" Canvas.Left="100" Canvas.Top="30" HorizontalAlignment="Center" VerticalAlignment="Top" Width="500">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition Height="70"/>
+                <RowDefinition />
+            </Grid.RowDefinitions>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+            </Grid.ColumnDefinitions>
+            <GroupBox Header="LP Select" FontSize="14" FontWeight="Bold"  Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="3">
+                <Grid>
+                    <RadioButton  Content="LP1"  x:Name="lp1" IsChecked="True"  FontSize="19"  Margin="52,0,0,0" VerticalContentAlignment="Center" HorizontalAlignment="Left">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding LPChangeCommand}" CommandParameter="{Binding ElementName=lp1,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                    <RadioButton  Content="LP2"  x:Name="lp2" IsChecked="False"  FontSize="19"  Margin="0,0,0,0" VerticalContentAlignment="Center" HorizontalAlignment="Center">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding LPChangeCommand}" CommandParameter="{Binding ElementName=lp2,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                    <RadioButton  Content="LP3"  x:Name="lp3" IsChecked="False"  FontSize="19"  Margin="0,0,50,0" VerticalContentAlignment="Center" HorizontalAlignment="Right">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding LPChangeCommand}" CommandParameter="{Binding ElementName=lp3,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                </Grid>
+            </GroupBox>
+            <GroupBox Header="Aligner Select" FontSize="14" FontWeight="Bold"  Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="3">
+                <Grid>
+                    <RadioButton Content="Aligner1"  x:Name="aligner" IsChecked="True" Margin="52,0,0,0" FontSize="19" VerticalContentAlignment="Center" HorizontalAlignment="Left">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding AlignerChangeCommand}" CommandParameter="{Binding ElementName=aligner,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                </Grid>
+            </GroupBox>
+
+            <GroupBox Header="Dummy Select" FontSize="14" FontWeight="Bold"  Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2" IsEnabled="{Binding IsDummySelected}">
+                <Grid>
+                    <RadioButton  Content="Dummy1"  x:Name="dummy1" IsChecked="True" Margin="52,0,0,0" FontSize="19" VerticalContentAlignment="Center" HorizontalAlignment="Left">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding DummyChangeCommand}" CommandParameter="{Binding ElementName=dummy1,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                    <RadioButton  Content="Dummy2"  x:Name="dummy2" IsChecked="False" Margin="132,0,0,0" FontSize="19" VerticalContentAlignment="Center" HorizontalAlignment="Center">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding DummyChangeCommand}" CommandParameter="{Binding ElementName=dummy2,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                </Grid>
+            </GroupBox>
+            <CheckBox Grid.Row="2" Grid.Column="2" Margin="0,12,0,0"  VerticalAlignment="Center" HorizontalAlignment="Left" Content="DummySelect"  FontSize="16" FontWeight="Bold" 
+               IsChecked="{Binding IsDummySelected,Mode=TwoWay}"/>
+            <GroupBox Header="SRD Select" FontSize="14" FontWeight="Bold"  Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2" IsEnabled="{Binding IsSrdSelected}">
+                <Grid>
+                    <RadioButton  Content="SRD1"  x:Name="srd1" IsChecked="True" Margin="52,0,0,0" FontSize="19" VerticalContentAlignment="Center" HorizontalAlignment="Left">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding SrdChangeCommand}" CommandParameter="{Binding ElementName=srd1,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                    <RadioButton  Content="SRD2"  x:Name="srd2" IsChecked="False" Margin="92,0,0,0" FontSize="19" VerticalContentAlignment="Center" HorizontalAlignment="Center">
+                        <i:Interaction.Triggers>
+                            <i:EventTrigger EventName="Checked">
+                                <i:InvokeCommandAction Command="{Binding SrdChangeCommand}" CommandParameter="{Binding ElementName=srd2,Path=Content}"/>
+                            </i:EventTrigger>
+                        </i:Interaction.Triggers>
+                    </RadioButton>
+                </Grid>
+            </GroupBox>
+            <CheckBox Grid.Row="3" Grid.Column="2" Margin="0,12,0,0"  VerticalAlignment="Center" HorizontalAlignment="Left" Content="SrdSelect"  FontSize="16" FontWeight="Bold" 
+                IsChecked="{Binding IsSrdSelected,Mode=TwoWay}"/>
+            <TextBlock  Grid.Row="4" Grid.Column="0" Text="Cycle :" FontSize="19" VerticalAlignment="Center" Margin="58,0,0,0"/>
+            <TextBox Grid.Row="4" Grid.Column="1" Height="35" Width="80" FontSize="15" HorizontalAlignment="Left"  Margin="0,0,0,0" Background="White" HorizontalContentAlignment="Center" VerticalContentAlignment="Center"  Text="{Binding InPutCycleTimes,Mode=TwoWay}" />
+
+            <TextBlock  Grid.Row="5" Grid.Column="0" Text="Current :" FontSize="19" VerticalAlignment="Center" Margin="58,0,0,0"/>
+            <Border Grid.Row="5" Grid.Column="1" Margin="0,0,0,0" Background="Black" Height="35" Width="80" HorizontalAlignment="Left">
+                <TextBlock  Text="{Binding CurrentCycle}" Foreground="Lime" FontSize="16" FontWeight="Bold" VerticalAlignment="Center" TextAlignment="Center" HorizontalAlignment="Center"/>
+            </Border>
+            <Button Grid.Row="6" Grid.Column="0" Grid.ColumnSpan="2" Content="Start" Width="120" Height="36" Command="{Binding RobotCycleStartCommand}" FontSize="18" HorizontalAlignment="Center" VerticalAlignment="Center"/>
+            <Button Grid.Row="6" Grid.Column="1" Grid.ColumnSpan="2" Content="Aobot" Width="120" Height="36" Command="{Binding RobotCycleAbortCommand}" FontSize="18" HorizontalAlignment="Center" VerticalAlignment="Center"/>
+        </Grid>
+    </Canvas>
+</UserControl>

CyberX8_MainPages/Views/RobotCycleView.xaml.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace CyberX8_MainPages.Views
+{
+    /// <summary>
+    /// RobotCycleView.xaml 的交互逻辑
+    /// </summary>
+    public partial class RobotCycleView : UserControl
+    {
+        public RobotCycleView()
+        {
+            InitializeComponent();
+        }
+    }
+}

CyberX8_RT/Config/Layout/ToolLayoutConfiguration.xml

@@ -341,7 +341,7 @@
 		<!-- PUFs -->
 
 		<Item i:type="PUF">
-			<Installed>true</Installed>
+			<Installed>false</Installed>
 			<PufID>1</PufID>
 			<SubType>DualPUF_WithDistanceSensors</SubType>
 		</Item>
@@ -885,7 +885,7 @@
 			<PermittedWaferSizeInMM>200</PermittedWaferSizeInMM>
 			<ResourceID>Dummy1</ResourceID>
 			<Type>Dummy</Type>
-			<MaxNumberOfSlots>25</MaxNumberOfSlots>
+			<MaxNumberOfSlots>16</MaxNumberOfSlots>
 			<DummyCassetteID>1</DummyCassetteID>
 		</Item>
 

CyberX8_RT/CyberX8_RT.csproj

@@ -259,8 +259,10 @@
     <Compile Include="Devices\TransPorter\TransporterDeviceTimer.cs" />
     <Compile Include="Dispatch\WaferHolderTaskDispatcher.cs" />
     <Compile Include="Modules\Dryer\DryerLotTrackUtil.cs" />
+    <Compile Include="Modules\EFEM\CycleRobotCycleRoutine.cs" />
     <Compile Include="Modules\EFEM\EfemAutoMessageProcessor.cs" />
     <Compile Include="Modules\EFEM\EfemRobotMapRoutine.cs" />
+    <Compile Include="Modules\EFEM\RobotCycleRoutine.cs" />
     <Compile Include="Modules\FaModuleNotifier.cs" />
     <Compile Include="Modules\Metal\CompactEmbranceInitializeRoutine.cs" />
     <Compile Include="Modules\Metal\CurrentShortTestRoutine.cs" />

CyberX8_RT/Devices/EFEM/SunWayEfem.cs

@@ -301,7 +301,6 @@ namespace CyberX8_RT.Devices.EFEM
                 Head = EfemMessage.MsgHead.SET,
                 Parameters = new List<string> { "CLEAR" }
             };
-
             _status = RState.Running;
             return _socket.Write(_currentMsg.ToString());
         }

CyberX8_RT/Devices/EFEM/SunWayRobot.cs

@@ -970,7 +970,7 @@ namespace CyberX8_RT.Devices.EFEM
                 }
                 return (int)dummyDevice.WaferSize;
             }
-            return 0;
+            return (int)SC.GetValue<int>("System.WaferSize");
         }
     }
 }

CyberX8_RT/Modules/EFEM/CycleRobotCycleRoutine.cs

@@ -0,0 +1,117 @@
+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.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CyberX8_RT.Modules.EFEM
+{
+    public class CycleRobotCycleRoutine : 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 RobotCycleRoutine _robotCycleRoutine;
+
+        public CycleRobotCycleRoutine(EfemBase efem) : base(ModuleName.EfemRobot)
+        {
+            _robotCycleRoutine = new RobotCycleRoutine(efem);
+        }
+
+        public RState Start(params object[] objs)
+        {
+            param = objs;
+            _currentCycle = 1;//初始化当前Cycle次数
+            if (objs.Length >= 5)
+            {
+                _cycleTimes = (int)objs[4];
+                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");
+        }
+
+        public RState Monitor()
+        {
+            Runner.LoopStart(CycleRobotCycleStep.LoopStart, "Loop StartCycleRobotCycleRoutine", _cycleTimes, NullFun, _delay_1ms)
+                .LoopRun(CycleRobotCycleStep.LoopRunRobotCycle, () => _robotCycleRoutine.Start(param) == RState.Running, _delay_1ms)
+                .LoopRunWithStopStatus(CycleRobotCycleStep.LoopRunRobotCycleWait, () => { return CommonFunction.CheckRoutineEndState(_robotCycleRoutine); },
+                 () => CheckRoutineStopStatus(_robotCycleRoutine, "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/EfemEntity.cs

@@ -65,7 +65,8 @@ namespace CyberX8_RT.Modules
             Retrying,
             ConfirmCompleting,
             ErrorPicking,
-            ErrorPlacing
+            ErrorPlacing,
+            RobotCycleing
         }
 
         public enum MSG
@@ -117,7 +118,8 @@ namespace CyberX8_RT.Modules
             ReadCarrierId,
             WriteCarrierID,
             ReadTagData,
-            WriteTagData
+            WriteTagData,
+            RobotCycle
         }
 
         public enum EfemType
@@ -208,6 +210,8 @@ namespace CyberX8_RT.Modules
         private readonly EfemMapDummyRoutine _mapDummyRoutine;
         private readonly EfemRobotMapRoutine _robotMapRoutine;
         private readonly EfemVacuumRoutine _vacuumRoutine;
+        private readonly CycleRobotCycleRoutine _cycleRobotCycleRoutine;
+
         private string LiftMessage;
 
         private Stopwatch _robotWatch = new Stopwatch();
@@ -216,6 +220,8 @@ namespace CyberX8_RT.Modules
         private bool _isHomed = false;
         private EfemAutoMessageProcessor _autoMessageProcessor;
         private STATE _errorPreState;
+
+        private int _currentCycleTimes;
         // Constructor
         public EfemEntity()
         {
@@ -235,6 +241,7 @@ namespace CyberX8_RT.Modules
             _alignRoutine = new EFEMAlignRoutine(_efem);
             _mapDummyRoutine = new EfemMapDummyRoutine(_efem);
             _vacuumRoutine = new EfemVacuumRoutine(_efem);
+            _cycleRobotCycleRoutine =   new CycleRobotCycleRoutine(_efem);
             _autoMessageProcessor =new EfemAutoMessageProcessor(_efem);
         }
         public LoadPortModule GetLoadportModule(int lpNumber)
@@ -270,6 +277,7 @@ 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.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) => 
@@ -320,6 +328,7 @@ namespace CyberX8_RT.Modules
             DATA.Subscribe($"{Name}.IsOnline", () => IsOnline, SubscriptionAttribute.FLAG.IgnoreSaveDB);
             DATA.Subscribe($"{Name}.IsHomed", () => _isHomed,  SubscriptionAttribute.FLAG.IgnoreSaveDB);
             DATA.Subscribe($"{Name}.RobotSpeed",()=>IsIdle?SC.GetValue<int>("EFEM.DefaultMoveSpeedInPercent"):0);
+            DATA.Subscribe($"{Name}.CurrentRobotCycleTime",()=>_currentCycleTimes, SubscriptionAttribute.FLAG.IgnoreSaveDB);
             _robotWatch.Restart();
             return true;
         }
@@ -343,6 +352,7 @@ namespace CyberX8_RT.Modules
             Transition(STATE.Error, MSG.Recover, fnRecover, STATE.Idle);
 
             // Home
+            Transition(STATE.Unknown,          MSG.HomeAll,            fnHomeAll,          STATE.Initializing);
             Transition(STATE.Init,          MSG.HomeAll,            fnHomeAll,          STATE.Initializing);
             Transition(STATE.Idle,          MSG.HomeAll,            fnHomeAll,          STATE.Initializing);    
             Transition(STATE.Error,         MSG.HomeAll,            fnHomeAll,          STATE.Initializing);
@@ -362,6 +372,11 @@ namespace CyberX8_RT.Modules
             Transition(STATE.Picking,       FSM_MSG.TIMER,          FnPickTimeout,      STATE.Idle);
             Transition(STATE.Picking,       MSG.Abort,              FnAbortPick,        STATE.Idle);
 
+            //Robot Cycle
+            Transition(STATE.Idle, MSG.RobotCycle, FnStartRobotCycle, STATE.RobotCycleing);
+            Transition(STATE.RobotCycleing, FSM_MSG.TIMER, FnRobotCycleTimeout, STATE.Idle);
+            Transition(STATE.RobotCycleing, MSG.Abort, FnAbortRobotCycle, STATE.Idle);
+
             Transition(STATE.Error,         MSG.Pick,               FnErrorStartPick, STATE.ErrorPicking);
             Transition(STATE.ErrorPicking,  FSM_MSG.TIMER,          FnErrorPickTimeout, STATE.Error);
             Transition(STATE.ErrorPicking,  MSG.Abort,              FnErrorAbortPick, STATE.Error);
@@ -681,6 +696,10 @@ namespace CyberX8_RT.Modules
             return _pickRoutine.Start(param) == RState.Running;
         }
 
+        private bool FnStartRobotCycle(object[] param)
+        {
+            return _cycleRobotCycleRoutine.Start(param) == RState.Running;
+        }
 
         private bool FnErrorStartPick(object[] param)
         {
@@ -720,6 +739,19 @@ namespace CyberX8_RT.Modules
 
             return ret == RState.End;
         }
+
+        private bool FnRobotCycleTimeout(object[] param)
+        {
+            RState ret = _cycleRobotCycleRoutine.Monitor();
+            if (ret == RState.Failed || ret == RState.Timeout)
+            {
+                PostMsg(MSG.Error);
+                return false;
+            }
+            _currentCycleTimes = _cycleRobotCycleRoutine.GetCurrentCycle();
+            return ret == RState.End;
+        }
+
         private bool FnErrorPickTimeout(object[] param)
         {
             RState ret = _pickRoutine.Monitor();
@@ -759,6 +791,11 @@ namespace CyberX8_RT.Modules
             _pickRoutine.Abort();
             return true;
         }
+        private bool FnAbortRobotCycle(object[] param)
+        {
+            _cycleRobotCycleRoutine.Abort();
+            return true;
+        }
         private bool FnErrorAbortPick(object[] param)
         {
             _pickRoutine.Abort();

CyberX8_RT/Modules/EFEM/RobotCycleRoutine.cs

@@ -0,0 +1,355 @@
+using Aitex.Core.Common;
+using Aitex.Core.RT.Log;
+using Aitex.Core.RT.Routine;
+using Aitex.Core.RT.SCCore;
+using Aitex.Core.Util;
+using Aitex.Sorter.Common;
+using CyberX8_Core;
+using CyberX8_RT.Devices.EFEM;
+using CyberX8_RT.Modules.LPs;
+using MECF.Framework.Common.Beckhoff.Station;
+using MECF.Framework.Common.Equipment;
+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 RobotCycleRoutine : ModuleRoutineBase, IRoutine
+    {
+        private enum RobotCycleStep
+        {
+
+            LPCycleStrat,
+            
+            PickFromLP,
+            PickFromLPCheck,
+
+            PlaceToAligner,
+            PlaceToAlignerCheck,
+
+            PickFromAligner,
+            PickFromAlignerCheck,
+
+            PlaceToDummy,
+            PlaceToDummyCheck,
+
+            PickFromDummy,
+            PickFromDummyCheck,
+
+            PlaceToSrd,
+            PlaceToSrdCheck,
+
+            PickFromSrd,
+            PickFromSrdCheck,
+
+            PlaceToLP,
+            PlaceToLPCheck,
+
+            LPCycleEnd,
+
+            End
+        }
+
+        EfemBase _efem;
+        /// <summary>
+        /// 当前Cycle选中的LP里面的Wafer数量
+        /// </summary>
+        private int _waferCount;
+
+        private EfemPickRoutine _efemPickRoutine;
+        private EfemPlaceRoutine _efemPlaceRoutine;
+
+        private ModuleName _targetLP;
+        private ModuleName _targetAligner;
+        private ModuleName _targetDummy;
+        private ModuleName _targetSrd;
+        
+        private Queue<MoveItem> _lpToAlignerMoveItem = new Queue<MoveItem>();
+        private Queue<MoveItem> _alignerToDummyMoveItem = new Queue<MoveItem>();
+        private Queue<MoveItem> _alignerToSrdMoveItem = new Queue<MoveItem>();
+        private Queue<MoveItem> _dummyToLpMoveItem = new Queue<MoveItem>();
+        private Queue<MoveItem> _dummyToSrdMoveItem = new Queue<MoveItem>();
+        private Queue<MoveItem> _srdToLpMoveItem = new Queue<MoveItem>();
+        
+        private Queue<int> _lpWaferIndex = new Queue<int>(); //记录有LP有Wafer的slot号
+     
+        private int _moveTimeout = 20 * 1000;
+
+        public RobotCycleRoutine(EfemBase efem) : base(ModuleName.EfemRobot)
+        {
+            _efem = efem;
+            _efemPickRoutine = new EfemPickRoutine(efem);
+            _efemPlaceRoutine = new EfemPlaceRoutine(efem);
+
+        }
+
+        public RState Start(params object[] objs)
+        {
+            _lpWaferIndex.Clear();//初始化LP 有wafer的slot号
+            _waferCount = 0; //初始化wafercount的数量
+            if (objs.Length >= 5)
+            {
+                _targetLP = (ModuleName)objs[0];
+                _targetAligner = (ModuleName)objs[1];
+                _targetDummy = (ModuleName)objs[2];
+                _targetSrd = (ModuleName)objs[3];
+            }
+            else
+            {
+                return RState.Failed;
+            }
+            if (!CheckPreCondition())
+            {
+                return RState.Failed;
+            }
+            _moveTimeout = SC.GetValue<int>($"EFEM.MotionTimeout") * 1000;
+            
+            MoveItem lpToAlignerMoveItem = new MoveItem   //LP To Aligner
+            {
+                SourceModule = _targetLP,
+                SourceSlot = _lpWaferIndex.Dequeue(),
+                DestinationModule = ModuleName.Aligner1,
+                DestinationSlot = 0,
+                RobotHand = 0 //表示blade1
+            };
+            _lpToAlignerMoveItem.Enqueue(lpToAlignerMoveItem);
+
+
+           MoveItem alignerToDummyMoveItem = new MoveItem //Aligner To Dummy
+            {
+                SourceModule = ModuleName.Aligner1,
+                SourceSlot = 0,
+                DestinationModule = _targetDummy,
+                DestinationSlot = 0,
+                RobotHand = 0
+            };
+            _alignerToDummyMoveItem.Enqueue(alignerToDummyMoveItem);
+            
+            MoveItem alignerToSrdMoveItem = new MoveItem //Aligner To Srd
+            {
+                SourceModule = ModuleName.Aligner1,
+                SourceSlot = 0,
+                DestinationModule = _targetSrd,
+                DestinationSlot = 0,
+                RobotHand = 0
+            };
+            _alignerToSrdMoveItem.Enqueue(alignerToSrdMoveItem);
+            
+            MoveItem dummyToLpMoveItem = new MoveItem //Dummy To LP
+            {
+                SourceModule = _targetDummy,
+                SourceSlot = 0,
+                DestinationModule = _targetLP,
+                DestinationSlot = _lpToAlignerMoveItem.Peek().SourceSlot, //放回原来LP的slot位置
+                RobotHand = 0
+            };
+            _dummyToLpMoveItem.Enqueue(dummyToLpMoveItem);
+            
+            MoveItem dummyToSrdMoveItem = new MoveItem //Dummy To Srd
+            {
+                SourceModule = _targetDummy,
+                SourceSlot = 0, 
+                DestinationModule = _targetSrd,
+                DestinationSlot = 0,
+                RobotHand = 0
+            };
+            _dummyToSrdMoveItem.Enqueue(dummyToSrdMoveItem);
+            
+            MoveItem srdToLpMoveItem = new MoveItem //SRD To LP
+            {
+                DestinationModule = _targetLP,
+                DestinationSlot = _lpToAlignerMoveItem.Peek().SourceSlot, //放回原来LP的slot位置
+                RobotHand = 0
+            };
+            _srdToLpMoveItem.Enqueue(srdToLpMoveItem);
+
+            return Runner.Start(Module, "Robot Cycle start");
+        }
+        //更新dummy的位置
+        private bool UpdateMoveItem()
+        {
+            if (_lpWaferIndex.Count > 0)
+            {
+                _lpToAlignerMoveItem.Peek().SourceSlot = _lpWaferIndex.Dequeue(); //更新从LP取片的位置
+                if (_targetDummy != ModuleName.Unknown)
+                {
+                    _alignerToDummyMoveItem.Peek().DestinationSlot++; //更新放到Dummy的位置
+                    _dummyToLpMoveItem.Peek().SourceSlot++; //更新从dummy取片的位置,送回LP
+                    _dummyToSrdMoveItem.Peek().SourceSlot++;//更新从dummy取片的位置，送到Srd
+                }
+                _dummyToLpMoveItem.Peek().DestinationSlot = _lpToAlignerMoveItem.Peek().SourceSlot;//更新放回LP的位置。 
+                _srdToLpMoveItem.Peek().DestinationSlot = _lpToAlignerMoveItem.Peek().SourceSlot;//更新放回LP的位置。 
+            }
+            return true;
+        }
+        //清除MoveItem
+        private bool ClearMoveItem()
+        {
+          _lpToAlignerMoveItem.Clear();
+          _alignerToDummyMoveItem.Clear();
+          _alignerToSrdMoveItem.Clear();
+          _dummyToLpMoveItem.Clear();
+          _dummyToSrdMoveItem.Clear();
+          _srdToLpMoveItem.Clear();
+           return true;
+        }
+
+        public RState Monitor()
+        {
+            Runner.LoopStart(RobotCycleStep.LPCycleStrat, "LP Cycle Start", _waferCount, NullFun, _delay_1ms)
+   
+                .LoopRun(RobotCycleStep.PickFromLP, () => { return _efemPickRoutine.Start(_lpToAlignerMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunWithStopStatus(RobotCycleStep.PickFromLPCheck, () => { return CommonFunction.CheckRoutineEndState(_efemPickRoutine); },
+                 () => CheckRoutineStopStatus(_efemPickRoutine, "Efem pick from LP failed"))
+
+                .LoopRun(RobotCycleStep.PlaceToAligner, () => { return _efemPlaceRoutine.Start(_lpToAlignerMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunWithStopStatus(RobotCycleStep.PlaceToAlignerCheck, () => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to aligner failed"))
+
+                .LoopRun(RobotCycleStep.PickFromAligner, () => { return _efemPickRoutine.Start(_alignerToDummyMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunWithStopStatus(RobotCycleStep.PickFromAlignerCheck, () => { return CommonFunction.CheckRoutineEndState(_efemPickRoutine); },
+                 () => CheckRoutineStopStatus(_efemPickRoutine, "Efem pick from aligner failed"))
+
+                .LoopRunIf(RobotCycleStep.PlaceToDummy, _targetDummy != ModuleName.Unknown, () => { return _efemPlaceRoutine.Start(_alignerToDummyMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PlaceToDummyCheck, _targetDummy != ModuleName.Unknown,() => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to dummy failed"))
+
+                .LoopRunIf(RobotCycleStep.PickFromDummy, _targetDummy != ModuleName.Unknown, () => { return _efemPickRoutine.Start(_dummyToLpMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PickFromDummyCheck, _targetDummy != ModuleName.Unknown,() => { return CommonFunction.CheckRoutineEndState(_efemPickRoutine); },
+                 () => CheckRoutineStopStatus(_efemPickRoutine, "Efem pick from dummy failed"))
+
+                //从Dummy到SRD的
+                .LoopRunIf(RobotCycleStep.PlaceToSrd, _targetSrd != ModuleName.Unknown && _targetDummy!=ModuleName.Unknown, () => { return _efemPlaceRoutine.Start(_alignerToSrdMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PlaceToSrdCheck, _targetSrd != ModuleName.Unknown && _targetDummy != ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to srd failed"))
+                .LoopRunIf(RobotCycleStep.PickFromSrd, _targetSrd != ModuleName.Unknown && _targetDummy != ModuleName.Unknown, () => { return _efemPickRoutine.Start(_alignerToSrdMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PickFromSrdCheck, _targetSrd != ModuleName.Unknown && _targetDummy != ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPickRoutine); },
+                 () => CheckRoutineStopStatus(_efemPickRoutine, "Efem pick from srd failed"))
+
+                //从Aligner到SRD的
+                .LoopRunIf(RobotCycleStep.PlaceToSrd, _targetSrd != ModuleName.Unknown && _targetDummy == ModuleName.Unknown, () => { return _efemPlaceRoutine.Start(_dummyToSrdMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PlaceToSrdCheck, _targetSrd != ModuleName.Unknown && _targetDummy == ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to srd failed"))
+                .LoopRunIf(RobotCycleStep.PickFromSrd, _targetSrd != ModuleName.Unknown && _targetDummy == ModuleName.Unknown, () => { return _efemPickRoutine.Start(_dummyToSrdMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PickFromSrdCheck, _targetSrd != ModuleName.Unknown && _targetDummy == ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPickRoutine); },
+                 () => CheckRoutineStopStatus(_efemPickRoutine, "Efem pick from srd failed"))
+
+                //从Dummy回LP
+                .LoopRunIf(RobotCycleStep.PlaceToLP, _targetDummy != ModuleName.Unknown && _targetSrd == ModuleName.Unknown, () => { return _efemPlaceRoutine.Start(_dummyToLpMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PlaceToLPCheck, _targetDummy != ModuleName.Unknown && _targetSrd == ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to LP failed"))
+
+                //从SRD回LP
+                .LoopRunIf(RobotCycleStep.PlaceToLP, _targetSrd != ModuleName.Unknown, () => { return _efemPlaceRoutine.Start(_srdToLpMoveItem) == RState.Running; }, _delay_1ms)
+                .LoopRunIfWithStopStatus(RobotCycleStep.PlaceToLPCheck, _targetSrd != ModuleName.Unknown, () => { return CommonFunction.CheckRoutineEndState(_efemPlaceRoutine); },
+                 () => CheckRoutineStopStatus(_efemPlaceRoutine, "Efem place to LP failed"))
+
+                .LoopEnd(RobotCycleStep.LPCycleEnd, UpdateMoveItem, _delay_1ms)
+                .End(RobotCycleStep.End, ClearMoveItem, _delay_1ms);
+
+
+            return Runner.Status;
+        }
+
+        public void Abort()
+        {
+            _efem.Halt();
+        }
+
+        #region 功能方法
+        private bool CheckPreCondition()
+        {
+            if (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, 0))
+            {
+                Stop($"Efem robot arm already has a wafer, cannot do the RobotCycle action");
+                return false;
+            }
+            //LoadPort状态判断
+            if (ModuleHelper.IsLoadPort(_targetLP) && ModuleHelper.IsInstalled(_targetLP))
+            {
+                Loadport loadPort = GetLoadPort(_targetLP);
+                if (loadPort == null)
+                {
+                    Stop($"{_targetLP} is null");
+                    return false;
+                }
+                if (!loadPort.IsLoaded)
+                {
+                    Stop($"{_targetLP} is not load");
+                    return false;
+                }
+                WaferInfo[] waferInfos = WaferManager.Instance.GetWafers(_targetLP);
+                for (int i = 0; i < waferInfos.Length; i++)
+                {
+                    if (waferInfos[i] != null && !waferInfos[i].IsEmpty)
+                    {
+                        _waferCount++;
+                        _lpWaferIndex.Enqueue(i);
+                    }
+                }
+                if (_waferCount < 1)
+                {
+                    Stop($"there is no wafer in {_targetLP}");
+                    return false;
+                }
+
+            }
+            //Aligner状态判断
+            //if (!ModuleHelper.IsInstalled(_targetAligner))
+            //{
+            //    Stop($"{_targetAligner} is not installed");
+            //    return false;
+            //}
+            //Dummy状态判断
+            if (!ModuleHelper.IsInstalled(_targetDummy))
+            {
+                Stop($"{_targetDummy} is not installed");
+                return false;
+            }
+            //若dummy存在wafer，需要人工处理
+            DummyDevice dummyDevice = Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(_targetDummy - ModuleName.Dummy1);
+            if(dummyDevice != null)
+            {
+                if (!dummyDevice.HasCassette)
+                {
+                    Stop($"{_targetDummy} dose not have cassette");
+                }
+                WaferInfo[] waferInfos = WaferManager.Instance.GetWafers(_targetDummy);
+                foreach (var item in waferInfos)
+                {
+                    if (item != null && !item.IsEmpty)
+                    {
+                        Stop($"There are wafers inside the {_targetDummy},cannot do the RobotCycle action");
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        private Loadport GetLoadPort(ModuleName station)
+        {
+            LoadPortModule loadPortModule = Singleton<RouteManager>.Instance.EFEM.GetLoadportModule(station - ModuleName.LP1);
+            return loadPortModule.LPDevice;
+        }
+
+        private bool CheckRoutineStopStatus(IRoutine routine, string error)
+        {
+            bool result = CommonFunction.CheckRoutineStopState(routine);
+            if (result)
+            {
+                Stop( $"{error}");
+            }
+            return result;
+        }
+
+       
+        #endregion
+    }
+}

CyberX8_Simulator/Devices/SunWayEfemSimulator.cs

@@ -12,7 +12,6 @@ namespace CyberX8_Simulator.Devices
 {
     public class SunWayEfemSimulator : SocketDeviceSimulator
     {
-        private const string CMD_PATTERN = "^MOV|^SET|^GET";
         private const string SCMD        = @"(?<=\:)(.*?)(?=\/)";
         private const string SFOUP       = @"(?<=P)(\d{1})(?=[\;\/])";
         private const string ACK         = "ACK";
@@ -84,38 +83,33 @@ namespace CyberX8_Simulator.Devices
         {
             if (IsConnected)
             {
-                if (!_bCommReady)
-                {
-                    OnWriteMessage("INF:READY/COMM;");
-                }
-            }
-            else
-            {
-                _bCommReady = false;
+                
             }
             return true;
         }
 
         protected override void ProcessUnsplitMessage(string str)
         {
-            if (!_bCommReady && str.Contains("ACK:READY/COMM"))
+
+            string ack = ""; 
+            if (str.StartsWith("RQ LOAD"))
             {
-                _bCommReady = true;
+                ack = "LOAD A OFF\n_RDY";
+            }
+            else if(str.StartsWith("RSR"))
+            {
+                ack = "MAP 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0";
+            }
+            else
+            {
+                ack = str + "\n_RDY"; ;
             }
-
-            if (!Regex.IsMatch(str, CMD_PATTERN))
-                return;
-
-            string[] strStart = str.Split(':');
-            string strCommand= strStart[0];
             // 发送ACK 表示收到
-            string ack = Regex.Replace(str, CMD_PATTERN, ACK);
+            
             OnWriteMessage(ack);
-
             // 处理INF
-            OnWork(ack,strCommand);
+            //OnWork(str);
         }
-
         internal void SetCassetteDoor(bool doorOpen)
         {
             _isMaintainDoorOpen = doorOpen;
@@ -163,7 +157,7 @@ namespace CyberX8_Simulator.Devices
             string msg = $"EVT:SIGSTAT/System/{data:X8}/00000000;";
             OnWriteMessage(msg);
         }
-        private void OnWork(string strACK,string strCommand)
+        private void OnWork(string strACK)
         {
             // match basic
             Match m1 = Regex.Match(strACK, SCMD);
@@ -186,7 +180,7 @@ namespace CyberX8_Simulator.Devices
             // build the INF string
             string strINF = string.Empty;
 
-            switch (EfemConstant.ToOperation(sBasic))
+            switch (EfemConstant.ToOperation(strACK))
             {
                 case EfemOperation.GetWaferInfo:
                     strINF = strACK.Replace(ACK, "INF");
@@ -234,53 +228,12 @@ namespace CyberX8_Simulator.Devices
                     strINF = "INF:STATE/TRACK/NONE/NONE;";
                     break;
                 case EfemOperation.CarrierId:
-                    if (strCommand.StartsWith("GET"))
-                    {
-                        strINF = strACK.Replace(ACK, "INF");
-                        strINF = strINF.TrimEnd(';');
-                        string[] str = strACK.Split(delimiters);
-                        if ("LP1".Equals(str[2]))
-                        {
-                           strINF += $"/{_carrier1ID};";
-                        }
-                        else if ("LP2".Equals(str[2]))
-                        {
-                            strINF += $"/{_carrier2ID};";
-                        }
-                        else
-                        {
-                            strINF += $"/{_carrier3ID};";
-                        }
-                    }
-                    else
-                    {
-                        strINF = strACK.Replace(ACK, "INF");
-                        string[] str = strACK.Split(delimiters);
-                        if ("LP1".Equals(str[2]))
-                        {
-                            _carrier1ID = str[3];
-                        }else if ("LP2".Equals(str[2]))
-                        {
-                            _carrier2ID = str[3];
-                        }
-                        else
-                        {
-                            _carrier3ID = str[3];
-                        }
-                    }
+                    
+                    
                     break;
 
                 case EfemOperation.Size:
-                    strINF = strACK.Replace(ACK, "INF");
-                    strINF = strINF.TrimEnd(';');
-                    if (!"SET".Equals(strCommand))
-                    {
-                        strINF += $"/{WaferSize};";
-                    }
-                    else
-                    {
-                        strINF += ";";
-                    }
+                    
                     break;
                 case EfemOperation.Dock:
                     Match mDock = Regex.Match(strACK, SFOUP);
@@ -315,22 +268,7 @@ namespace CyberX8_Simulator.Devices
                     strINF = strACK.Replace(ACK, "INF");
                     break;
                 case EfemOperation.Speed:
-                    if(strCommand.StartsWith("GET"))
-                    {
-                        strINF = strACK.Replace(ACK, "INF");
-                        strINF = strINF.TrimEnd(';');
-                        strINF += $"/{_speed};";
-                    }
-                    else
-                    {
-                        strINF = strACK.Replace(ACK, "INF");
-                        string[] str = strACK.Split(delimiters);
-                        if(str.Length>=4)
-                        {
-                            string strSpeed = str[3];
-                            _speed = int.Parse(strSpeed);
-                        }
-                    }
+                    
                     break;
                 case EfemOperation.Align:
                 case EfemOperation.Pick:

CyberX8_UI/Config/UIMenu.json

@@ -654,6 +654,12 @@
 				"IsShow": "true",
 				"Name": "EFEM",
 				"View": "EfemView"
+			},
+			{
+				"Id": "RobotCycle",
+				"IsShow": "true",
+				"Name": "RobotCycle",
+				"View": "RobotCycleView"
 			}
 		]
 

CyberX8_UI/Config/UIMenu_permission.json

@@ -379,6 +379,10 @@
 					{
 						"MenuName": "EFEM",
 						"Permission": 2
+					},
+					{
+						"MenuName": "RobotCycle",
+						"Permission": 2
 					}
 				]
 			},