void AMPVwStatusControl::onSettlingTimeFinished()
{
settlingTimer_.stop();
if(!settlingInProgress_) {
// temporary, for settling state testing:
qWarning() << "AMPVwStatusControl:" << name() << ": Settling timeout while settlingInProgress is not true. This should never happen; please report this bug.";
return;
}
settlingInProgress_ = false;
if(moveInProgress_) {
moveInProgress_ = false;
// Check if we succeeded...
if(inPosition()) {
emit moveSucceeded();
}
else {
emit moveFailed(AMControl::ToleranceFailure);
}
}
else {
// temporary, for settling state testing:
qWarning() << "AMPVwStatusControl: " << name() << ": Settling time reached while moveInProgress_ == false. This should never happen; please report this bug.";
}
// possible that a change in settlingInProgress_ caused isMoving() to change. Emit signal if necessary:
bool nowMoving = isMoving();
if(nowMoving != wasMoving_)
emit movingChanged(wasMoving_ = nowMoving);
}
void AMControlMoveAction::startImplementation() {
const AMControlInfo& setpoint = *(controlMoveInfo()->controlInfo());
// lookup the control we need to use to run this
control_ = getControlForAction(setpoint);
// Must have a control, and it must be able to move.
if(!control_) {
AMErrorMon::report(AMErrorReport(this,
AMErrorReport::Alert,
-1,
QString("There was an error moving the control '%1' into position, because the control was not found. Please report this problem to the Acquaman developers.").arg(setpoint.name())));
notifyFailed();
return;
}
// check we can move...
if(!control_->canMove()) {
AMErrorMon::report(AMErrorReport(this,
AMErrorReport::Alert,
-2,
QString("There was an error moving the control '%1' into position, because the control was not connected and ready to move. Please report this problem to the beamline staff.")
.arg(control_->name())));
notifyFailed();
return;
}
// check that the destination is in range...
if(control_->valueOutOfRange(controlMoveInfo()->isRelativeMove() ? control_->value()+setpoint.value() : setpoint.value())) {
AMErrorMon::report(AMErrorReport(this,
AMErrorReport::Alert,
-3,
QString("There was an error moving the control '%1' into position, because the destination %2 %3 was outside its range. Please report this problem to the beamline staff.")
.arg(control_->name())
.arg(setpoint.value())
.arg(setpoint.units())));
notifyFailed();
return;
}
// connect to its moveSucceeded and moveFailed signals
connect(control_, SIGNAL(moveStarted()), this, SLOT(onMoveStarted()));
connect(control_, SIGNAL(moveReTargetted()), this, SLOT(onMoveStarted())); // For controls that support allowsMovesWhileMoving(), they might already be moving when we request our move(). A moveReTargetted() signal from them also counts as a moveStarted() for us.
connect(control_, SIGNAL(moveFailed(int)), this, SLOT(onMoveFailed(int)));
connect(control_, SIGNAL(moveSucceeded()), this, SLOT(onMoveSucceeded()));
// remember the start position:
startPosition_ = control_->toInfo();
// start the move:
int failureExplanation;
if(controlMoveInfo()->isRelativeMove())
failureExplanation = control_->moveRelative(setpoint.value());
else
failureExplanation = control_->move(setpoint.value());
if(failureExplanation != AMControl::NoFailure)
onMoveFailed(failureExplanation);
}
// Start a move to the value setpoint:
AMControl::FailureExplanation CLSMDriveMotorControl::move(double Setpoint) {
if(isMoving()) {
if(!allowsMovesWhileMoving()) {
AMErrorMon::debug(this, AMPVCONTROL_COULD_NOT_MOVE_WHILE_MOVING, QString("AMPVControl: Could not move %1 (%2) to %3, because the control is already moving.").arg(name()).arg(writePV_->pvName()).arg(setpoint_));
return AlreadyMovingFailure;
}
if(!moveInProgress()) {
// the control is already moving, but it's not one of our moves. In this situation, there is no way that we can start a move and be assured that we'll be notified when OUR move finishes.
AMErrorMon::debug(this, AMPVCONTROL_COULD_NOT_MOVE_WHILE_MOVING_EXTERNAL, QString("AMPVControl: Could not move %1 (%2) to %3, because the control is already moving.").arg(name()).arg(writePV_->pvName()).arg(setpoint_));
return AlreadyMovingFailure;
}
// Otherwise: This control supports mid-move updates, and we're already moving. We just need to update the setpoint and send it.
setpoint_ = writeUnitConverter()->convertToRaw(Setpoint);
writePV_->setValue(setpoint_);
// since the settling phase is considered part of a move, it's OK to be here while settling... But for Acquaman purposes, this will be considered a single re-targetted move, even though the hardware will see two. If we're settling, disable the settling timer, because we only want to respond to the end of the second move.
if(settlingInProgress_) {
settlingInProgress_ = false;
settlingTimer_.stop();
}
emit moveReTargetted(); // re-targetted moves will emit moveReTargetted(), although no moveSucceeded()/moveFailed() will be issued for the initial move.
}
else {
settlingInProgress_ = false;
stopInProgress_ = false;
moveInProgress_ = false;
// Flag that "our" move started:
startInProgress_ = true;
// This is our new target:
setpoint_ = writeUnitConverter()->convertToRaw(Setpoint);
// Special case: "null move" should complete immediately. Use only if moveStartTolerance() is non-zero, and the move distance is within moveStartTolerance().
if(moveStartTolerance() != 0 && fabs(setpoint()-value()) < moveStartTolerance()) {
startInProgress_ = false;
moveInProgress_ = true;
emit moveStarted();
moveInProgress_ = false;
emit moveSucceeded();
}
// Normal move:
else {
// Issue the move command:
writePV_->setValue(setpoint_);
// start the timer to check if our move failed to start:
moveStartTimer_.start(int(moveStartTimeout_*1000.0));
}
}
return NoFailure;
}
AMControl::FailureExplanation CLSMAXvMotor::move(double setpoint){
CLSMAXvMotor::Limit limitCondition = atLimit();
if(limitCondition == CLSMAXvMotor::LimitNone)
return AMPVwStatusControl::move(setpoint);
else if(limitCondition == CLSMAXvMotor::LimitError)
return AMControl::LimitFailure;
double currentPosition = value();
bool positiveSlope = false;
if(stepCalibrationSlope_->value() > 0)
positiveSlope = true;
bool positiveMovement = false;
if(setpoint > currentPosition)
positiveMovement = true;
bool canMoveAwayFromLimit = false;
if(limitCondition == CLSMAXvMotor::LimitCW && positiveMovement && !positiveSlope)
canMoveAwayFromLimit = true;
else if(limitCondition == CLSMAXvMotor::LimitCW && !positiveMovement && positiveSlope)
canMoveAwayFromLimit = true;
else if(limitCondition == CLSMAXvMotor::LimitCCW && !positiveMovement && !positiveSlope)
canMoveAwayFromLimit = true;
else if(limitCondition == CLSMAXvMotor::LimitCCW && positiveMovement && positiveSlope)
canMoveAwayFromLimit = true;
if(!canMoveAwayFromLimit)
return AMControl::LimitFailure;
settlingInProgress_ = false;
stopInProgress_ = false;
moveInProgress_ = false;
// Flag that "our" move started:
startInProgress_ = true;
// This is our new target:
setpoint_ = setpoint;
// Normal move:
// Issue the move command, check on attemptMoveWhenWithinTolerance
if(!attemptMoveWhenWithinTolerance_ && inPosition())
emit moveSucceeded();
else{
writePV_->setValue(setpoint_);
// start the timer to check if our move failed to start:
moveStartTimer_.start(int(moveStartTimeout_*1000.0));
}
return NoFailure;
}
// This is used to check every new value, to see if we entered tolerance:
void AMPVControl::onNewFeedbackValue(double) {
// If we're not in the middle of a move, don't really care about changing values.
if(!moveInProgress_)
return;
// Did we make it?
if( inPosition() ) {
// move is now done:
emit movingChanged(moveInProgress_ = false);
// disable the timer, so it doesn't trigger an error later
completionTimer_.stop();
// let everyone know we succeeded:
emit moveSucceeded();
}
}
// This is used to handle the timeout of a move:
void AMPVControl::onCompletionTimeout() {
// if we weren't moving, this shouldn't have happened. someone forgot to shutoff the timer?
// todo: this is only included for state testing debugging... can remove if never happens
if(!moveInProgress_) {
return;
}
// No matter what, this move is over:
emit movingChanged(moveInProgress_ = false);
completionTimer_.stop();
// Did we make it?
if( inPosition() ) {
emit moveSucceeded();
}
// Didn't make it into position:
else {
emit moveFailed(AMControl::TimeoutFailure);
}
}
void REIXSXESSpectrometerControlEditor::setupConnections()
{
connect(spectrometer_, SIGNAL(valueChanged(double)), this, SLOT(updateCurrentEnergyStatus(double)));
connect(spectrometer_, SIGNAL(calibrationChanged()), this, SLOT(populateGratingComboBox()));
connect(spectrometer_, SIGNAL(gratingChanged(int)), this, SLOT(updateCurrentGratingStatus()));
connect(spectrometer_, SIGNAL(movingChanged(bool)), this, SLOT(updateCurrentGratingStatus()));
connect(spectrometer_, SIGNAL(moveSucceeded()), this, SLOT(onSpectrometerMoveSucceeded()));
connect(spectrometer_, SIGNAL(moveFailed(int)), this, SLOT(onSpectrometerMoveFailed(int)));
connect(spectrometer_->gratingMask(), SIGNAL(valueChanged(double)), this, SLOT(updateMaskPosition()));
connect(spectrometer_->gratingMask(), SIGNAL(connected(bool)), this, SLOT(updateMaskPosition()));
connect(maskComboBox_, SIGNAL(currentIndexChanged(QString)), this, SLOT(on_maskComboBox_currentIndexChanged(QString)));
connect(energyBox_, SIGNAL(valueChanged(double)), this, SLOT(updateCurrentEnergyStatus()));
connect(gratingSelectorBox_, SIGNAL(currentIndexChanged(int)), this, SLOT(onGratingComboBoxActivated(int)));
connect(stopButton_, SIGNAL(clicked()), this, SLOT(onStopButtonClicked()));
connect(moveNowButton_, SIGNAL(clicked()), this, SLOT(onMoveButtonClicked()));
connect(energyBox_, SIGNAL(valueChanged(double)), this, SLOT(updateEnergyRange()));
connect(tiltOffsetBox_, SIGNAL(valueChanged(double)), this, SLOT(updateEnergyRange()));
connect(gratingSelectorBox_, SIGNAL(currentIndexChanged(int)), this, SLOT(updateEnergyRange()));
}
// This is used to handle the timeout of a move start:
void CLSMDriveMotorControl::onMoveStartTimeout() {
moveStartTimer_.stop();
// This is only meaningful if one of our moves is in progress.
if(startInProgress_) {
// give up on this move:
startInProgress_ = false;
// Special case: only applies if moveTimeoutTolerance_ != 0 AND we've gotten within moveTimeoutTolerance_ of the setpoint.
if(moveTimeoutTolerance() != 0.0 && fabs(setpoint() - value()) < moveTimeoutTolerance_) {
moveInProgress_ = true;
emit moveStarted();
moveInProgress_ = false;
emit moveSucceeded();
}
else {
// The move didn't start within our allowed start period. That counts as a move failed.
emit moveFailed(AMControl::TimeoutFailure);
}
}
}
// Re-implemented from AMReadOnlyPVwStatusControl:
void AMPVwStatusControl::onMovingChanged(int isMovingValue) {
bool nowMoving = (*statusChecker_)(isMovingValue); // according to the hardware. For checking moveSucceeded/moveStarted/moveFailed, use the value delivered in the signal argument, instead of re-checking the PV, in case we respond late and the hardware has already changed again.
// In case the hardware is being silly and sending multiple MOVE ACTIVE, MOVE ACTIVE, MOVE ACTIVE states in a row, or MOVE DONE, MOVE DONE, MOVE DONE states in a row: only act on changes. [Edge detection]
if(nowMoving == hardwareWasMoving_)
return;
hardwareWasMoving_ = nowMoving;
// moveStarted, moveFailed, moveSucceeded, or transition to settling:
///////////////////////////////////////////////////////////////////////
// if we requested one of our moves, and moving just started:
if(startInProgress_ && nowMoving) {
moveInProgress_ = true;
startInProgress_ = false;
// This is great... the device started moving within the timeout:
// disable the moveStartTimer, we don't need it anymore
moveStartTimer_.stop();
emit moveStarted();
}
// If one of our moves was running, and we stopped moving:
if(moveInProgress_ && !nowMoving) {
// Mode 1: No settling:
if( settlingTime_ == 0.0) {
// That's the end of our move
moveInProgress_ = false;
// Check if we succeeded...
if(inPosition()) {
emit moveSucceeded();
} else {
emit moveFailed(AMControl::ToleranceFailure);
}
}
// Mode 2: allow settling
else {
if(!settlingInProgress_) {
settlingInProgress_ = true;
settlingTimer_.start(int(settlingTime_*1000)); // QTimer uses millisecond time intervals.
}
}
}
// "sucessfully" stopped due to a stop() command.
if(stopInProgress_ && !nowMoving) {
stopInProgress_ = false;
// but the move itself has failed, due to a stop() intervention.
emit moveFailed(AMControl::WasStoppedFailure);
}
// Emitting movingChanged().
/////////////////////////////////////
// For external purposes, isMoving() depends on whether the hardware says we're moving, or we're in the settling phase.
nowMoving = isMoving();
if(nowMoving != wasMoving_)
emit movingChanged(wasMoving_ = nowMoving);
}
// Start a move to the value setpoint:
AMControl::FailureExplanation AMPVControl::move(double setpoint) {
if(isMoving()) {
if(!allowsMovesWhileMoving()) {
AMErrorMon::debug(this, AMPVCONTROL_COULD_NOT_MOVE_WHILE_MOVING, QString("AMPVControl: Could not move %1 (%2) to %3, because the control is already moving.").arg(name()).arg(writePV_->pvName()).arg(setpoint_));
return AlreadyMovingFailure;
}
// assuming this control can accept mid-move updates. We just need to update our setpoint and send it.
if(!canMove()) { // this would be rare: a past move worked, but now we're no longer connected?
AMErrorMon::debug(this, AMPVCONTROL_COULD_NOT_MOVE_BASED_ON_CANMOVE, QString("AMPVControl: Could not move %1 (%2) to %3.").arg(name()).arg(writePV_->pvName()).arg(setpoint_));
return NotConnectedFailure;
}
setpoint_ = setpoint;
writePV_->setValue(setpoint_);
completionTimer_.start(int(completionTimeout_*1000.0)); // restart the completion timer... Since this might be another move, give it some more time.
// re-targetted moves will emit moveReTargetted(), although no moveSucceeded()/moveFailed() will be issued for the first move.
emit moveReTargetted();
// check for done:
if(inPosition()) {
completionTimer_.stop();
emit movingChanged(moveInProgress_ = false);
emit moveSucceeded();
}
}
// Regular case: start of a new move.
else {
// kill any old countdowns:
completionTimer_.stop();
if(!canMove()) {
AMErrorMon::debug(this, AMPVCONTROL_COULD_NOT_MOVE_BASED_ON_CANMOVE, QString("AMPVControl: Could not move %1 (%2) to %3.").arg(name()).arg(writePV_->pvName()).arg(setpoint_));
return NotConnectedFailure;
}
// new move target:
setpoint_ = setpoint;
// Issue the move, check on attemptMoveWhenWithinTolerance
if(!attemptMoveWhenWithinTolerance_ && inPosition()){
emit moveSucceeded();
}
else{
writePV_->setValue(setpoint_);
// We're now moving! Let's hope this control makes it... (No way to actually check.)
emit movingChanged(moveInProgress_ = true);
// emit the signal that we started:
emit moveStarted();
// Are we in-position? [With the default tolerance of AMCONTROL_TOLERANCE_DONT_CARE, we will always be in-position, and moves will complete right away, that's the intended behaviour, because we have no other way of knowing when they'll finish.]
if(inPosition()) {
emit movingChanged(moveInProgress_ = false);
emit moveSucceeded();
}
else {
// start the countdown to see if we get there in time or stall out: (completionTimeout_ is in seconds)
completionTimer_.start(int(completionTimeout_*1000.0));
}
}
}
return NoFailure;
}
