namespace SHARP_CLAS_UI
|
{
|
public class Stacker
|
{
|
#region Enum
|
private enum ProcessSteps
|
{
|
Wait,
|
|
StackerForwardSolOn,
|
StackerForwardSolOnCheck,
|
StackerForwardSensorCheck,
|
|
StackerForwardSolOff,
|
StackerForwardSolOffCheck,
|
StackerBackwardSensorCheck,
|
}
|
#endregion
|
|
#region Property
|
public bool ForwardSol
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Output(_forwardSol);
|
}
|
|
set
|
{
|
_equipment.Board_Control.IO_manager.Set_Output(_forwardSol, 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 IsForwardSensor3
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isForwardSensor3);
|
}
|
}
|
|
public bool IsForwardSensor4
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isForwardSensor4);
|
}
|
}
|
|
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 IsBackwardSensor3
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isBackwardSensor3);
|
}
|
}
|
|
public bool IsBackwardSensor4
|
{
|
get
|
{
|
return _equipment.Board_Control.IO_manager.Get_Input(_isBackwardSensor4);
|
}
|
}
|
|
public bool IsForward
|
{
|
get
|
{
|
return ForwardSol && IsForwardSensor1 && IsForwardSensor2 && IsForwardSensor3 && IsForwardSensor4;
|
}
|
}
|
|
public bool IsBackward
|
{
|
get
|
{
|
return ForwardSol == false && IsBackwardSensor1 && IsBackwardSensor2 && IsBackwardSensor3 && IsBackwardSensor4;
|
}
|
}
|
|
public bool IsWorkEnd
|
{
|
get
|
{
|
if(_step == ProcessSteps.Wait)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
#endregion
|
|
#region Field
|
Equipment _equipment;
|
|
private OutputData _forwardSol;
|
|
private InputData _isForwardSensor1;
|
private InputData _isForwardSensor2;
|
private InputData _isForwardSensor3;
|
private InputData _isForwardSensor4;
|
|
private InputData _isBackwardSensor1;
|
private InputData _isBackwardSensor2;
|
private InputData _isBackwardSensor3;
|
private InputData _isBackwardSensor4;
|
|
private En_Alarm_List _forwardSensor1Alarm;
|
private En_Alarm_List _forwardSensor2Alarm;
|
private En_Alarm_List _forwardSensor3Alarm;
|
private En_Alarm_List _forwardSensor4Alarm;
|
private En_Alarm_List _backwardSensor1Alarm;
|
private En_Alarm_List _backwardSensor2Alarm;
|
private En_Alarm_List _backwardSensor3Alarm;
|
private En_Alarm_List _backwardSensor4Alarm;
|
|
private ProcessSteps _step;
|
|
private SequenceTimer _sequenceTimer;
|
|
private readonly int _retryLimitCount = 3;
|
private int _retryCount;
|
|
#endregion
|
|
#region Construct
|
public Stacker(Equipment equipment)
|
{
|
_equipment = equipment;
|
_sequenceTimer = new SequenceTimer();
|
_retryCount = 0;
|
_step = ProcessSteps.Wait;
|
}
|
#endregion
|
|
#region Function
|
public void Initialize(OutputData forwardSol, InputData isForwardSensor1, InputData isForwardSensor2, InputData isForwardSensor3, InputData isForwardSensor4, InputData isBackwardSensor1, InputData isBackwardSensor2, InputData isBackwardSensor3, InputData isBackwardSensor4,
|
En_Alarm_List forwardSensor1Alarm, En_Alarm_List forwardSensor2Alarm, En_Alarm_List forwardSensor3Alarm, En_Alarm_List forwardSensor4Alarm, En_Alarm_List backwardSensor1Alarm, En_Alarm_List backwardSensor2Alarm, En_Alarm_List backwardSensor3Alarm, En_Alarm_List backwardSensor4Alarm)
|
{
|
_forwardSol = forwardSol;
|
_isForwardSensor1 = isForwardSensor1;
|
_isForwardSensor2 = isForwardSensor2;
|
_isForwardSensor3 = isForwardSensor3;
|
_isForwardSensor4 = isForwardSensor4;
|
_isBackwardSensor1 = isBackwardSensor1;
|
_isBackwardSensor2 = isBackwardSensor2;
|
_isBackwardSensor3 = isBackwardSensor3;
|
_isBackwardSensor4 = isBackwardSensor4;
|
|
_forwardSensor1Alarm = forwardSensor1Alarm;
|
_forwardSensor2Alarm = forwardSensor2Alarm;
|
_forwardSensor3Alarm = forwardSensor3Alarm;
|
_forwardSensor4Alarm = forwardSensor4Alarm;
|
_backwardSensor1Alarm = backwardSensor1Alarm;
|
_backwardSensor2Alarm = backwardSensor2Alarm;
|
_backwardSensor3Alarm = backwardSensor3Alarm;
|
_backwardSensor4Alarm = backwardSensor4Alarm;
|
}
|
|
public void ExecuteProcess()
|
{
|
switch (_step)
|
{
|
case ProcessSteps.Wait:
|
{
|
break;
|
}
|
case ProcessSteps.StackerForwardSolOn:
|
{
|
ForwardSol = true;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.StackerForwardSolOnCheck;
|
break;
|
}
|
case ProcessSteps.StackerForwardSolOnCheck:
|
{
|
if (ForwardSol == true)
|
{
|
_retryCount = 0;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.StackerForwardSensorCheck;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > 1)
|
{
|
if (_retryCount < _retryLimitCount)
|
{
|
_retryCount++;
|
_step = ProcessSteps.StackerForwardSolOn;
|
}
|
else
|
{
|
_retryCount = 0;
|
Interlock_Manager.Add_Interlock_Msg($"{_forwardSol} on fail.", $"{_forwardSol} on is fail (retry 3).");
|
_step = ProcessSteps.Wait;
|
}
|
}
|
}
|
break;
|
}
|
case ProcessSteps.StackerForwardSensorCheck:
|
{
|
if (IsForwardSensor1 && IsForwardSensor2 && IsForwardSensor3 && IsForwardSensor4)
|
{
|
_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);
|
}
|
|
if (IsForwardSensor3 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_forwardSensor3Alarm);
|
}
|
|
if (IsForwardSensor4 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_forwardSensor4Alarm);
|
}
|
_step = ProcessSteps.Wait;
|
}
|
}
|
break;
|
}
|
case ProcessSteps.StackerForwardSolOff:
|
{
|
ForwardSol = false;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.StackerForwardSolOffCheck;
|
break;
|
}
|
case ProcessSteps.StackerForwardSolOffCheck:
|
{
|
if (ForwardSol == false)
|
{
|
_retryCount = 0;
|
_sequenceTimer.Restart();
|
_step = ProcessSteps.StackerBackwardSensorCheck;
|
}
|
else
|
{
|
if (_sequenceTimer.Seconds > 1)
|
{
|
if (_retryCount < _retryLimitCount)
|
{
|
_retryCount++;
|
_step = ProcessSteps.StackerForwardSolOff;
|
}
|
else
|
{
|
_retryCount = 0;
|
Interlock_Manager.Add_Interlock_Msg($"{_forwardSol} off fail.", $"{_forwardSol} off is fail (retry 3).");
|
_step = ProcessSteps.Wait;
|
}
|
}
|
}
|
break;
|
}
|
case ProcessSteps.StackerBackwardSensorCheck:
|
{
|
if (IsBackwardSensor1 && IsBackwardSensor2 && IsBackwardSensor3 && IsBackwardSensor4)
|
{
|
_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);
|
}
|
|
if (IsBackwardSensor3 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_backwardSensor3Alarm);
|
}
|
|
if (IsBackwardSensor4 == false)
|
{
|
Alarm_Manager.Instance.Occurred(_backwardSensor4Alarm);
|
}
|
_step = ProcessSteps.Wait;
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
public bool Forward()
|
{
|
if (IsWorkEnd)
|
{
|
if (ForwardSol && IsForwardSensor1 && IsForwardSensor2 && IsForwardSensor3 && IsForwardSensor4)
|
{
|
return true;
|
}
|
else
|
{
|
_step = ProcessSteps.StackerForwardSolOn;
|
return true;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public bool Backward()
|
{
|
if (IsWorkEnd)
|
{
|
if (ForwardSol == false && IsBackwardSensor1 && IsBackwardSensor2 && IsBackwardSensor3 && IsBackwardSensor4)
|
{
|
return true;
|
}
|
else
|
{
|
_step = ProcessSteps.StackerForwardSolOff;
|
return true;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
#endregion
|
}
|
}
|
