Example #1
0
        public void MTMoveToICForInspectMask()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MTMC = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var ICMC = MachineMgr.CtrlMachines[EnumMachineID.MID_IC_A_ASB.ToString()] as MacMcInspectionCh;
            var ICMS = ICMC.StateMachine;
            var MTMS = MTMC.StateMachine;

            var IC_Task = Task.Factory.StartNew(() => { ICMS.SystemBootup(); });
            var MT_Task = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });

            Task.WaitAll(IC_Task, MT_Task);
            MTMS.LPHomeClampedToICHomeClamped();
            //Mask進入IC檢測Glass面
            MTMS.ICHomeClampedToICGlassReleaseReturnToICHome();
            ICMS.InspectGlass();
            MTMS.ICHomeToICGlassGetReturnToICClamped();
            ICMS.ReturnToIdleAfterReleaseGlass();

            //Mask進入IC檢測Pellicle面
            MTMS.ICHomeClampedToICReleaseReturnToICHome();
            ICMS.InspectPellicle();
            MTMS.ICHomeToICGetReturnToICClamped();
            ICMS.ReturnToIdleAfterReleasePellicle();
            MTMS.ICHomeClampedToICHomeInspected();
        }
Example #2
0
        public void TestMethod1()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var MS          = MachineCtrl.StateMachine;

            MS.SystemBootup();
            bool BankIn  = true;
            bool BankOut = false;

            if (BankIn)
            {
                MS.MoveToOpenStageGet();
                MS.MoveToCabinetPut("0101");
            }
            else if (BankOut)
            {
                MS.MoveToCabinetGet("0101");
                MS.MoveToOpenStagePut();
            }
            else
            {
                MS.MoveToLock();
                MS.MoveToUnlock();
            }
        }
Example #3
0
        public UtMcCabinet()
        {
            _machine = new MacMsCabinet();
            //
            var DrawerMachineIdRange = EnumMachineID.MID_DRAWER_01_01.GetDrawerStateMachineIDRange();
            var MachineMgr           = new MacMachineMgr();

            MachineMgr.MvCfInit();
            MachineControls  = new List <MacMcCabinetDrawer>();
            DicStateMachines = new Dictionary <EnumMachineID, MacMsCabinetDrawer>();

            for (var i = (int)DrawerMachineIdRange.StartID; i <= (int)DrawerMachineIdRange.EndID; i++)
            {
                var machineId = ((EnumMachineID)i);
                try
                {
                    var control = MachineMgr.CtrlMachines[machineId.ToString()] as MacMcCabinetDrawer;
                    MachineControls.Add(control);
                    DicStateMachines.Add(machineId, control.StateMachine);
                }
                catch (Exception ex)
                {
                }
            }
        }
Example #4
0
        public void ReleaseMask()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_OS_A_ASB.ToString()] as MacMcOpenStage;
            var MS          = MachineCtrl.StateMachine;

            MS.SystemBootup();
            MS.InputBoxWithMask();
            MS.CalibrationClosedBoxWithMask();
            MS.OpenBoxWithMask();
            if (false)//如果沒有取出Mask(非常態)
            {
                MS.ReturnCloseBoxWithMask();
                MS.ReleaseBoxWithMask();
                MS.ReturnToIdleAfterReleaseBoxWithMask();
            }
            else//如果有取出Mask
            {
                MS.CloseBox();
                MS.ReleaseBox();
                MS.ReturnToIdleAfterReleaseBox();
            }
        }
Example #5
0
        public UtMcLoadport()
        {
            // StateMachineA = MacMsLoadPort.LoadPortStateMachineA;
            //   StateMachineB = MacMsLoadPort.LoadPortStateMachineB;

            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MachineCtrlA = MachineMgr.CtrlMachines[EnumLoadportStateMachineID.MID_LP_A_ASB.ToString()] as MacMcLoadPort;
            var MachineCtrlB = MachineMgr.CtrlMachines[EnumLoadportStateMachineID.MID_LP_B_ASB.ToString()] as MacMcLoadPort;

            StateMachineA = MachineCtrlA.StateMachine;
            StateMachineB = MachineCtrlB.StateMachine;
        }
Example #6
0
        public void MTMoveToCCForCleanMask()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MTMC = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var CCMC = MachineMgr.CtrlMachines[EnumMachineID.MID_CC_A_ASB.ToString()] as MacMcCleanCh;
            var CCMS = CCMC.StateMachine;
            var MTMS = MTMC.StateMachine;

            var CC_Task = Task.Factory.StartNew(() => { CCMS.SystemBootup(); });
            var MT_Task = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });

            Task.WaitAll(CC_Task, MT_Task);
            MTMS.ICHomeInspectedToCCHomeClamped();
            //清理Glass面並進行檢測
            MTMS.CCHomeClampedToCCGlass();
            MTMS.InCCGlassMoveToClean();
            MT_Task = Task.Factory.StartNew(() => MTMS.CleanGlass());
            CC_Task = Task.Factory.StartNew(() => CCMS.CleanGlass());
            Task.WaitAll(MT_Task);
            CC_Task = Task.Factory.StartNew(() => CCMS.FinishCleanGlass());
            MTMS.CCGlassCleanedReturnInCCGlass();
            MTMS.InCCGlassMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => MTMS.InspectGlass());
            CC_Task = Task.Factory.StartNew(() => CCMS.InspectGlass());
            Task.WaitAll(MT_Task);
            CC_Task = Task.Factory.StartNew(() => CCMS.FinishInspectGlass());
            MTMS.CCGlassInspectedReturnInCCGlass();
            MTMS.InCCGlassToCCHomeClamped();

            //清理Pellicle面並進行檢測
            MTMS.CCHomeClampedToCC();
            MTMS.InCCMoveToClean();
            MT_Task = Task.Factory.StartNew(() => MTMS.CleanPellicle());
            CC_Task = Task.Factory.StartNew(() => CCMS.CleanPellicle());
            Task.WaitAll(MT_Task);
            CC_Task = Task.Factory.StartNew(() => CCMS.FinishCleanPellicle());
            MTMS.CCCleanedReturnInCC();
            MTMS.InCCMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => MTMS.InspectPellicle());
            CC_Task = Task.Factory.StartNew(() => CCMS.InspectPellicle());
            Task.WaitAll(MT_Task);
            CC_Task = Task.Factory.StartNew(() => CCMS.FinishInspectPellicle());
            MTMS.CCInspectedReturnInCC();
            MTMS.InCCToCCHomeClamped();

            MTMS.CCHomeClampedToCCHomeCleaned();
        }
Example #7
0
        //[DataRow(BoxrobotTransferLocation.Drawer_01_01)]
        //[DataRow(BoxrobotTransferLocation.Drawer_07_01)]
        public void TestMethod_BankOut(/*BoxrobotTransferLocation drawerNumber*/)
        {
            // DataRow
            BoxrobotTransferLocation drawerNumber = BoxrobotTransferLocation.Drawer_01_01;

            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var MS          = MachineCtrl.StateMachine;

            MS.Initial();
            MS.MoveToCabinetGet(drawerNumber);
            MS.MoveToOpenStagePut();
        }
Example #8
0
 public void LPAToOS()
 {
     try
     {
         var MachineMgr = new MacMachineMgr();
         MachineMgr.MvCfInit();
         var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
         var MS          = MachineCtrl.StateMachine;
         MS.SystemBootup();
         MS.LPHomeToLPAGetMaskReturnToLPHomeClamped();
         MS.LPHomeClampedToOSReleaseMaskReturnToLPHome();
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #9
0
 public void InspectGlass()
 {
     try
     {
         var MachineMgr = new MacMachineMgr();
         MachineMgr.MvCfInit();
         var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_IC_A_ASB.ToString()] as MacMcInspectionCh;
         var MS          = MachineCtrl.StateMachine;
         MS.SystemBootup();
         MS.InspectGlass();
         MS.ReturnToIdleAfterReleaseGlass();
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #10
0
        public void BankIn()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var LPAMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_A_ASB.ToString()] as MacMcLoadPort;
            var LPBMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_B_ASB.ToString()] as MacMcLoadPort;
            var MTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var OSMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_OS_A_ASB.ToString()] as MacMcOpenStage;
            var BTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var CBMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_DRAWER_01_01.ToString()] as MacMcCabinetDrawer;

            var LPAMS = LPAMC.StateMachine;
            var LPBMS = LPBMC.StateMachine;
            var MTMS  = MTMC.StateMachine;
            var OSMS  = OSMC.StateMachine;
            var BTMS  = BTMC.StateMachine;
            var CBMS  = CBMC.StateMachine;


            var LPA_Task = Task.Factory.StartNew(() => { LPAMS.SystemBootup(); });
            var LPB_Task = Task.Factory.StartNew(() => { LPBMS.SystemBootup(); });
            var MT_Task  = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });
            var OS_Task  = Task.Factory.StartNew(() => { OSMS.SystemBootup(); OSMS.InputBox(); });
            var BT_Task  = Task.Factory.StartNew(() => { BTMS.SystemBootup(); });
            var CB_Task  = Task.Factory.StartNew(() => { CBMS.SystemBootup(); CBMS.Unload_MoveTrayToIn(); });

            Task.WaitAll(BT_Task, CB_Task);
            BTMS.MoveToCabinetGet("0101");
            Task.WaitAll(OS_Task);
            BTMS.MoveToOpenStagePut();
            OSMS.CalibrationClosedBox();
            BTMS.MoveToUnlock();
            OS_Task = Task.Factory.StartNew(() => { OSMS.OpenBox(); });
            Task.WaitAll(LPA_Task, LPB_Task, MT_Task);
            MTMS.LPHomeToLPAGetMaskReturnToLPHomeClamped();
            Task.WaitAll(OS_Task);
            MTMS.LPHomeClampedToOSReleaseMaskReturnToLPHome();
            OSMS.CloseBoxWithMask();
            BTMS.MoveToLock();
            OSMS.ReleaseBoxWithMask();
            BTMS.MoveToOpenStageGet();
            OS_Task = Task.Factory.StartNew(() => { OSMS.ReturnToIdleAfterReleaseBoxWithMask(); });
            BTMS.MoveToCabinetPut("0101");
        }
Example #11
0
        public void TestMethod1()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_CC_A_ASB.ToString()] as MacMcCleanCh;
            var MS          = MachineCtrl.StateMachine;

            MS.SystemBootup();
            MS.CleanPellicle();
            MS.FinishCleanPellicle();
            MS.InspectPellicle();
            MS.FinishInspectPellicle();
            MS.CleanGlass();
            MS.FinishCleanGlass();
            MS.InspectGlass();
            MS.FinishInspectGlass();
        }
Example #12
0
        public void TestMethod1()
        {
            using (var machineMgr = new MacMachineMgr())
            {
                machineMgr.MvCfInit();
                machineMgr.MvCfLoad();



                machineMgr.RecipeMgr.LoaddRecipe("UserData/Recipe/RecipeFlow_Ocap.xml");
                machineMgr.RecipeMgr.Execute();



                machineMgr.MvCfUnload();
                machineMgr.MvCfFree();
            }
        }
Example #13
0
        public void MTMoveToOSGetAndPut()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var MTMC = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var OSMC = MachineMgr.CtrlMachines[EnumMachineID.MID_OS_A_ASB.ToString()] as MacMcOpenStage;
            var BTMC = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var OSMS = OSMC.StateMachine;
            var MTMS = MTMC.StateMachine;
            var BTMS = BTMC.StateMachine;

            var OS_Task = Task.Factory.StartNew(() => { OSMS.SystemBootup(); });
            var MT_Task = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });
            var BT_Task = Task.Factory.StartNew(() => { BTMS.SystemBootup(); });

            Task.WaitAll(OS_Task, MT_Task, BT_Task);
            //將空盒放上OS開盒,由MT放入Mask並關盒由BT取走盒子
            OSMS.InputBox();
            OSMS.CalibrationClosedBox();
            BTMS.MoveToUnlock();
            OSMS.OpenBox();
            MTMS.LPHomeClampedToOSReleaseMaskReturnToLPHome();
            OSMS.CloseBoxWithMask();
            BTMS.MoveToLock();
            OSMS.ReleaseBoxWithMask();
            BTMS.MoveToOpenStageGet();
            OSMS.ReturnToIdleAfterReleaseBoxWithMask();

            //將盒子放上OS開盒,由MT取出Mask並關盒由BT取走空盒
            OSMS.InputBoxWithMask();
            OSMS.CalibrationClosedBoxWithMask();
            BTMS.MoveToUnlock();
            OSMS.OpenBox();
            MTMS.LPHomeToOSGetMaskReturnToLPHomeClamped();
            OSMS.CloseBox();
            BTMS.MoveToLock();
            OSMS.ReleaseBox();
            BTMS.MoveToOpenStageGet();
            OSMS.ReturnToIdleAfterReleaseBox();
        }
Example #14
0
 public void LPACleanedToLPA()
 {
     try
     {
         var MachineMgr = new MacMachineMgr();
         MachineMgr.MvCfInit();
         var MachineCtrl = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
         var MS          = MachineCtrl.StateMachine;
         MS.SystemBootup();
         MS.LPHomeToLPAGetMaskReturnToLPHomeClamped();
         MS.LPHomeClampedToICHomeClamped();
         MS.ICHomeClampedToICReleaseReturnToICHome();
         MS.ICHomeToICGetReturnToICClamped();
         MS.ICHomeClampedToICGlassReleaseReturnToICHome();
         MS.ICHomeToICGlassGetReturnToICClamped();
         MS.ICHomeClampedToICHomeInspected();
         MS.ICHomeInspectedToCCHomeClamped();
         MS.CCHomeClampedToCC();
         MS.InCCMoveToClean();
         MS.CCCleanedReturnInCC();
         MS.InCCMoveToInspect();
         MS.CCInspectedReturnInCC();
         MS.InCCToCCHomeClamped();
         MS.CCHomeClampedToCCGlass();
         MS.InCCGlassMoveToClean();
         MS.CCGlassCleanedReturnInCCGlass();
         MS.InCCGlassMoveToInspect();
         MS.CCGlassInspectedReturnInCCGlass();
         MS.InCCGlassToCCHomeClamped();
         MS.CCHomeClampedToCCHomeCleaned();
         MS.CCHomeCleanedToLPHomeCleaned();
         MS.LPHomeCleanedToLPARelease();
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #15
0
        public void MTMoveToLPBGetAndPut()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var LPAMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_A_ASB.ToString()] as MacMcLoadPort;
            var LPBMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_B_ASB.ToString()] as MacMcLoadPort;
            var MTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var LPAMS = LPAMC.StateMachine;
            var LPBMS = LPBMC.StateMachine;
            var MTMS  = MTMC.StateMachine;

            var LPA_Task = Task.Factory.StartNew(() => { LPAMS.SystemBootup(); });
            var LPB_Task = Task.Factory.StartNew(() => { LPBMS.SystemBootup(); });
            var MT_Task  = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });

            Task.WaitAll(LPA_Task, LPB_Task, MT_Task);
            LPBMS.Dock();
            MTMS.LPHomeToLPBGetMaskReturnToLPHomeClamped();
            MTMS.LPHomeInspectedToLPBRelease();
            //MTMS.LPHomeCleanedToLPBRelease();
            LPBMS.Undock();
        }
Example #16
0
        public void BTMoveToCBGetAndPut()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var BTMC = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var CBMC = MachineMgr.CtrlMachines[EnumMachineID.MID_DRAWER_01_01.ToString()] as MacMcCabinetDrawer;
            var BTMS = BTMC.StateMachine;
            var CBMS = CBMC.StateMachine;

            var BT_Task = Task.Factory.StartNew(() => { BTMS.SystemBootup(); });
            var CB_Task = Task.Factory.StartNew(() => { CBMS.SystemBootup(); });

            Task.WaitAll(CB_Task, BT_Task);
            //放入盒子到Cabinet_01_01
            CBMS.Load_MoveTrayToIn();
            BTMS.MoveToCabinetPut("0101");
            CBMS.Load_MoveTrayToHome();

            //從Cabinet_01_01取出盒子
            CBMS.Unload_MoveTrayToIn();
            BTMS.MoveToCabinetGet("0101");
            CBMS.Unload_MoveTrayToHome();
        }
Example #17
0
        public void BankOut()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var LPAMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_A_ASB.ToString()] as MacMcLoadPort;
            var LPBMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_B_ASB.ToString()] as MacMcLoadPort;
            var MTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var OSMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_OS_A_ASB.ToString()] as MacMcOpenStage;
            var BTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_BT_A_ASB.ToString()] as MacMcBoxTransfer;
            var CBMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_DRAWER_01_01.ToString()] as MacMcCabinetDrawer;
            var ICMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_IC_A_ASB.ToString()] as MacMcInspectionCh;
            var CCMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_CC_A_ASB.ToString()] as MacMcCleanCh;

            var LPAMS = LPAMC.StateMachine;
            var LPBMS = LPBMC.StateMachine;
            var MTMS  = MTMC.StateMachine;
            var OSMS  = OSMC.StateMachine;
            var BTMS  = BTMC.StateMachine;
            var CBMS  = CBMC.StateMachine;
            var ICMS  = ICMC.StateMachine;
            var CCMS  = CCMC.StateMachine;

            var LPA_Task = Task.Factory.StartNew(() => { LPAMS.SystemBootup(); });
            var LPB_Task = Task.Factory.StartNew(() => { LPBMS.SystemBootup(); });
            var MT_Task  = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });
            var OS_Task  = Task.Factory.StartNew(() => { OSMS.SystemBootup(); OSMS.InputBox(); });
            var BT_Task  = Task.Factory.StartNew(() => { BTMS.SystemBootup(); });
            var CB_Task  = Task.Factory.StartNew(() => { CBMS.SystemBootup(); CBMS.Unload_MoveTrayToIn(); });
            var IC_Task  = Task.Factory.StartNew(() => { ICMS.SystemBootup(); });
            var CC_Task  = Task.Factory.StartNew(() => { CCMS.SystemBootup(); });

            Task.WaitAll(BT_Task, CB_Task);
            BTMS.MoveToCabinetGet("0101");
            Task.WaitAll(OS_Task);
            BTMS.MoveToOpenStagePut();
            OSMS.CalibrationClosedBoxWithMask();
            BTMS.MoveToUnlock();
            OSMS.OpenBoxWithMask();
            Task.WaitAll(LPA_Task, LPB_Task, MT_Task);
            MTMS.LPHomeToOSGetMaskReturnToLPHomeClamped();
            MTMS.LPHomeClampedToICHomeClamped();
            //To IC Inspect Glass
            MTMS.ICHomeClampedToICGlassReleaseReturnToICHome();
            ICMS.InspectGlass();
            MTMS.ICHomeToICGlassGetReturnToICClamped();
            //To IC Inspect Pellicle
            MTMS.ICHomeClampedToICReleaseReturnToICHome();
            ICMS.InspectPellicle();
            MTMS.ICHomeToICGetReturnToICClamped();

            MTMS.ICHomeClampedToICHomeInspected();
            MTMS.ICHomeInspectedToCCHomeClamped();
            //To CC Clean Glass
            MTMS.CCHomeClampedToCCGlass();
            MTMS.InCCGlassMoveToClean();
            MT_Task = Task.Factory.StartNew(() => { MTMS.CleanGlass(); });
            CCMS.CleanGlass();
            Task.WaitAll(MT_Task);
            CCMS.FinishCleanGlass();
            MTMS.CCGlassCleanedReturnInCCGlass();
            MTMS.InCCGlassMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => { MTMS.InspectGlass(); });
            CCMS.InspectGlass();
            Task.WaitAll(MT_Task);
            CCMS.FinishInspectGlass();
            MTMS.CCGlassInspectedReturnInCCGlass();
            MTMS.InCCGlassToCCHomeClamped();
            //To CC Clean Pellicle
            MTMS.CCHomeClampedToCC();
            MTMS.InCCMoveToClean();
            MT_Task = Task.Factory.StartNew(() => { MTMS.CleanPellicle(); });
            CCMS.CleanPellicle();
            Task.WaitAll(MT_Task);
            CCMS.FinishCleanPellicle();
            MTMS.CCCleanedReturnInCC();
            MTMS.InCCMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => { MTMS.InspectPellicle(); });
            CCMS.InspectPellicle();
            Task.WaitAll(MT_Task);
            CCMS.FinishInspectPellicle();
            MTMS.CCInspectedReturnInCC();
            MTMS.InCCToCCHomeClamped();

            MT_Task = Task.Factory.StartNew(() =>
            {
                MTMS.CCHomeClampedToCCHomeCleaned();
                MTMS.CCHomeCleanedToLPHomeCleaned();

                MTMS.LPHomeCleanedToLPARelease();
            });

            OSMS.CloseBox();
            BTMS.MoveToLock();
            OSMS.ReleaseBox();
            BTMS.MoveToOpenStageGet();
            OS_Task = Task.Factory.StartNew(() => { OSMS.ReturnToIdleAfterReleaseBox(); });
            BTMS.MoveToCabinetPut("0101");
        }
Example #18
0
        public void OCAP()
        {
            var MachineMgr = new MacMachineMgr();

            MachineMgr.MvCfInit();
            var LPAMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_A_ASB.ToString()] as MacMcLoadPort;
            var LPBMC = MachineMgr.CtrlMachines[EnumMachineID.MID_LP_B_ASB.ToString()] as MacMcLoadPort;
            var MTMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_MT_A_ASB.ToString()] as MacMcMaskTransfer;
            var ICMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_IC_A_ASB.ToString()] as MacMcInspectionCh;
            var CCMC  = MachineMgr.CtrlMachines[EnumMachineID.MID_CC_A_ASB.ToString()] as MacMcCleanCh;
            var LPAMS = LPAMC.StateMachine;
            var LPBMS = LPBMC.StateMachine;
            var MTMS  = MTMC.StateMachine;
            var ICMS  = ICMC.StateMachine;
            var CCMS  = CCMC.StateMachine;


            var LPA_Task = Task.Factory.StartNew(() => { LPAMS.SystemBootup(); });
            var LPB_Task = Task.Factory.StartNew(() => { LPBMS.SystemBootup(); });
            var IC_Task  = Task.Factory.StartNew(() => { ICMS.SystemBootup(); });
            var CC_Task  = Task.Factory.StartNew(() => { CCMS.SystemBootup(); });
            var MT_Task  = Task.Factory.StartNew(() => { MTMS.SystemBootup(); });

            Task.WaitAll(LPA_Task, LPB_Task, MT_Task);
            MTMS.LPHomeToLPAGetMaskReturnToLPHomeClamped();
            MTMS.LPHomeClampedToICHomeClamped();
            //To IC Inspect Glass
            MTMS.ICHomeClampedToICGlassReleaseReturnToICHome();
            ICMS.InspectGlass();
            MTMS.ICHomeToICGlassGetReturnToICClamped();
            //To IC Inspect Pellicle
            MTMS.ICHomeClampedToICReleaseReturnToICHome();
            ICMS.InspectPellicle();
            MTMS.ICHomeToICGetReturnToICClamped();

            MTMS.ICHomeClampedToICHomeInspected();
            MTMS.ICHomeInspectedToCCHomeClamped();
            //To CC Clean Glass
            MTMS.CCHomeClampedToCCGlass();
            MTMS.InCCGlassMoveToClean();
            MT_Task = Task.Factory.StartNew(() => { MTMS.CleanGlass(); });
            CCMS.CleanGlass();
            Task.WaitAll(MT_Task);
            CCMS.FinishCleanGlass();
            MTMS.CCGlassCleanedReturnInCCGlass();
            MTMS.InCCGlassMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => { MTMS.InspectGlass(); });
            CCMS.InspectGlass();
            Task.WaitAll(MT_Task);
            CCMS.FinishInspectGlass();
            MTMS.CCGlassInspectedReturnInCCGlass();
            MTMS.InCCGlassToCCHomeClamped();
            //To CC Clean Pellicle
            MTMS.CCHomeClampedToCC();
            MTMS.InCCMoveToClean();
            MT_Task = Task.Factory.StartNew(() => { MTMS.CleanPellicle(); });
            CCMS.CleanPellicle();
            Task.WaitAll(MT_Task);
            CCMS.FinishCleanPellicle();
            MTMS.CCCleanedReturnInCC();
            MTMS.InCCMoveToInspect();
            MT_Task = Task.Factory.StartNew(() => { MTMS.InspectPellicle(); });
            CCMS.InspectPellicle();
            Task.WaitAll(MT_Task);
            CCMS.FinishInspectPellicle();
            MTMS.CCInspectedReturnInCC();
            MTMS.InCCToCCHomeClamped();

            MTMS.CCHomeClampedToCCHomeCleaned();
            MTMS.CCHomeCleanedToLPHomeCleaned();

            MTMS.LPHomeCleanedToLPARelease();
        }
Example #19
0
 public void TestMethod1()
 {
     using (var machineMgr = new MacMachineMgr())
     {
     }
 }