using System;
|
using System.Threading;
|
|
namespace SA_LTT.Module
|
{
|
public class PreAligner : ComPort
|
{
|
public enum ErrorCode
|
{
|
None,
|
PinUpError,
|
PinDownError,
|
VaccumError,
|
NoWafer,
|
WaferLimitErrorAfterAlign,
|
NotFoundNotch,
|
StageLimitError = 9,
|
InvalidAlignCommand,
|
ChuckArrangeError,
|
WaferAlignCCDOver,
|
WaferLimitErrorBeforeAlign,
|
RetractHome = 16,
|
WaferExist,
|
CCDModuleError = 30,
|
AlignerTypeError = 50,
|
CommandError = 999,
|
}
|
|
private Equipment _equipment;
|
private Thread t_statusUpdate;
|
private Thread t_commandWriteRead;
|
private string _version;
|
|
private double _positionX;
|
private double _positionY;
|
private double _positionT;
|
|
private bool _isWaferExist;
|
private bool _isVacuumOn;
|
private bool _isHome;
|
private bool _isAlignRun;
|
|
private bool _lockCheck;
|
private object _thisLock = new object();
|
|
private int waitTime = 100;
|
public ErrorCode error;
|
|
private SequenceTimer _timer = new SequenceTimer();
|
|
public string Version
|
{
|
get
|
{
|
return _version;
|
}
|
|
set
|
{
|
_version = value;
|
}
|
}
|
|
public double PositionX
|
{
|
get
|
{
|
return _positionX;
|
}
|
|
set
|
{
|
_positionX = value;
|
}
|
}
|
|
public double PositionY
|
{
|
get
|
{
|
return _positionY;
|
}
|
|
set
|
{
|
_positionY = value;
|
}
|
}
|
|
public double PositionT
|
{
|
get
|
{
|
return _positionT;
|
}
|
|
set
|
{
|
_positionT = value;
|
}
|
}
|
|
public bool IsHome
|
{
|
get
|
{
|
return _isHome;
|
}
|
|
set
|
{
|
_isHome = value;
|
}
|
}
|
|
public bool IsWaferExist
|
{
|
get
|
{
|
return _isWaferExist;
|
}
|
|
set
|
{
|
_isWaferExist = value;
|
}
|
}
|
|
public bool IsVacuumOn
|
{
|
get
|
{
|
return _isVacuumOn;
|
}
|
|
set
|
{
|
_isVacuumOn = value;
|
}
|
}
|
|
public bool IsAlignRun
|
{
|
get
|
{
|
return _isAlignRun;
|
}
|
|
set
|
{
|
_isAlignRun = value;
|
}
|
}
|
|
public bool IsRunEnable
|
{
|
get
|
{
|
if(IsOpen && (t_commandWriteRead == null || t_commandWriteRead.ThreadState == ThreadState.Stopped))
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
public PreAligner(Equipment equipment)
|
{
|
serialPort.PortName = "COM4";
|
serialPort.DataBits = 8;
|
serialPort.Parity = System.IO.Ports.Parity.None;
|
serialPort.StopBits = System.IO.Ports.StopBits.One;
|
serialPort.BaudRate = 19200;
|
ReceiveWaitSeconds = 0.1;
|
Terminator = null;
|
|
_equipment = equipment;
|
|
error = ErrorCode.None;
|
t_statusUpdate = new Thread(statusUpdate);
|
t_statusUpdate.Start();
|
}
|
|
public void statusUpdate()
|
{
|
while (_equipment.IsDisposed == false)
|
{
|
try
|
{
|
Thread.Sleep(waitTime);
|
|
if (IsOpen)
|
{
|
if (IsRunEnable)
|
{
|
ReadPosition();
|
ReadStatus();
|
}
|
}
|
else
|
{
|
if (_equipment.alarmManager.OccurredAlarms.Exists(x => x.Code == AlarmCode.AL_0051_PRE_ALIGNER_DISCONNECTED))
|
{
|
|
}
|
else
|
{
|
if (Open() == false)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0051_PRE_ALIGNER_DISCONNECTED);
|
}
|
else
|
{
|
if (ReadVersion() == false)
|
{
|
Close();
|
}
|
else
|
{
|
//Home();
|
}
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
}
|
}
|
|
public void Align(double angle)
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
IsAlignRun = true;
|
|
if (angle < 0)
|
{
|
angle = 0;
|
}
|
else if (angle > 359.999)
|
{
|
angle = 359.999;
|
}
|
|
string str = WriteRead($"ALIGN {angle:f3}");
|
string str1 = Read(10);
|
//ALIGN 90.000\rEND\r
|
|
string[] datas = str.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
string errorCode = datas[1].Split(' ')[1];
|
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), errorCode);
|
SetAlarmCode(error);
|
}
|
|
datas = str1.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
string errorCode = datas[1].Split(' ')[1];
|
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), errorCode);
|
SetAlarmCode(error);
|
}
|
|
Thread.Sleep(100);
|
|
string log = WriteRead($"RQ POSITION");
|
EquipmentLogManager.Instance.WritePreAlignLog("Result : " + log.Replace('\r', ' '));
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
IsAlignRun = false;
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
);
|
|
t_commandWriteRead.Start();
|
}
|
|
/// <summary>
|
/// 얼라인 이후에 각도 변경
|
/// </summary>
|
/// <param name="angle"></param>
|
public void Again(double angle)
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
IsAlignRun = true;
|
|
if (angle < 0)
|
{
|
angle = 0;
|
}
|
else if (angle > 359.999)
|
{
|
angle = 359.999;
|
}
|
|
string str = WriteRead($"AGAIN {angle:f3}");
|
|
string[] datas = str.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), datas[1].Split(' ')[1]);
|
SetAlarmCode(error);
|
}
|
|
Thread.Sleep(waitTime);
|
//AGAIN 0.000\rEND\r
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
IsAlignRun = false;
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public bool ReadVersion()
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string receivedData = WriteRead($"VER");
|
string[] datas = receivedData.Split('\r');
|
|
if (datas.Length == 3)
|
{
|
Version = datas[1];
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
return false;
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void Home()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"HOME");
|
str = Read(20);
|
//HOME\rEND\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public void VacuumOn()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"VAC ON");
|
str = Read(5);
|
|
string[] datas = str.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), datas[1].Split(' ')[1]);
|
SetAlarmCode(error);
|
}
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public void VacuumOff()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"VAC OFF");
|
|
string[] datas = str.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), datas[1].Split(' ')[1]);
|
SetAlarmCode(error);
|
}
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public void PinUp()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
t_commandWriteRead.Start();
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"PIN UP");
|
//PIN UP\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
}
|
|
public void PinDown()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"PIN DN");
|
//PIN DN\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public void ReadStatus()
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"STATUS");
|
//STATUS\r[0:ON 1:OFF] VAC:1 WF1:1 WF2:0 START:1 CLR:1 HOME:1 IN4:1 RUN:1 WAF:0 VAC:1 ALM:0\r
|
string[] datas = str.Split('\r');
|
|
if(datas.Length == 3)
|
{
|
string[] status = datas[1].Split(' ');
|
|
IsHome = status[7].Split(':')[1] == "0" ? true : false;
|
IsWaferExist = status[10].Split(':')[1] == "0" ? true : false;
|
IsVacuumOn = status[11].Split(':')[1] == "0" ? true : false;
|
}
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadLog()
|
{
|
string str = WriteRead($"RQ LOG");
|
|
|
}
|
public void ReadAlarmCode()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
|
});
|
|
t_commandWriteRead.Start();
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"ALARM CODE");
|
str = Read(20);
|
//ALARM CODE\rNO_ALARM\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadPinStatus()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
|
});
|
|
t_commandWriteRead.Start();
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"RQ PIN");
|
//RQ PIN\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadWaferStatus()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
|
});
|
|
t_commandWriteRead.Start();
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"RQ WAFER");
|
//RQ WAFER\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadVaccumStatus()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
|
});
|
|
t_commandWriteRead.Start();
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"RQ VAC");
|
//RQ VAC\r[OFF]\r
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadParameter()
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"RQ PARA");
|
str = Read(3);
|
//"RQ PARA\r\rVER 1.2(DX)-01\rTYPE 1\rDEEP 0.6\rDEEX 1.5\rRETRY 5\rSET 000.00\rOFFSET +000.000\rWIDTH 5\rWAFER SIZE 300\rBASE LENGTH 142\rLOOP 1\rRESET 1\rLOG 1\rVAC KEEP 0\rRESPONSE 1\rWP 0\rDIST"
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void ReadPosition()
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string receivedData = WriteRead("RQ POSITION");
|
|
string[] datas = receivedData.Split('\r');
|
|
if (datas.Length == 3)
|
{
|
string[] positions = datas[1].Split(' ');
|
PositionX = double.Parse(positions[1]);
|
PositionY = double.Parse(positions[2]);
|
PositionT = double.Parse(positions[3]);
|
}
|
else
|
{
|
|
}
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
public void Center()
|
{
|
if (IsRunEnable == false) return;
|
|
t_commandWriteRead = new Thread(() =>
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"CENTER");
|
|
string[] datas = str.Split('\r');
|
|
if (datas.Length == 3 && datas[1].Contains("ERR"))
|
{
|
error = (ErrorCode)Enum.Parse(typeof(ErrorCode), datas[1].Split(' ')[1]);
|
SetAlarmCode(error);
|
}
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
});
|
|
t_commandWriteRead.Start();
|
}
|
|
public void SetAlignOffset(double offset)
|
{
|
lock (_thisLock)
|
{
|
while (_lockCheck)
|
Monitor.Wait(_thisLock);
|
try
|
{
|
_lockCheck = true;
|
|
string str = WriteRead($"OFFSET {offset:3f}");
|
|
Thread.Sleep(waitTime);
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
finally
|
{
|
_lockCheck = false;
|
Monitor.Pulse(_thisLock);
|
}
|
}
|
}
|
|
//===================================================================
|
public new bool Write(string command)
|
{
|
string data = base.WriteRead(command + "\r");
|
|
if (data != string.Empty)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public new string WriteRead(string command)
|
{
|
string receivedData = string.Empty;
|
|
receivedData = base.WriteRead(command + "\r");
|
|
if (receivedData.StartsWith(command.Split(' ')[0]))
|
{
|
return receivedData;
|
}
|
else
|
{
|
if (receivedData.Contains("ERR"))
|
{
|
string errorCode = receivedData.Split(' ')[1].Replace("\r", "");
|
if (Enum.TryParse(errorCode, out error))
|
{
|
SetAlarmCode(error);
|
}
|
//Error 추가.
|
}
|
|
return "-1";
|
}
|
}
|
|
public bool WriteRead(string command, out string receivedData)
|
{
|
string data = base.WriteRead(command + '\r');
|
|
if (data.StartsWith(command.Split(' ')[0]))
|
{
|
receivedData = data.Remove(0, command.Split(' ')[0].Length).Replace("\r", "");
|
return true;
|
}
|
else
|
{
|
receivedData = string.Empty;
|
return false;
|
}
|
}
|
|
private void SetAlarmCode(ErrorCode errorCode)
|
{
|
EquipmentLogManager.Instance.WritePreAlignLog($"Error Code : {(int)errorCode} : {errorCode.ToString()}");
|
|
switch (errorCode)
|
{
|
case ErrorCode.PinUpError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0500_PREALIGNER_PIN_UP_ERROR);
|
break;
|
}
|
case ErrorCode.PinDownError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0501_PREALIGNER_PIN_DOWN_ERROR);
|
break;
|
}
|
case ErrorCode.VaccumError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0502_PREALIGNER_VACCUM_ERROR);
|
break;
|
}
|
case ErrorCode.NoWafer:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0503_PREALIGNER_NO_WAFER);
|
break;
|
}
|
case ErrorCode.WaferLimitErrorAfterAlign:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0504_PREALIGNER_WAFER_LIMIT_ERROR_AFTER_ALIGN);
|
break;
|
}
|
case ErrorCode.NotFoundNotch:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0505_PREALIGNER_NOT_FOUND_NOTCH);
|
break;
|
}
|
case ErrorCode.StageLimitError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0506_PREALIGNER_STAGE_LIMIT_ERROR);
|
break;
|
}
|
case ErrorCode.InvalidAlignCommand:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0507_PREALIGNER_INVALID_ALIGN_COMMAND);
|
break;
|
}
|
case ErrorCode.ChuckArrangeError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0508_PREALIGNER_CHUCK_ARRANGE_ERROR);
|
break;
|
}
|
case ErrorCode.WaferAlignCCDOver:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0509_PREALIGNER_WAFER_ALIGN_CCD_OVER);
|
break;
|
}
|
case ErrorCode.WaferLimitErrorBeforeAlign:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0510_PREALIGNER_WAFER_LIMIT_ERROR_BEFORE_ALIGN);
|
break;
|
}
|
case ErrorCode.RetractHome:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0511_PREALIGNER_RETRACT_HOME);
|
break;
|
}
|
case ErrorCode.WaferExist:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0512_PREALIGNER_WAFER_EXIST);
|
break;
|
}
|
case ErrorCode.CCDModuleError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0513_PREALIGNER_CCD_MODULE_ERROR);
|
break;
|
}
|
case ErrorCode.AlignerTypeError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0514_PREALIGNER_ALIGNER_TYPE_ERROR);
|
break;
|
}
|
case ErrorCode.CommandError:
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0515_PREALIGNER_COMMAND_ERROR);
|
break;
|
}
|
}
|
}
|
}
|
}
|
