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; }