namespace SHARP_CLAS_UI
|
{
|
public class AlignerY
|
{
|
#region Enum
|
private enum ProcessSteps
|
{
|
Wait,
|
|
BackwardSolOff,
|
BackwardSolOffCheck,
|
ForwardSensorCheck,
|
|
BackwardSolOn,
|
BackwardSolOnCheck,
|
BackwardSensorCheck,
|
}
|
#endregion
|
|
#region Property
|
public bool BackwardSol
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Output(_backwardSol);
|
}
|
|
set
|
{
|
_equipment.Board_Control.IO_manager.Set_Output(_backwardSol, value);
|
}
|
}
|
|
public bool IsForwardSensor1
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isForwardSensor1);
|
}
|
}
|
|
public bool IsForwardSensor2
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isForwardSensor2);
|
}
|
}
|
|
public bool IsBackwardSensor1
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isBackwardSensor1);
|
}
|
}
|
|
public bool IsBackwardSensor2
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isBackwardSensor2);
|
}
|
}
|
|
public bool IsForward
|
{
|
get
|
{
|
return BackwardSol == false && IsForwardSensor1 && IsForwardSensor2;
|
}
|
}
|
|
public bool IsBackward
|
{
|
get
|
{
|
return BackwardSol && IsBackwardSensor1 && IsBackwardSensor2;
|
}
|
}
|
|
public bool IsWorkEnd
|
{
|
get
|
{
|
if (_step == ProcessSteps.Wait)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
#endregion
|
|
#region Field
|
Equipment _equipment;
|
|
private OutputData _backwardSol;
|
|
private InputData _isForwardSensor1;
|
private InputData _isForwardSensor2;
|
|
private InputData _isBackwardSensor1;
|
private InputData _isBackwardSensor2;
|
|
private En_Alarm_List _forwardSensor1Alarm;
|
private En_Alarm_List _forwardSensor2Alarm;
|
private En_Alarm_List _backwardSensor1Alarm;
|
private En_Alarm_List _backwardSensor2Alarm;
|
private ProcessSteps _step;
|
|
private SequenceTimer _sequenceTimer;
|
|
private readonly int _retryLimitCount = 3;
|
private int _retryCount;
|
#endregion
|
|
#region Construct
|
public AlignerY(Equipment equipment)
|
{
|
_equipment = equipment;
|
_sequenceTimer = new SequenceTimer();
|
_retryCount = 0;
|
_step = ProcessSteps.Wait;
|
}
|
#endregion
|
|
#region Function
|
public void Initialize(OutputData backwardSol, InputData isForwardSensor1, InputData isForwardSensor2, InputData isBackwardSensor1, InputData isBackwardSensor2,
|
En_Alarm_List forwardSensor1Alarm, En_Alarm_List forwardSensor2Alarm, En_Alarm_List backwardSensor1Alarm, En_Alarm_List backwardSensor2Alarm)
|
{
|
_backwardSol = backwardSol;
|
_isForwardSensor1 = isForwardSensor1;
|
_isForwardSensor2 = isForwardSensor2;
|
_isBackwardSensor1 = isBackwardSensor1;
|
_isBackwardSensor2 = isBackwardSensor2;
|
|
_forwardSensor1Alarm = forwardSensor1Alarm;
|
_forwardSensor2Alarm = forwardSensor2Alarm;
|
_backwardSensor1Alarm = backwardSensor1Alarm;
|
_backwardSensor2Alarm = backwardSensor2Alarm;
|
}
|
|
public void ExecuteProcess()
|
{
|
switch (_step)
|
{
|
case ProcessSteps.Wait:
|
{
|
break;
|
}
|
case ProcessSteps.BackwardSolOff:
|
{
|
BackwardSol = false;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.BackwardSolOffCheck;
|
break;
|
}
|
case ProcessSteps.BackwardSolOffCheck:
|
{
|
if (BackwardSol == false)
|
{
|
_retryCount = 0;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.ForwardSensorCheck;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > 1)
|
{
|
if (_retryCount < _retryLimitCount)
|
{
|
_retryCount++;
|
_step = ProcessSteps.BackwardSolOff;
|
}
|
else
|
{
|
_retryCount = 0;
|
Interlock_Manager.Add_Interlock_Msg($"{_backwardSol} on fail.", $"{_backwardSol} on is fail (retry 3).");
|
_step = ProcessSteps.Wait;
|
}
|
}
|
}
|
break;
|
}
|
case ProcessSteps.ForwardSensorCheck:
|
{
|
if (IsForwardSensor1 && IsForwardSensor2)
|
{
|
_sequenceTimer.Reset();
|
_step = ProcessSteps.Wait;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > _equipment.Setting.Cylinder_Timeout)
|
{
|
if (IsForwardSensor1 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_forwardSensor1Alarm);
|
}
|
|
if (IsForwardSensor2 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_forwardSensor2Alarm);
|
}
|
|
_step = ProcessSteps.Wait;
|
}
|
}
|
break;
|
}
|
case ProcessSteps.BackwardSolOn:
|
{
|
BackwardSol = true;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.BackwardSolOnCheck;
|
break;
|
}
|
|
case ProcessSteps.BackwardSolOnCheck:
|
{
|
if (BackwardSol)
|
{
|
_retryCount = 0;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.BackwardSensorCheck;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > 1)
|
{
|
if (_retryCount < _retryLimitCount)
|
{
|
_retryCount++;
|
_step = ProcessSteps.BackwardSolOn;
|
}
|
else
|
{
|
_retryCount = 0;
|
Interlock_Manager.Add_Interlock_Msg($"{_backwardSol} off fail.", $"{_backwardSol} off is fail (retry 3).");
|
_step = ProcessSteps.Wait;
|
}
|
}
|
}
|
|
break;
|
}
|
case ProcessSteps.BackwardSensorCheck:
|
{
|
if (IsBackwardSensor1 && IsBackwardSensor2)
|
{
|
_sequenceTimer.Reset();
|
_step = ProcessSteps.Wait;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > _equipment.Setting.Cylinder_Timeout)
|
{
|
if (IsBackwardSensor1 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_backwardSensor1Alarm);
|
}
|
|
if (IsBackwardSensor2 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_backwardSensor2Alarm);
|
}
|
|
_step = ProcessSteps.Wait;
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
public bool Forward()
|
{
|
if (IsWorkEnd)
|
{
|
if (BackwardSol == false && IsForwardSensor1 && IsForwardSensor2)
|
{
|
return true;
|
}
|
else
|
{
|
_step = ProcessSteps.BackwardSolOff;
|
return true;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public bool Backward()
|
{
|
if (IsWorkEnd)
|
{
|
if (BackwardSol && IsBackwardSensor1 && IsBackwardSensor2)
|
{
|
return true;
|
}
|
else
|
{
|
_step = ProcessSteps.BackwardSolOn;
|
return true;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
#endregion
|
}
|
}
|
