using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Threading;
|
using System.Windows.Forms;
|
|
namespace SHARP_CLAS_UI
|
{
|
public class Ablation : AblationUnit
|
{
|
#region Enum
|
#endregion
|
|
#region Property
|
public bool Is_Power_Measure
|
{
|
get
|
{
|
return (AblationSteps.S5000_AUTO_POWER_START <= Step && Step <= AblationSteps.S5999_AUTO_POWER_END);
|
}
|
}
|
|
public AblationSteps Step
|
{
|
get
|
{
|
return _step;
|
}
|
|
set
|
{
|
_step = value;
|
}
|
}
|
|
public override bool IsWorkEnd
|
{
|
get
|
{
|
if(Step == AblationSteps.S0000_WAIT)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
public override bool IsStayPosition
|
{
|
get
|
{
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
return MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset);
|
}
|
}
|
#endregion
|
|
#region Field
|
private AblationSteps _step;
|
private AblationSteps _oldStep;
|
public AblationHomeSteps _homeStep;
|
|
public Time_Checker Tact_Move = new Time_Checker();
|
|
public Time_Checker Power_Time_Check = new Time_Checker();
|
|
private Thread Ablation_Run_Th;
|
|
List<double> lst_power = new List<double>();
|
|
Form_Auto_Power_Viewer auto_power_view;
|
|
System.Windows.Forms.Timer tmrUi = new System.Windows.Forms.Timer();
|
int retry_cnt;
|
#endregion
|
|
#region Construct
|
public Ablation(Equipment equipment) : base (equipment, MotorAxis.Ablation_X, MotorAxis.Ablation_Z)
|
{
|
Step = AblationSteps.S0000_WAIT;
|
_oldStep = AblationSteps.S0000_WAIT;
|
|
auto_power_view = new Form_Auto_Power_Viewer(equipment);
|
|
pauseDisableList.Add(AblationSteps.S1105_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S1115_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S1135_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S1215_ABLATION_PROCESS_WAIT);
|
pauseDisableList.Add(AblationSteps.S1225_POSITION_CHECK);
|
|
pauseDisableList.Add(AblationSteps.S2105_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S2115_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S2135_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S2215_ABLATION_PROCESS_WAIT);
|
pauseDisableList.Add(AblationSteps.S2225_POSITION_CHECK);
|
|
pauseDisableList.Add(AblationSteps.S3105_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S3115_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S3135_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S3215_ABLATION_PROCESS_WAIT);
|
pauseDisableList.Add(AblationSteps.S3225_POSITION_CHECK);
|
|
pauseDisableList.Add(AblationSteps.S4105_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S4115_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S4135_POSITION_CHECK);
|
pauseDisableList.Add(AblationSteps.S4215_ABLATION_PROCESS_WAIT);
|
pauseDisableList.Add(AblationSteps.S4225_POSITION_CHECK);
|
|
pauseDisableList.Add(AblationSteps.S5220_SCANNER_MOVE_WAIT);
|
|
pauseDisableList.Add(AblationSteps.S5320_LASER_ON);
|
pauseDisableList.Add(AblationSteps.S5330_LASER_ON_CHECK);
|
pauseDisableList.Add(AblationSteps.S5340_POWER_MEASUREMENT_START);
|
pauseDisableList.Add(AblationSteps.S5350_POWER_MEASUREMENT);
|
pauseDisableList.Add(AblationSteps.S5360_POWER_MEASUREMENT_END);
|
pauseDisableList.Add(AblationSteps.S5370_LASER_OFF);
|
pauseDisableList.Add(AblationSteps.S5380_LASER_OFF_CHECK);
|
|
pauseDisableList.Add(AblationSteps.S5420_LASER_ON);
|
pauseDisableList.Add(AblationSteps.S5430_LASER_ON_CHECK);
|
pauseDisableList.Add(AblationSteps.S5440_POWER_MEASUREMENT_START);
|
pauseDisableList.Add(AblationSteps.S5450_POWER_MEASUREMENT);
|
pauseDisableList.Add(AblationSteps.S5460_POWER_MEASUREMENT_END);
|
pauseDisableList.Add(AblationSteps.S5470_LASER_OFF);
|
pauseDisableList.Add(AblationSteps.S5480_LASER_OFF_CHECK);
|
|
MotorX.Check_Jog_Interlock = Jog_Interlock_MotorX;
|
MotorX.Check_Move_Interlock = Move_Interlock_MotorX;
|
MotorZ.Check_Jog_Interlock = Jog_Interlock;
|
MotorZ.Check_Move_Interlock = Move_Interlock;
|
|
tmrUi.Tick += TmrUi_Tick;
|
tmrUi.Interval = 5000;
|
tmrUi.Start();
|
}
|
#endregion
|
|
#region Function
|
private bool Move_Interlock_MotorX()
|
{
|
if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
|
{
|
return true;
|
}
|
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset) == false)
|
{
|
return true;
|
}
|
|
return false;
|
}
|
|
private bool Jog_Interlock_MotorX(bool positive)
|
{
|
if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
|
{
|
return true;
|
}
|
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset) == false)
|
{
|
return true;
|
}
|
|
return false;
|
}
|
|
private bool Move_Interlock()
|
{
|
if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
|
{
|
return true;
|
}
|
|
return false;
|
}
|
|
private bool Jog_Interlock(bool positive)
|
{
|
if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
|
{
|
return true;
|
}
|
|
return false;
|
}
|
|
private void TmrUi_Tick(object sender, EventArgs e)
|
{
|
if (Is_Power_Measure && !auto_power_view.shown)
|
{
|
auto_power_view.shown = true;
|
auto_power_view.Show();
|
auto_power_view.BringToFront();
|
}
|
else if(Is_Power_Measure)
|
{
|
auto_power_view.BringToFront();
|
}
|
}
|
|
public void Auto_Power_View_Show()
|
{
|
auto_power_view.Show();
|
auto_power_view.BringToFront();
|
}
|
|
public void Init_Seq()
|
{
|
Step = AblationSteps.S0000_WAIT;
|
_homeStep = AblationHomeSteps.S0000_WAIT;
|
|
Tact_Move.Reset();
|
}
|
|
public void Seq_Auto()
|
{
|
|
}
|
|
public override void MonitoringStatus()
|
{
|
if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
|
{
|
if (MotorX.MotionComplete == false)
|
{
|
MotorX.Move_Stop();
|
}
|
|
if (MotorZ.MotionComplete == false)
|
{
|
MotorZ.Move_Stop();
|
}
|
|
bool on = false;
|
equipment.scanner.Get_Laser_On(out on);
|
if (on)
|
{
|
equipment.scanner.Set_Stop();
|
equipment.scanner.Set_Laser_Off();
|
}
|
}
|
}
|
|
public override void ExecuteStep()
|
{
|
if (_oldStep != Step)
|
{
|
sequenceChangedTime.Restart();
|
_oldStep = Step;
|
WriteSequenceLog(Step.ToString());
|
}
|
|
if (UnitMode == En_Equipment_Mode.Stop)
|
{
|
Init_Seq();
|
isHomeComplete = false;
|
return;
|
}
|
else if (UnitMode == En_Equipment_Mode.Pause)
|
{
|
if ((AblationSteps.S5320_LASER_ON <= Step && Step <= AblationSteps.S5380_LASER_OFF_CHECK) ||
|
(AblationSteps.S5420_LASER_ON <= Step && Step <= AblationSteps.S5480_LASER_OFF_CHECK))
|
{
|
Seq_Power_Measure();
|
}
|
|
return;
|
}
|
else if (UnitMode == En_Equipment_Mode.Home)
|
{
|
if (!IsHomeComplete)
|
{
|
Seq_Home();
|
}
|
|
return;
|
}
|
else if (UnitMode == En_Equipment_Mode.Auto || UnitMode == En_Equipment_Mode.Manual)
|
{
|
sequenceChangedTime.Start();
|
|
if (equipment.equip_mode == En_Equipment_Mode.Pause)
|
{
|
if (pauseDisableList.Contains(Step) != false)
|
{
|
UnitMode = En_Equipment_Mode.Pause;
|
return;
|
}
|
}
|
|
if (UnitMode == En_Equipment_Mode.Auto)
|
{
|
Seq_Auto();
|
}
|
|
//인터락 위치.
|
Seq_AblationA1();
|
Seq_AblationA2();
|
Seq_AblationB1();
|
Seq_AblationB2();
|
Seq_Power_Measure();
|
}
|
}
|
|
private void Seq_Home()
|
{
|
switch(_homeStep)
|
{
|
case AblationHomeSteps.S0000_WAIT:
|
{
|
_homeStep = AblationHomeSteps.S1000_STATUS_CHECK;
|
break;
|
}
|
case AblationHomeSteps.S1000_STATUS_CHECK:
|
{
|
if (MotorX.ErrorStop)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0321_ABLATION_X_ERROR_STOP);
|
}
|
else if (MotorZ.ErrorStop)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0331_ABLATION_Z_ERROR_STOP);
|
}
|
else if (!MotorX.PowerOn)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0320_ABLATION_X_POWER_OFF);
|
}
|
else if (!MotorZ.PowerOn)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0330_ABLATION_Z_POWER_OFF);
|
}
|
else
|
{
|
_homeStep = AblationHomeSteps.S2000_X_HOME_START;
|
}
|
break;
|
}
|
case AblationHomeSteps.S2000_X_HOME_START:
|
{
|
if (MotorX.Home())
|
{
|
homeCheckedTime.Restart();
|
_homeStep = AblationHomeSteps.S2100_X_HOME_CHECK;
|
}
|
break;
|
}
|
case AblationHomeSteps.S2100_X_HOME_CHECK:
|
{
|
if (homeCheckedTime.Seconds < 1) return;
|
|
if (!MotorX.IsHomed)
|
{
|
if (MotorX.Homing == false && MotorX.ErrorStop)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0321_ABLATION_X_ERROR_STOP);
|
}
|
}
|
else
|
{
|
_homeStep = AblationHomeSteps.S2200_Z_HOME_START;
|
}
|
break;
|
}
|
case AblationHomeSteps.S2200_Z_HOME_START:
|
{
|
if (MotorZ.Home())
|
{
|
_homeStep = AblationHomeSteps.S2300_Z_HOME_CHECK;
|
}
|
break;
|
}
|
case AblationHomeSteps.S2300_Z_HOME_CHECK:
|
{
|
if (!MotorZ.IsHomed)
|
{
|
if (MotorZ.ErrorStop)
|
{
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0331_ABLATION_Z_ERROR_STOP);
|
}
|
}
|
else
|
{
|
_homeStep = AblationHomeSteps.S9999_END;
|
}
|
break;
|
}
|
case AblationHomeSteps.S9999_END:
|
{
|
isHomeComplete = true;
|
_homeStep = AblationHomeSteps.S0000_WAIT;
|
break;
|
}
|
}
|
}
|
|
private void Seq_AblationA1()
|
{
|
switch (Step)
|
{
|
case AblationSteps.S1000_ABLATION_STAGE_1_1_START:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel1;
|
|
if (equipment.process.ablation_stage_1.Stage1.IsExist == false || info.IsAblationWorked || info.Ablation_Run == false)
|
{
|
Step = AblationSteps.S1999_ABLATION_STAGE_1_1_END;
|
}
|
else
|
{
|
Tact_Move.Start();
|
Step = AblationSteps.S1100_MOVE_Z_STAY_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S1100_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S1105_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S1105_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S1110_MOVE_X_ABLATION_POSITION;
|
}
|
else
|
{
|
Step = AblationSteps.S1100_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S1110_MOVE_X_ABLATION_POSITION:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel1;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_A1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_A1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S1115_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S1115_POSITION_CHECK:
|
{
|
Panel_Info info = Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.Ablation_1_1);
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_A1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_A1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.MotionComplete)
|
{
|
if (MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S1120_ABLATION_STAGE_1_CHECK;
|
}
|
else
|
{
|
Step = AblationSteps.S1110_MOVE_X_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S1120_ABLATION_STAGE_1_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel1;
|
|
double position = info.Fine_Align_Y_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_Y_A1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_Y_A1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (equipment.process.ablation_stage_1.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S1130_MOVE_Z_ABLATION_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S1130_MOVE_Z_ABLATION_POSITION:
|
{
|
if (MotorZ.Move_Absolute_Pos(equipment.Cur_Main_Recipe.process_info.Scanner_Z_A1, 500))
|
{
|
Step = AblationSteps.S1135_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S1135_POSITION_CHECK:
|
{
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(equipment.Cur_Main_Recipe.process_info.Scanner_Z_A1, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S1200_LASER_SETTING;
|
}
|
else
|
{
|
Step = AblationSteps.S1130_MOVE_Z_ABLATION_POSITION;
|
}
|
}
|
|
break;
|
}
|
case AblationSteps.S1200_LASER_SETTING:
|
{
|
if (sequenceChangedTime.Seconds < 1) return;
|
|
double jump_speed = 0, mark_speed = 0;
|
short laseron_delay = 0, laseroff_delay = 0;
|
ushort jump_delay = 0, mark_delay = 0, polygon_delay = 0;
|
|
jump_speed = equipment.Cur_Main_Recipe.process_info.Jump_Speed;
|
mark_speed = equipment.Cur_Main_Recipe.process_info.Mark_Speed;
|
laseron_delay = equipment.Cur_Main_Recipe.process_info.Laser_On_Delay;
|
laseroff_delay = equipment.Cur_Main_Recipe.process_info.Laser_Off_Delay;
|
jump_delay = equipment.Cur_Main_Recipe.process_info.Jump_Delay;
|
mark_delay = equipment.Cur_Main_Recipe.process_info.Mark_Delay;
|
polygon_delay = 0;
|
|
if (!equipment.scanner.Set_Process_Datas(jump_speed, mark_speed, laseron_delay, laseroff_delay, jump_delay, mark_delay, polygon_delay))
|
return;
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power + equipment.Setting.Stage_1_1_Power_Offset;
|
|
Panel_Info info = equipment.process.ablation_stage_1.Panel1;
|
info.AblationPower = power;
|
info.AblationTargetPower = equipment.Cur_Main_Recipe.process_info.Target_Power_W;
|
equipment.process.ablation_stage_1.Panel1 = info;
|
|
if (!equipment.scanner.Set_Power(frequency, power))
|
return;
|
|
Step = AblationSteps.S1210_ABLATION_PROCESS_START;
|
|
break;
|
}
|
case AblationSteps.S1210_ABLATION_PROCESS_START:
|
{
|
if (sequenceChangedTime.Seconds < 0.5) return;
|
|
if(equipment.Mode.Ablation_Skip || equipment.process.ablation_stage_1.Stage1.IsExist == false)
|
{
|
Step = AblationSteps.S1215_ABLATION_PROCESS_WAIT;
|
return;
|
}
|
|
Panel_Info info = equipment.process.ablation_stage_1.Panel1;
|
info.IsAblationWorked = true;
|
equipment.process.ablation_stage_1.Panel1 = info;
|
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, true);
|
Ablation_Run_Th = new Thread(() => Ablation_Run(info.Fine_Align_T_Offset + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_T_A1));
|
Ablation_Run_Th.Start();
|
Step = AblationSteps.S1215_ABLATION_PROCESS_WAIT;
|
break;
|
}
|
case AblationSteps.S1215_ABLATION_PROCESS_WAIT:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (moving == false)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S1220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S1220_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S1225_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S1225_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_A1_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S1999_ABLATION_STAGE_1_1_END;
|
}
|
else
|
{
|
Step = AblationSteps.S1220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S1999_ABLATION_STAGE_1_1_END:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (moving == false)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
|
Tact_Move.Stop();
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
private void Seq_AblationA2()
|
{
|
switch (Step)
|
{
|
case AblationSteps.S2000_ABLATION_STAGE_1_2_START:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
|
if (equipment.process.ablation_stage_1.Stage2.IsExist == false || info.IsAblationWorked || info.Ablation_Run == false)
|
{
|
Step = AblationSteps.S2999_ABLATION_STAGE_1_2_END;
|
}
|
else
|
{
|
Tact_Move.Start();
|
Step = AblationSteps.S2100_MOVE_Z_STAY_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S2100_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_A2_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S2105_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S2105_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_A2_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S2110_MOVE_X_ABLATION_POSITION;
|
}
|
else
|
{
|
Step = AblationSteps.S2100_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S2110_MOVE_X_ABLATION_POSITION:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_A2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_A2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S2115_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S2115_POSITION_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_A2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_A2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.MotionComplete)
|
{
|
if (MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S2120_ABLATION_STAGE_1_CHECK;
|
}
|
else
|
{
|
Step = AblationSteps.S2110_MOVE_X_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S2120_ABLATION_STAGE_1_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
|
double position = info.Fine_Align_Y_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_Y_A2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_Y_A2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (equipment.process.ablation_stage_1.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S2130_MOVE_Z_ABLATION_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S2130_MOVE_Z_ABLATION_POSITION:
|
{
|
if (MotorZ.Move_Absolute_Pos(equipment.Cur_Main_Recipe.process_info.Scanner_Z_A2, 500))
|
{
|
Step = AblationSteps.S2135_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S2135_POSITION_CHECK:
|
{
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(equipment.Cur_Main_Recipe.process_info.Scanner_Z_A2, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S2200_LASER_SETTING;
|
}
|
else
|
{
|
Step = AblationSteps.S2130_MOVE_Z_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S2200_LASER_SETTING:
|
{
|
if (sequenceChangedTime.Seconds < 1) return;
|
|
double jump_speed = 0, mark_speed = 0;
|
short laseron_delay = 0, laseroff_delay = 0;
|
ushort jump_delay = 0, mark_delay = 0, polygon_delay = 0;
|
|
jump_speed = equipment.Cur_Main_Recipe.process_info.Jump_Speed;
|
mark_speed = equipment.Cur_Main_Recipe.process_info.Mark_Speed;
|
laseron_delay = equipment.Cur_Main_Recipe.process_info.Laser_On_Delay;
|
laseroff_delay = equipment.Cur_Main_Recipe.process_info.Laser_Off_Delay;
|
jump_delay = equipment.Cur_Main_Recipe.process_info.Jump_Delay;
|
mark_delay = equipment.Cur_Main_Recipe.process_info.Mark_Delay;
|
polygon_delay = 0;
|
|
if (!equipment.scanner.Set_Process_Datas(jump_speed, mark_speed, laseron_delay, laseroff_delay, jump_delay, mark_delay, polygon_delay))
|
return;
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power + equipment.Setting.Stage_1_2_Power_Offset;
|
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
info.AblationPower = power;
|
info.AblationTargetPower = equipment.Cur_Main_Recipe.process_info.Target_Power_W;
|
equipment.process.ablation_stage_1.Panel2 = info;
|
|
if (!equipment.scanner.Set_Power(frequency, power))
|
return;
|
|
Step = AblationSteps.S2210_ABLATION_PROCESS_START;
|
break;
|
}
|
case AblationSteps.S2210_ABLATION_PROCESS_START:
|
{
|
if (sequenceChangedTime.Seconds < 0.5) return;
|
|
if (equipment.Mode.Ablation_Skip || equipment.process.ablation_stage_1.Stage2.IsExist == false)
|
{
|
Step = AblationSteps.S2215_ABLATION_PROCESS_WAIT;
|
return;
|
}
|
|
Panel_Info info = equipment.process.ablation_stage_1.Panel2;
|
info.IsAblationWorked = true;
|
equipment.process.ablation_stage_1.Panel2 = info;
|
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, true);
|
Ablation_Run_Th = new Thread(() => Ablation_Run(info.Fine_Align_T_Offset + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_T_A2));
|
Ablation_Run_Th.Start();
|
|
Step = AblationSteps.S2215_ABLATION_PROCESS_WAIT;
|
break;
|
}
|
case AblationSteps.S2215_ABLATION_PROCESS_WAIT:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if(sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (moving == false)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S2220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S2220_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_A2_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S2225_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S2225_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_A2_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S2999_ABLATION_STAGE_1_2_END;
|
}
|
else
|
{
|
Step = AblationSteps.S2220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S2999_ABLATION_STAGE_1_2_END:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
|
if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (!moving)
|
{
|
Tact_Move.Stop();
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
private void Seq_AblationB1()
|
{
|
switch (Step)
|
{
|
case AblationSteps.S3000_ABLATION_STAGE_2_1_START:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
|
if (equipment.process.ablation_stage_2.Stage1.IsExist == false || info.IsAblationWorked || info.Ablation_Run == false)
|
{
|
Step = AblationSteps.S1999_ABLATION_STAGE_1_1_END;
|
}
|
else
|
{
|
Tact_Move.Start();
|
Step = AblationSteps.S3100_MOVE_Z_STAY_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S3100_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S3105_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S3105_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S3110_MOVE_X_ABLATION_POSITION;
|
}
|
else
|
{
|
Step = AblationSteps.S3100_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S3110_MOVE_X_ABLATION_POSITION:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_B1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_B1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S3115_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S3115_POSITION_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_B1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_B1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.MotionComplete)
|
{
|
if (MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S3120_ABLATION_STAGE_2_CHECK;
|
}
|
else
|
{
|
Step = AblationSteps.S3110_MOVE_X_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S3120_ABLATION_STAGE_2_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
|
double position = info.Fine_Align_Y_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_Y_B1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_Y_B1;
|
position = double.Parse(position.ToString("F3"));
|
|
if (equipment.process.ablation_stage_2.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S3130_MOVE_Z_ABLATION_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S3130_MOVE_Z_ABLATION_POSITION:
|
{
|
if (MotorZ.Move_Absolute_Pos(equipment.Cur_Main_Recipe.process_info.Scanner_Z_B1, 500))
|
{
|
Step = AblationSteps.S3135_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S3135_POSITION_CHECK:
|
{
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(equipment.Cur_Main_Recipe.process_info.Scanner_Z_B1, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S3200_LASER_SETTING;
|
}
|
else
|
{
|
Step = AblationSteps.S3130_MOVE_Z_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S3200_LASER_SETTING:
|
{
|
if (MotorZ.MotionComplete && MotorX.MotionComplete && sequenceChangedTime.Seconds< 1) return;
|
|
double jump_speed = 0, mark_speed = 0;
|
short laseron_delay = 0, laseroff_delay = 0;
|
ushort jump_delay = 0, mark_delay = 0, polygon_delay = 0;
|
|
jump_speed = equipment.Cur_Main_Recipe.process_info.Jump_Speed;
|
mark_speed = equipment.Cur_Main_Recipe.process_info.Mark_Speed;
|
laseron_delay = equipment.Cur_Main_Recipe.process_info.Laser_On_Delay;
|
laseroff_delay = equipment.Cur_Main_Recipe.process_info.Laser_Off_Delay;
|
jump_delay = equipment.Cur_Main_Recipe.process_info.Jump_Delay;
|
mark_delay = equipment.Cur_Main_Recipe.process_info.Mark_Delay;
|
polygon_delay = 0;
|
|
if (!equipment.scanner.Set_Process_Datas(jump_speed, mark_speed, laseron_delay, laseroff_delay, jump_delay, mark_delay, polygon_delay))
|
return;
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power + equipment.Setting.Stage_2_1_Power_Offset;
|
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
info.AblationPower = power;
|
info.AblationTargetPower = equipment.Cur_Main_Recipe.process_info.Target_Power_W;
|
equipment.process.ablation_stage_2.Panel1 = info;
|
|
if (!equipment.scanner.Set_Power(frequency, power))
|
return;
|
|
Step = AblationSteps.S3210_ABLATION_PROCESS_START;
|
break;
|
}
|
case AblationSteps.S3210_ABLATION_PROCESS_START:
|
{
|
if (sequenceChangedTime.Seconds < 0.5) return;
|
|
if (equipment.Mode.Ablation_Skip || equipment.process.ablation_stage_2.Stage1.IsExist == false)
|
{
|
Step = AblationSteps.S3215_ABLATION_PROCESS_WAIT;
|
return;
|
}
|
|
Panel_Info info = equipment.process.ablation_stage_2.Panel1;
|
info.IsAblationWorked = true;
|
equipment.process.ablation_stage_2.Panel1 = info;
|
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, true);
|
Ablation_Run_Th = new Thread(() => Ablation_Run(info.Fine_Align_T_Offset + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_T_B1));
|
Ablation_Run_Th.Start();
|
|
Step = AblationSteps.S3215_ABLATION_PROCESS_WAIT;
|
break;
|
}
|
case AblationSteps.S3215_ABLATION_PROCESS_WAIT:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (!moving)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S3220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S3220_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_B1_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S3225_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S3225_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_B1_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S3999_ABLATION_STAGE_2_1_END;
|
}
|
else
|
{
|
Step = AblationSteps.S3220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S3999_ABLATION_STAGE_2_1_END:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (!moving)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Tact_Move.Stop();
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
private void Seq_AblationB2()
|
{
|
switch (Step)
|
{
|
case AblationSteps.S4000_ABLATION_STAGE_2_2_START:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
|
if (equipment.process.ablation_stage_2.Stage2.IsExist == false || info.IsAblationWorked || info.Ablation_Run == false)
|
{
|
Step = AblationSteps.S4999_ABLATION_STAGE_2_2_END;
|
}
|
else
|
{
|
Tact_Move.Start();
|
Step = AblationSteps.S4100_MOVE_Z_STAY_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S4100_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S4105_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S4105_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S4110_MOVE_X_ABLATION_POSITION;
|
}
|
else
|
{
|
Step = AblationSteps.S4100_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S4110_MOVE_X_ABLATION_POSITION:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_B2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_B2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S4115_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S4115_POSITION_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
|
double position = info.Fine_Align_X_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_X_B2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_B2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (MotorX.MotionComplete)
|
{
|
if (MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S4120_ABLATION_STAGE_2_CHECK;
|
}
|
else
|
{
|
Step = AblationSteps.S4110_MOVE_X_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S4120_ABLATION_STAGE_2_CHECK:
|
{
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
|
double position = info.Fine_Align_Y_Offset + equipment.Cur_Main_Recipe.process_info.Scanner_Y_B2 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_Y_B2;
|
position = double.Parse(position.ToString("F3"));
|
|
if (equipment.process.ablation_stage_2.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S4130_MOVE_Z_ABLATION_POSITION;
|
}
|
break;
|
}
|
case AblationSteps.S4130_MOVE_Z_ABLATION_POSITION:
|
{
|
if (MotorZ.Move_Absolute_Pos(equipment.Cur_Main_Recipe.process_info.Scanner_Z_B2, 500))
|
{
|
Step = AblationSteps.S4135_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S4135_POSITION_CHECK:
|
{
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(equipment.Cur_Main_Recipe.process_info.Scanner_Z_B2, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S4200_LASER_SETTING;
|
}
|
else
|
{
|
Step = AblationSteps.S4130_MOVE_Z_ABLATION_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S4200_LASER_SETTING:
|
{
|
if (sequenceChangedTime.Seconds < 1) return;
|
|
double jump_speed = 0, mark_speed = 0;
|
short laseron_delay = 0, laseroff_delay = 0;
|
ushort jump_delay = 0, mark_delay = 0, polygon_delay = 0;
|
|
jump_speed = equipment.Cur_Main_Recipe.process_info.Jump_Speed;
|
mark_speed = equipment.Cur_Main_Recipe.process_info.Mark_Speed;
|
laseron_delay = equipment.Cur_Main_Recipe.process_info.Laser_On_Delay;
|
laseroff_delay = equipment.Cur_Main_Recipe.process_info.Laser_Off_Delay;
|
jump_delay = equipment.Cur_Main_Recipe.process_info.Jump_Delay;
|
mark_delay = equipment.Cur_Main_Recipe.process_info.Mark_Delay;
|
polygon_delay = 0;
|
|
if (!equipment.scanner.Set_Process_Datas(jump_speed, mark_speed, laseron_delay, laseroff_delay, jump_delay, mark_delay, polygon_delay))
|
return;
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power + equipment.Setting.Stage_2_2_Power_Offset;
|
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
info.AblationPower = power;
|
info.AblationTargetPower = equipment.Cur_Main_Recipe.process_info.Target_Power_W;
|
equipment.process.ablation_stage_2.Panel2 = info;
|
|
if (!equipment.scanner.Set_Power(frequency, power))
|
return;
|
|
Step = AblationSteps.S4210_ABLATION_PROCESS_START;
|
break;
|
}
|
case AblationSteps.S4210_ABLATION_PROCESS_START:
|
{
|
if (sequenceChangedTime.Seconds < 0.5) return;
|
|
if (equipment.Mode.Ablation_Skip || equipment.process.ablation_stage_2.Stage2.IsExist == false)
|
{
|
Step = AblationSteps.S4215_ABLATION_PROCESS_WAIT;
|
return;
|
}
|
|
Panel_Info info = equipment.process.ablation_stage_2.Panel2;
|
info.IsAblationWorked = true;
|
equipment.process.ablation_stage_2.Panel2 = info;
|
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, true);
|
Ablation_Run_Th = new Thread(() => Ablation_Run(info.Fine_Align_T_Offset + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_T_B2));
|
Ablation_Run_Th.Start();
|
|
Step = AblationSteps.S4215_ABLATION_PROCESS_WAIT;
|
break;
|
}
|
case AblationSteps.S4215_ABLATION_PROCESS_WAIT:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (!moving)
|
{
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S4220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S4220_MOVE_Z_STAY_POSITION:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.Move_Absolute_Pos(position, 500))
|
{
|
Step = AblationSteps.S4225_POSITION_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S4225_POSITION_CHECK:
|
{
|
double position = Get_Scanner_Z_B2_Stay_Position();
|
|
if (MotorZ.MotionComplete)
|
{
|
if (MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset))
|
{
|
Step = AblationSteps.S4999_ABLATION_STAGE_2_2_END;
|
}
|
else
|
{
|
Step = AblationSteps.S4220_MOVE_Z_STAY_POSITION;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S4999_ABLATION_STAGE_2_2_END:
|
{
|
if (Ablation_Run_Th != null && Ablation_Run_Th.ThreadState != ThreadState.Stopped)
|
{
|
return;
|
}
|
else if (sequenceChangedTime.Seconds > 1)
|
{
|
bool moving;
|
equipment.scanner.Get_Busy(out moving);
|
|
if (!moving)
|
{
|
Tact_Move.Stop();
|
equipment.Board_Control.IO_manager.Set_Output(OutputData.LASER_LED_Electronic_Board, false);
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
|
break;
|
}
|
}
|
}
|
|
private void Seq_Power_Measure()
|
{
|
//Laser 출사 위치에서 Power Meter위치가 아닐 때 Laser off 후 첫 Step으로 이동.
|
if((AblationSteps.S5320_LASER_ON <= Step && Step <= AblationSteps.S5360_POWER_MEASUREMENT_END) ||
|
(AblationSteps.S5420_LASER_ON <= Step && Step <= AblationSteps.S5460_POWER_MEASUREMENT_END))
|
{
|
if (equipment.process.ablation.Get_Is_Position_X_Power_Meter() == false || equipment.process.ablation.Get_Is_Position_Z_Power_Meter() == false)
|
{
|
if (equipment.scanner.Set_Laser_Off())
|
{
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
}
|
|
switch (Step)
|
{
|
case AblationSteps.S5000_AUTO_POWER_START:
|
{
|
if (!auto_power_view.shown) return;
|
|
retry_cnt = 0;
|
auto_power_view.Clear_Info();
|
auto_power_view.Add_Info($"{DateTime.Now} Auto Power Start");
|
Step = AblationSteps.S5100_POWER_METER_STATUS_CHECK;
|
break;
|
}
|
case AblationSteps.S5100_POWER_METER_STATUS_CHECK:
|
{
|
if (equipment.power_meter.Check_Power_Meter_Status())
|
{
|
Step = AblationSteps.S5110_MEASURE_MODE_SET_W;
|
}
|
else
|
{
|
auto_power_view.Add_Info($"Power Meter Status Fail");
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
break;
|
}
|
case AblationSteps.S5110_MEASURE_MODE_SET_W:
|
{
|
equipment.power_meter.Set_Measurement_Mode_W();
|
Step = AblationSteps.S5120_MEASURE_MODE_SET_CHECK;
|
break;
|
}
|
case AblationSteps.S5120_MEASURE_MODE_SET_CHECK:
|
{
|
if (equipment.power_meter.Check_Measurement_Mode_W())
|
{
|
Step = AblationSteps.S5130_ZERO_SET;
|
}
|
break;
|
}
|
case AblationSteps.S5130_ZERO_SET:
|
{
|
equipment.power_meter.Set_Zero();
|
Step = AblationSteps.S5210_SCANNER_POSITION_MOVE;
|
break;
|
}
|
case AblationSteps.S5210_SCANNER_POSITION_MOVE:
|
{
|
if (equipment.process.ablation.Move_X_Power_Meter_Position())
|
{
|
if (equipment.process.ablation.Move_Z_Power_Meter_Position())
|
{
|
Step = AblationSteps.S5220_SCANNER_MOVE_WAIT;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S5220_SCANNER_MOVE_WAIT:
|
{
|
if (equipment.process.ablation.MotorX.MotionComplete && equipment.process.ablation.MotorZ.MotionComplete)
|
{
|
if (equipment.process.ablation.Get_Is_Position_X_Power_Meter() && equipment.process.ablation.Get_Is_Position_Z_Power_Meter())
|
{
|
auto_power_view.Add_Info($"Scanner Position Move");
|
Step = AblationSteps.S5300_SCANNER_INIT;
|
}
|
else
|
{
|
Step = AblationSteps.S5210_SCANNER_POSITION_MOVE;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S5300_SCANNER_INIT:
|
{
|
if (equipment.Cur_Main_Recipe.process_info == null) return;
|
|
if (equipment.scanner.Initialize(equipment.Cur_Main_Recipe.process_info.CTB_File_Path))
|
{
|
Step = AblationSteps.S5310_TARGET_POWER_SET;
|
}
|
else
|
{
|
//Interlock.
|
}
|
break;
|
}
|
case AblationSteps.S5310_TARGET_POWER_SET:
|
{
|
int frequency = equipment.Power_Parameter.Target_Setting_Frequency;
|
double power = equipment.Power_Parameter.Target_Setting_Power;
|
|
if (equipment.scanner.Set_Power(frequency, power))
|
{
|
auto_power_view.Add_Info($"Target Power Set.");
|
auto_power_view.Add_Info($"Frequency : {frequency}");
|
auto_power_view.Add_Info($"Power : {power}");
|
|
Step = AblationSteps.S5320_LASER_ON;
|
}
|
break;
|
}
|
case AblationSteps.S5320_LASER_ON:
|
{
|
if (equipment.process.ablation.MotorX.MotionComplete && equipment.process.ablation.MotorZ.MotionComplete)
|
{
|
if (equipment.process.ablation.Get_Is_Position_X_Power_Meter() && equipment.process.ablation.Get_Is_Position_Z_Power_Meter())
|
{
|
if (equipment.scanner.Set_Laser_On())
|
{
|
auto_power_view.Add_Info($"Laser On.");
|
Step = AblationSteps.S5330_LASER_ON_CHECK;
|
}
|
}
|
else
|
{
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S5330_LASER_ON_CHECK:
|
{
|
if (equipment.sm.Get_Bit(Input_Memory_Address.Laser_Active))
|
{
|
Step = AblationSteps.S5340_POWER_MEASUREMENT_START;
|
}
|
break;
|
}
|
case AblationSteps.S5340_POWER_MEASUREMENT_START:
|
{
|
if (sequenceChangedTime.Seconds < 5) return;
|
|
auto_power_view.Add_Info($"Target Measrue Start.");
|
lst_power.Clear();
|
Power_Time_Check.Start();
|
Step = AblationSteps.S5350_POWER_MEASUREMENT;
|
break;
|
}
|
case AblationSteps.S5350_POWER_MEASUREMENT:
|
{
|
if (Power_Time_Check.Seconds < equipment.Power_Parameter.Measurement_Time_Sec)
|
{
|
double power = equipment.power_meter.Read_Power();
|
lst_power.Add(power);
|
|
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Energy, power);
|
|
if (lst_power.Count != 0)
|
{
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Average, lst_power.Average());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Max, lst_power.Max());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Min, lst_power.Min());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Count, lst_power.Count);
|
}
|
else
|
{
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Average, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Max, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Min, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Count, 0);
|
}
|
}
|
else
|
{
|
Step = AblationSteps.S5360_POWER_MEASUREMENT_END;
|
}
|
break;
|
}
|
case AblationSteps.S5360_POWER_MEASUREMENT_END:
|
{
|
Step = AblationSteps.S5370_LASER_OFF;
|
break;
|
}
|
case AblationSteps.S5370_LASER_OFF:
|
{
|
if (equipment.scanner.Set_Laser_Off())
|
{
|
Step = AblationSteps.S5380_LASER_OFF_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S5380_LASER_OFF_CHECK:
|
{
|
if (!equipment.sm.Get_Bit(Input_Memory_Address.Laser_Active))
|
{
|
auto_power_view.Add_Info($"Laser Off.");
|
Step = AblationSteps.S5390_ENERGY_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S5390_ENERGY_CHECK:
|
{
|
if(lst_power.Count == 0)
|
{
|
//alarm.
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0942_POWER_COUNT_IS_EMPTY);
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
|
double averager = lst_power.Average();
|
|
double min = equipment.Power_Parameter.Target_Power - equipment.Power_Parameter.Target_Margin_of_Error;
|
double max = equipment.Power_Parameter.Target_Power + equipment.Power_Parameter.Target_Margin_of_Error;
|
|
if (min <= averager && averager <= max)
|
{
|
auto_power_view.Add_Info($"Target Measure Success");
|
auto_power_view.Add_Info($"Target : {equipment.Power_Parameter.Target_Power}");
|
auto_power_view.Add_Info($"Averager : {averager}");
|
auto_power_view.Add_Info($"Max : {lst_power.Max()}");
|
auto_power_view.Add_Info($"Min : {lst_power.Min()}");
|
|
Step = AblationSteps.S5400_SCANNER_INIT;
|
}
|
else
|
{
|
//Target Alarm
|
auto_power_view.Add_Info($"Target Measure Fail");
|
|
auto_power_view.Add_Info($"Target : {equipment.Power_Parameter.Target_Power}");
|
auto_power_view.Add_Info($"Averager : {averager}");
|
auto_power_view.Add_Info($"Max : {lst_power.Max()}");
|
auto_power_view.Add_Info($"Min : {lst_power.Min()}");
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0940_TARGET_POWER_ERROR);
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
break;
|
}
|
case AblationSteps.S5400_SCANNER_INIT:
|
{
|
if (equipment.Cur_Main_Recipe.process_info == null) return;
|
|
if (equipment.scanner.Initialize(equipment.Cur_Main_Recipe.process_info.CTB_File_Path))
|
{
|
Step = AblationSteps.S5410_RECIPE_POWER_SET;
|
}
|
else
|
{
|
//Interlock.
|
}
|
break;
|
}
|
case AblationSteps.S5410_RECIPE_POWER_SET:
|
{
|
if (sequenceChangedTime.Seconds < 5) return;
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power;
|
|
if (equipment.scanner.Set_Power(frequency, power))
|
{
|
Step = AblationSteps.S5420_LASER_ON;
|
}
|
break;
|
}
|
case AblationSteps.S5420_LASER_ON:
|
{
|
if (equipment.process.ablation.MotorX.MotionComplete && equipment.process.ablation.MotorZ.MotionComplete)
|
{
|
if (equipment.process.ablation.Get_Is_Position_X_Power_Meter() && equipment.process.ablation.Get_Is_Position_Z_Power_Meter())
|
{
|
if (equipment.scanner.Set_Laser_On())
|
{
|
auto_power_view.Add_Info($"Laser On.");
|
Step = AblationSteps.S5430_LASER_ON_CHECK;
|
}
|
}
|
else
|
{
|
Step = AblationSteps.S0000_WAIT;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S5430_LASER_ON_CHECK:
|
{
|
if (equipment.sm.Get_Bit(Input_Memory_Address.Laser_Active))
|
{
|
auto_power_view.Add_Info($"Laser On");
|
Step = AblationSteps.S5440_POWER_MEASUREMENT_START;
|
}
|
break;
|
}
|
case AblationSteps.S5440_POWER_MEASUREMENT_START:
|
{
|
if (sequenceChangedTime.Seconds < 5) return;
|
|
auto_power_view.Add_Info($"Recipe Measrue Start.");
|
lst_power.Clear();
|
Power_Time_Check.Start();
|
Step = AblationSteps.S5450_POWER_MEASUREMENT;
|
break;
|
}
|
case AblationSteps.S5450_POWER_MEASUREMENT:
|
{
|
if (Power_Time_Check.Seconds < equipment.Power_Parameter.Measurement_Time_Sec)
|
{
|
double power = equipment.power_meter.Read_Power();
|
lst_power.Add(power);
|
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Energy, power);
|
|
if (lst_power.Count != 0)
|
{
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Average, lst_power.Average());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Max, lst_power.Max());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Min, lst_power.Min());
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Count, lst_power.Count);
|
}
|
else
|
{
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Average, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Max, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Min, 0);
|
equipment.sm.Set_Value(Process_Memory_Address.Power_Meter_Count, 0);
|
}
|
}
|
else
|
{
|
Step = AblationSteps.S5460_POWER_MEASUREMENT_END;
|
}
|
break;
|
}
|
case AblationSteps.S5460_POWER_MEASUREMENT_END:
|
{
|
Step = AblationSteps.S5470_LASER_OFF;
|
break;
|
}
|
case AblationSteps.S5470_LASER_OFF:
|
{
|
if (equipment.scanner.Set_Laser_Off())
|
{
|
Step = AblationSteps.S5480_LASER_OFF_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S5480_LASER_OFF_CHECK:
|
{
|
if (!equipment.sm.Get_Bit(Input_Memory_Address.Laser_Active))
|
{
|
auto_power_view.Add_Info($"Lsaer Off");
|
Step = AblationSteps.S5490_ENERGEY_CHECK;
|
}
|
break;
|
}
|
case AblationSteps.S5490_ENERGEY_CHECK:
|
{
|
if (lst_power.Count == 0)
|
{
|
//alarm.
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0942_POWER_COUNT_IS_EMPTY);
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
|
double averager = lst_power.Average();
|
|
double min = equipment.Cur_Main_Recipe.process_info.Target_Power_W - equipment.Power_Parameter.Recipe_Margin_of_Error;
|
double max = equipment.Cur_Main_Recipe.process_info.Target_Power_W + equipment.Power_Parameter.Recipe_Margin_of_Error;
|
|
if (min <= averager && averager <= max)
|
{
|
auto_power_view.Add_Info($"Recipe Measure Succeess");
|
|
auto_power_view.Add_Info($"Target : {equipment.Cur_Main_Recipe.process_info.Target_Power_W}");
|
auto_power_view.Add_Info($"Averager : {averager}");
|
auto_power_view.Add_Info($"Max : {lst_power.Max()}");
|
auto_power_view.Add_Info($"Min : {lst_power.Min()}");
|
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
else
|
{
|
if (retry_cnt < equipment.Power_Parameter.Power_Revision_Count)
|
{
|
auto_power_view.Add_Info($"Recipe Measure Fail");
|
auto_power_view.Add_Info($"Target : {equipment.Cur_Main_Recipe.process_info.Target_Power_W}");
|
auto_power_view.Add_Info($"Averager : {averager}");
|
auto_power_view.Add_Info($"Max : {lst_power.Max()}");
|
auto_power_view.Add_Info($"Min : {lst_power.Min()}");
|
|
auto_power_view.Add_Info($"Recipe Measure Retry");
|
retry_cnt++;
|
Step = AblationSteps.S5510_RECIPE_POWER_CHANGE;
|
}
|
else
|
{
|
//Target Alarm
|
auto_power_view.Add_Info($"Recipe Measure Fail");
|
|
auto_power_view.Add_Info($"Target : {equipment.Cur_Main_Recipe.process_info.Target_Power_W}");
|
auto_power_view.Add_Info($"Averager : {averager}");
|
auto_power_view.Add_Info($"Max : {lst_power.Max()}");
|
auto_power_view.Add_Info($"Min : {lst_power.Min()}");
|
Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0941_RECIPE_POWER_ERROR);
|
Step = AblationSteps.S5999_AUTO_POWER_END;
|
}
|
}
|
break;
|
}
|
case AblationSteps.S5510_RECIPE_POWER_CHANGE:
|
{
|
double com_power = equipment.Cur_Main_Recipe.process_info.Target_Power_W - lst_power.Average();
|
|
int frequency = equipment.Cur_Main_Recipe.process_info.Frequency;
|
double power = equipment.Cur_Main_Recipe.process_info.Power + com_power;
|
|
Main_Recipe recipe = equipment.Cur_Main_Recipe.Clone();
|
|
auto_power_view.Add_Info($"Recipe Name : {recipe.process_info.Name}");
|
auto_power_view.Add_Info($"Current Power : {recipe.process_info.Power}");
|
auto_power_view.Add_Info($"Change Power : {power.ToString("F1")}");
|
|
recipe.process_info.Power = double.Parse(power.ToString("F1"));
|
|
Process_Info_Manager.Instance.Save_Recipe(recipe.process_info.Name, recipe.process_info);
|
Main_Recipe_Manager.Instance.Save_Recipe(recipe.Name, recipe);
|
|
Step = AblationSteps.S5410_RECIPE_POWER_SET;
|
break;
|
}
|
case AblationSteps.S5999_AUTO_POWER_END:
|
{
|
Parameter_Power parameter = equipment.Power_Parameter.Clone();
|
parameter.Measure_Date = DateTime.Now;
|
Parameter_Power_Manager.Instance.Save_Parameter_Power(parameter);
|
|
auto_power_view.Add_Info($"Auto Power Check End.");
|
Step = AblationSteps.S0000_WAIT;
|
break;
|
}
|
}
|
}
|
|
public bool Auto_Power_Start()
|
{
|
if (Step == AblationSteps.S0000_WAIT)
|
{
|
Step = AblationSteps.S5000_AUTO_POWER_START;
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
private void Ablation_Run(double degree)
|
{
|
bool moving;
|
|
do
|
{
|
equipment.scanner.Get_Busy(out moving);
|
} while (moving);
|
|
Thread th;
|
|
if (equipment.Cur_Main_Recipe.process_info.Draw_Info_1.Draw)
|
{
|
th = new Thread(() => Ablation_Run(equipment.Cur_Main_Recipe.process_info.Draw_Info_1, degree));
|
th.Start();
|
while (th.ThreadState != ThreadState.Stopped) { }
|
}
|
|
if (equipment.Cur_Main_Recipe.process_info.Draw_Info_2.Draw)
|
{
|
th = new Thread(() => Ablation_Run(equipment.Cur_Main_Recipe.process_info.Draw_Info_2, degree));
|
th.Start();
|
while (th.ThreadState != ThreadState.Stopped) { }
|
}
|
|
if (equipment.Cur_Main_Recipe.process_info.Draw_Info_3.Draw)
|
{
|
th = new Thread(() => Ablation_Run(equipment.Cur_Main_Recipe.process_info.Draw_Info_3, degree));
|
th.Start();
|
while (th.ThreadState != ThreadState.Stopped) { }
|
}
|
|
if (equipment.Cur_Main_Recipe.process_info.Draw_Info_4.Draw)
|
{
|
th = new Thread(() => Ablation_Run(equipment.Cur_Main_Recipe.process_info.Draw_Info_4, degree));
|
th.Start();
|
while (th.ThreadState != ThreadState.Stopped) { }
|
}
|
}
|
|
private void Ablation_Run(Process_Draw_Info draw_info, double degree)
|
{
|
Scanner_Recipe rec;
|
|
bool moving;
|
|
float work_area_x, work_area_y;
|
float start_x, end_x, start_y, end_y, distance, draw_distance;
|
int repeat, range, draw_repeat;
|
|
Scanner_Recipe.Ablation_Style waveform;
|
|
work_area_x = equipment.Cur_Main_Recipe.process_info.Work_Area_X;
|
work_area_y = equipment.Cur_Main_Recipe.process_info.Work_Area_Y;
|
|
start_x = draw_info.Start_X;
|
end_x = draw_info.End_X;
|
start_y = draw_info.Start_Y;
|
end_y = draw_info.End_Y;
|
|
distance = equipment.Cur_Main_Recipe.process_info.Hatch_Distance;
|
repeat = equipment.Cur_Main_Recipe.process_info.Jump_Repeat;
|
range = equipment.Cur_Main_Recipe.process_info.Jump_Range;
|
|
draw_distance = draw_info.Distance;
|
draw_repeat = draw_info.Repeat;
|
|
waveform = (Scanner_Recipe.Ablation_Style)equipment.Cur_Main_Recipe.process_info.Waveform;
|
|
if (draw_info.Reverse)
|
rec = new Scanner_Recipe(work_area_x, work_area_y, start_x, start_y, end_x, end_y, distance, repeat, range, 0, draw_distance, 0, draw_repeat, waveform, degree, draw_info.Reverse);
|
else
|
rec = new Scanner_Recipe(work_area_x, work_area_y, start_x, start_y, end_x, end_y, distance, repeat, range, draw_distance, 0, draw_repeat, 0, waveform, degree, draw_info.Reverse);
|
|
do
|
{
|
equipment.scanner.Get_Busy(out moving);
|
} while (moving);
|
|
equipment.scanner.Set_Start_List(1);
|
|
equipment.Write_Scanner_Log($"degree : {degree}, reverse : {draw_info.Reverse}");
|
|
foreach (Scanner_Position_Info info in rec.Recipe_Pos_Info)
|
{
|
if (info.mark)
|
{
|
equipment.scanner.Set_Mark_Abs(info.x, info.y);
|
}
|
else
|
{
|
equipment.scanner.Set_Jump_Abs(info.x, info.y);
|
}
|
}
|
|
equipment.scanner.Set_End_Of_List();
|
equipment.scanner.Set_Excute_List(1);
|
|
do
|
{
|
equipment.scanner.Get_Busy(out moving);
|
} while (moving);
|
}
|
|
public bool Move_X_Power_Meter_Position()
|
{
|
object value;
|
double position;
|
double velocity;
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_X_Power_Meter_Position, out value);
|
position = double.Parse($"{value}");
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_X_Power_Meter_Velocity, out value);
|
velocity = double.Parse($"{value}");
|
|
return MotorX.Move_Absolute_Pos(position, velocity);
|
}
|
|
public bool Move_Z_Power_Meter_Position()
|
{
|
object value;
|
double position;
|
double velocity;
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_Power_Meter_Position, out value);
|
position = double.Parse($"{value}");
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_Power_Meter_Velocity, out value);
|
velocity = double.Parse($"{value}");
|
|
return MotorZ.Move_Absolute_Pos(position, velocity);
|
}
|
|
public bool Get_Is_Position_X_Power_Meter()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_X_Power_Meter_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return MotorX.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
|
}
|
|
public bool Get_Is_Position_Z_Power_Meter()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_Power_Meter_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return MotorZ.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
|
}
|
|
public double Get_Scanner_Z_A1_Stay_Position()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_A1_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return get_position;
|
}
|
|
public double Get_Scanner_Z_A2_Stay_Position()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_A2_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return get_position;
|
}
|
|
public double Get_Scanner_Z_B1_Stay_Position()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_B1_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return get_position;
|
}
|
|
public double Get_Scanner_Z_B2_Stay_Position()
|
{
|
object value;
|
double get_position;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_B2_Position, out value);
|
get_position = double.Parse($"{value}");
|
|
return get_position;
|
}
|
|
public bool StageA1AblationStart()
|
{
|
if (Step != AblationSteps.S0000_WAIT)
|
{
|
return false;
|
}
|
else
|
{
|
Step = AblationSteps.S1000_ABLATION_STAGE_1_1_START;
|
return true;
|
}
|
}
|
|
public bool StageA2AblationStart()
|
{
|
if (Step != AblationSteps.S0000_WAIT)
|
{
|
return false;
|
}
|
else
|
{
|
Step = AblationSteps.S2000_ABLATION_STAGE_1_2_START;
|
return true;
|
}
|
}
|
|
public bool StageB1AblationStart()
|
{
|
if (Step != AblationSteps.S0000_WAIT)
|
{
|
return false;
|
}
|
else
|
{
|
Step = AblationSteps.S3000_ABLATION_STAGE_2_1_START;
|
return true;
|
}
|
}
|
|
public bool StageB2AblationStart()
|
{
|
if (Step != AblationSteps.S0000_WAIT)
|
{
|
return false;
|
}
|
else
|
{
|
Step = AblationSteps.S4000_ABLATION_STAGE_2_2_START;
|
return true;
|
}
|
}
|
|
public bool Move_Cleaning_Position()
|
{
|
object value;
|
|
equipment.sm.Get_Value(Position_Parameter_Address.Scanner_Z_A1_Position, out value);
|
double position = double.Parse($"{value}");
|
|
return MotorX.Move_Absolute_Pos(0, 500) && MotorZ.Move_Absolute_Pos(position, 500);
|
}
|
|
public void Stage1WaitPositionMove()
|
{
|
double position = equipment.Cur_Main_Recipe.process_info.Scanner_X_A1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_A1;
|
position = double.Parse(position.ToString("F3"));
|
|
MotorX.Move_Absolute_Pos(position, 500);
|
}
|
|
public void Stage2WaitPositionMove()
|
{
|
double position = equipment.Cur_Main_Recipe.process_info.Scanner_X_B1 + equipment.Cur_Main_Recipe.panel_type_info.Scanner_Offset_X_B1;
|
position = double.Parse(position.ToString("F3"));
|
|
MotorX.Move_Absolute_Pos(position, 500);
|
}
|
#endregion
|
}
|
}
|
