public enuPositionerStatus SetAxisAbsolutePosition(enuAxes _axis, double _position)
{
if (Settings.AutoValidateParam)
{
if (ValidateAxisAbsolutePosition(_axis, ref _position) != enuPositionerStatus.Ready)
{
return(mPosStatus);
}
double mSpeed = 0;
if (GetAxisSpeed(_axis, ref mSpeed) != enuPositionerStatus.Ready)
{
return(mPosStatus);
}
if (ValidateAxisSpeed(_axis, ref mSpeed) != enuPositionerStatus.Ready)
{
return(mPosStatus);
}
}
if (mPosStatus == enuPositionerStatus.Ready)
{
HWStatus = LogError(Positioner.MoveAbsSingleAxis(AxisIndex(_axis), _position, true));
//if (HWStatus == enuHWStatus.Ready) mPosStatus = enuPositionerStatus.Ready;
}
return(mPosStatus);
}
public enuPositionerStatus GetAxisAbsolutePosition(enuAxes _axis, ref double _pos)
{
if (mPosStatus == enuPositionerStatus.Ready)
{
HWStatus = LogError(Positioner.GetPosSingleAxis(AxisIndex(_axis), ref _pos));
}
return(mPosStatus);// mPosStatus was modified by HWStatus already
}
public enuPositionerStatus ValidateAxisSpeed(enuAxes _axis, ref double _speed)
{
if (mPosStatus == enuPositionerStatus.Ready)
{
switch (_axis)
{
case enuAxes.XAxis:
if (_speed > Settings.X.MaxSpeed)
{
_speed = Settings.X.MaxSpeed;
}
if (_speed <= 0)
{
_speed = Settings.X.FailSafeSpeed;
}
break;
case enuAxes.YAxis:
if (_speed > Settings.Y.MaxSpeed)
{
_speed = Settings.Y.MaxSpeed;
}
if (_speed <= 0)
{
_speed = Settings.Y.FailSafeSpeed;
}
break;
case enuAxes.ZAxis:
if (_speed > Settings.Z.MaxSpeed)
{
_speed = Settings.Z.MaxSpeed;
}
if (_speed <= 0)
{
_speed = Settings.Z.FailSafeSpeed;
}
break;
case enuAxes.AAxis:
if (_speed > Settings.A.MaxSpeed)
{
_speed = Settings.A.MaxSpeed;
}
if (_speed <= 0)
{
_speed = Settings.A.FailSafeSpeed;
}
break;
default:
mPosStatus = enuPositionerStatus.Error;
break;
}
}
return(mPosStatus);
}
private int AxisIndex(enuAxes _axis)
{
switch (_axis)
{
case enuAxes.XAxis:
return(Settings.X.AxisNumber);
case enuAxes.YAxis:
return(Settings.Y.AxisNumber);
case enuAxes.ZAxis:
return(Settings.Z.AxisNumber);
}
return(0);
}
public enuPositionerStatus SetAxisSpeed(enuAxes _axis, double _speed)
{
if (mPosStatus == enuPositionerStatus.Ready)
{
if (Settings.AutoValidateParam)
{
if (ValidateAxisSpeed(_axis, ref _speed) != enuPositionerStatus.Ready)
{
return(mPosStatus); // mPosStatus was modified by ValidateAxisSpeed already
}
}
HWStatus = LogError(Positioner.SetVelSingleAxis(AxisIndex(_axis), _speed));
}
return(mPosStatus); // mPosStatus was modified by HWStatus already
}
private int AxisIndex(enuAxes _axis)
{
switch (_axis)
{
case enuAxes.XAxis:
return(Settings.X.AxisNumber);
case enuAxes.YAxis:
return(Settings.Y.AxisNumber);
case enuAxes.ZAxis:
return(Settings.Z.AxisNumber);
default:
return(-1); //todo: log an error event (implement a-axis as well?)
}
}
public enuPositionerStatus GetAxisSpeed(enuAxes _axis, ref double _speed)
{
switch (_axis)
{
case enuAxes.XAxis:
_speed = mSpeeds.X;
break;
case enuAxes.YAxis:
_speed = mSpeeds.Y;
break;
case enuAxes.ZAxis:
_speed = mSpeeds.Z;
break;
}
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus GetAxisAbsolutePosition(enuAxes _axis, ref double _pos)
{
switch (_axis)
{
case enuAxes.XAxis:
_pos = mPos.X;
break;
case enuAxes.YAxis:
_pos = mPos.Y;
break;
case enuAxes.ZAxis:
_pos = mPos.Z;
break;
}
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus SetAxisSpeed(enuAxes _axis, double _speed)
{
switch (_axis)
{
case enuAxes.XAxis:
mSpeeds.X = _speed;
break;
case enuAxes.YAxis:
mSpeeds.Y = _speed;
break;
case enuAxes.ZAxis:
mSpeeds.Z = _speed;
break;
}
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus SetAxisAbsolutePosition(enuAxes _axis, double _position)
{
switch (_axis)
{
case enuAxes.XAxis:
Thread.Sleep((int)((Math.Abs(mPos.X - _position) / mSpeeds.X)));
mPos.X = _position;
break;
case enuAxes.YAxis:
Thread.Sleep((int)((Math.Abs(mPos.Y - _position) / mSpeeds.Y)));
mPos.Y = _position;
break;
case enuAxes.ZAxis:
Thread.Sleep((int)((Math.Abs(mPos.Z - _position) / mSpeeds.Z)));
mPos.Z = _position;
break;
}
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus SetAxisRelativePosition(enuAxes _axis, double _increment)
{
switch (_axis)
{
case enuAxes.XAxis:
mPos.X += _increment;
Thread.Sleep((int)(_increment / mSpeeds.X));
break;
case enuAxes.YAxis:
mPos.Y += _increment;
Thread.Sleep((int)(_increment / mSpeeds.Y));
break;
case enuAxes.ZAxis:
mPos.Z += _increment;
Thread.Sleep((int)(_increment / mSpeeds.Z));
break;
}
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus GetAxisSpeed(enuAxes _axis, ref double _speed)
{
double X = 0, Y = 0, Z = 0, A = 0;
_speed = 0;
if (mPosStatus == enuPositionerStatus.Ready)
{
HWStatus = LogError(Positioner.GetVel(ref X, ref Y, ref Z, ref A));
}
if (mPosStatus == enuPositionerStatus.Ready) // mPosStatus was modified by HWStatus already
{
switch (_axis)
{
case enuAxes.XAxis:
_speed = X;
break;
case enuAxes.YAxis:
_speed = Y;
break;
case enuAxes.ZAxis:
_speed = Z;
break;
case enuAxes.AAxis:
_speed = A;
break;
default:
mPosStatus = enuPositionerStatus.Error;
break;
}
}
return(mPosStatus);
}
public enuPositionerStatus SetAxisRelativePosition(enuAxes _axis, double _increment)
{
if (mPosStatus == enuPositionerStatus.Ready)
{
if (Settings.AutoValidateParam)
{
if (ValidateAxisRelativeMovement(_axis, ref _increment) != enuPositionerStatus.Ready)
{
return(mPosStatus); // mPosStatus was modified by ValidateAxisRelativeMovement already
}
double mSpeed = 0;
if (GetAxisSpeed(_axis, ref mSpeed) != enuPositionerStatus.Ready)
{
return(mPosStatus); // mPosStatus was modified by GetAxisSpeed already
}
if (ValidateAxisSpeed(_axis, ref mSpeed) != enuPositionerStatus.Ready)
{
return(mPosStatus); // mPosStatus was modified by ValidateAxisSpeed already
}
}
HWStatus = LogError(Positioner.MoveRelSingleAxis(AxisIndex(_axis), _increment, true));
}
return(mPosStatus); // mPosStatus was evtl. modified by HWStatus already
}
public enuPositionerStatus ValidateAxisRelativeMovement(enuAxes _axis, ref double _distance)
{ //check, if the position can be reached including distance and precision
return(mPosStatus); //todo, log error
}
public enuPositionerStatus AxisStop(enuAxes _axis)
{
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus ValidateAxisAbsolutePosition(enuAxes _axis, ref double _pos)
{
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus ValidateAxisSpeed(enuAxes _axis, ref double _speed)
{
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus AxisStop(enuAxes _axis)
{
// mHWStatus = LogError(Positioner.SetAbortFlag());
HWStatus = LogError(Positioner.StopAxes());
return(mPosStatus);
}
public enuPositionerStatus ValidateAxisRelativeMovement(enuAxes _axis, ref double _distance)
{
return(enuPositionerStatus.Ready);
}
public enuPositionerStatus GetAxisStatus(enuAxes _axis)
{
string strStatus = new String('\0', 256);
enuPositionerStatus axisState = enuPositionerStatus.Error;
switch (strStatus.Substring(AxisIndex(_axis), 1))
{
case "M":
// Achse ist in Bewegung (Motion)
axisState = enuPositionerStatus.Busy;
break;
case "-":
axisState = enuPositionerStatus.NotInitialized;
break;
case "@":
axisState = enuPositionerStatus.Ready;
break;
case "S":
// Achse steht in Endschalter
axisState = enuPositionerStatus.Error;
break;
case "F":
axisState = enuPositionerStatus.Error;
break;
default:
axisState = enuPositionerStatus.Error;
break;
}
return(axisState);
/*
* int intSwitches = 0;
* ErrCheck(Positioner.GetSwitches(ref intSwitches));
*
* if (intSwitches > 0)
* {
* return enuPositionerStatus.Error;
* //todo: log
* }
*
* if ((intSwitches | 1024) == 1024)
* {
* ErrCheck(Positioner.RMeasureEx(4));
* }
* else if ((intSwitches | 512) == 512)
* {
* ErrCheck(Positioner.RMeasureEx(2));
* }
* else if ((intSwitches | 256) == 256)
* {
* ErrCheck(Positioner.RMeasureEx(1));
* }
* else if ((intSwitches | 4) == 4)
* {
* ErrCheck(Positioner.CalibrateEx(4));
* }
* else if ((intSwitches | 2) == 2)
* {
* ErrCheck(Positioner.CalibrateEx(2));
* }
* else if ((intSwitches | 1) == 1)
* {
* ErrCheck(Positioner.CalibrateEx(1));
* }
* //todo: objLogger.LogEvent(Me, "The stage was moved across the end-switch, stored positions are now invalid!", LL_Warning)
*
* // return mStatus; //todo:
* }
*/
}
