bool StepGuider::SetBumpPercentage(int bumpPercentage, bool updateGraph)
{
bool bError = false;
try
{
if (bumpPercentage <= 0)
{
throw ERROR_INFO("invalid bumpPercentage");
}
m_bumpPercentage = bumpPercentage;
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
bError = true;
m_bumpPercentage = DefaultBumpPercentage;
}
pConfig->Profile.SetInt("/stepguider/BumpPercentage", m_bumpPercentage);
if (updateGraph)
{
InitBumpPositions();
pFrame->pStepGuiderGraph->SetLimits(MaxPosition(LEFT), MaxPosition(UP), m_xBumpPos1, m_yBumpPos1);
}
return bError;
}
void StepGuider::InitBumpPositions(void)
{
int limit2Pct = (100 + m_bumpPercentage) / 2;
m_xBumpPos1 = IntegerPercent(m_bumpPercentage, MaxPosition(LEFT));
m_xBumpPos2 = IntegerPercent(limit2Pct, MaxPosition(LEFT));
m_yBumpPos1 = IntegerPercent(m_bumpPercentage, MaxPosition(UP));
m_yBumpPos2 = IntegerPercent(limit2Pct, MaxPosition(UP));
enum { BumpCenterTolerancePct = 10 }; // end bump when position is within 10 pct of center
m_bumpCenterTolerance = IntegerPercent(BumpCenterTolerancePct, 2 * MaxPosition(UP));
Debug.AddLine("StepGuider: Bump Limits: X: %d, %d; Y: %d, %d; center: %d", m_xBumpPos1, m_xBumpPos2, m_yBumpPos1, m_yBumpPos2, m_bumpCenterTolerance);
}
bool StepGuider::Connect(void)
{
bool bError = false;
try
{
if (Mount::Connect())
{
throw ERROR_INFO("Mount::Connect() failed");
}
InitBumpPositions();
pFrame->pStepGuiderGraph->SetLimits(MaxPosition(LEFT), MaxPosition(UP), m_xBumpPos1, m_yBumpPos1);
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
bError = true;
}
return bError;
}
bool StepGuider::WouldHitLimit(GUIDE_DIRECTION direction, int steps)
{
bool bReturn = false;
assert(steps >= 0);
if (CurrentPosition(direction) + steps >= MaxPosition(direction))
{
bReturn = true;
}
Debug.AddLine(wxString::Format("WouldHitLimit=%d current=%d, steps=%d, max=%d", bReturn, CurrentPosition(direction), steps, MaxPosition(direction)));
return bReturn;
}
CalChart::Coord ShowMode::ClipPosition(const CalChart::Coord& pos) const
{
auto min = MinPosition();
auto max = MaxPosition();
CalChart::Coord clipped;
if (pos.x < min.x)
clipped.x = min.x;
else if (pos.x > max.x)
clipped.x = max.x;
else
clipped.x = pos.x;
if (pos.y < min.y)
clipped.y = min.y;
else if (pos.y > max.y)
clipped.y = max.y;
else
clipped.y = pos.y;
return clipped;
}
Mount::MOVE_RESULT StepGuider::Move(GUIDE_DIRECTION direction, int steps, bool normalMove, MoveResultInfo *moveResult)
{
MOVE_RESULT result = MOVE_OK;
bool limitReached = false;
try
{
Debug.AddLine(wxString::Format("Move(%d, %d, %d)", direction, steps, normalMove));
// Compute the required guide steps
if (!m_guidingEnabled)
{
throw THROW_INFO("Guiding disabled");
}
// Acutally do the guide
assert(steps >= 0);
if (steps > 0)
{
int yDirection = 0;
int xDirection = 0;
switch (direction)
{
case UP:
yDirection = 1;
break;
case DOWN:
yDirection = -1;
break;
case RIGHT:
xDirection = 1;
break;
case LEFT:
xDirection = -1;
break;
default:
throw ERROR_INFO("StepGuider::Move(): invalid direction");
break;
}
assert(yDirection == 0 || xDirection == 0);
assert(yDirection != 0 || xDirection != 0);
Debug.AddLine(wxString::Format("stepping direction=%d steps=%d xDirection=%d yDirection=%d", direction, steps, xDirection, yDirection));
if (WouldHitLimit(direction, steps))
{
int new_steps = MaxPosition(direction) - 1 - CurrentPosition(direction);
Debug.AddLine(wxString::Format("StepGuider step would hit limit: truncate move direction=%d steps=%d => %d", direction, steps, new_steps));
steps = new_steps;
limitReached = true;
}
if (steps > 0)
{
if (Step(direction, steps))
{
throw ERROR_INFO("step failed");
}
m_xOffset += xDirection * steps;
m_yOffset += yDirection * steps;
Debug.AddLine(wxString::Format("stepped: xOffset=%d yOffset=%d", m_xOffset, m_yOffset));
}
}
}
catch (const wxString& Msg)
{
POSSIBLY_UNUSED(Msg);
steps = 0;
result = MOVE_ERROR;
}
if (moveResult)
{
moveResult->amountMoved = steps;
moveResult->limited = limitReached;
}
return result;
}
bool StepGuider::UpdateCalibrationState(const PHD_Point& currentLocation)
{
bool bError = false;
try
{
if (!m_calibrationStartingLocation.IsValid())
{
m_calibrationStartingLocation = currentLocation;
Debug.AddLine(wxString::Format("Stepguider::UpdateCalibrationstate: starting location = %.2f,%.2f", currentLocation.X, currentLocation.Y));
}
wxString status0, status1;
int stepsRemainingUp = MaxPosition(UP) - CurrentPosition(UP);
int stepsRemainingDown = MaxPosition(DOWN) - CurrentPosition(DOWN);
int stepsRemainingRight = MaxPosition(RIGHT) - CurrentPosition(RIGHT);
int stepsRemainingLeft = MaxPosition(LEFT) - CurrentPosition(LEFT);
stepsRemainingUp /= m_calibrationStepsPerIteration;
stepsRemainingDown /= m_calibrationStepsPerIteration;
stepsRemainingRight /= m_calibrationStepsPerIteration;
stepsRemainingLeft /= m_calibrationStepsPerIteration;
int stepsRemainingDownAndRight = wxMax(stepsRemainingDown, stepsRemainingRight);
assert(stepsRemainingUp >= 0);
assert(stepsRemainingDown >= 0);
assert(stepsRemainingRight >= 0);
assert(stepsRemainingLeft >= 0);
assert(stepsRemainingDownAndRight >= 0);
bool moveUp = false;
bool moveDown = false;
bool moveRight = false;
bool moveLeft = false;
double x_dist;
double y_dist;
switch (m_calibrationState)
{
case CALIBRATION_STATE_GOTO_LOWER_RIGHT_CORNER:
if (stepsRemainingDownAndRight > 0)
{
status0.Printf(_("Init Calibration: %3d"), stepsRemainingDownAndRight);
moveDown = stepsRemainingDown > 0;
moveRight = stepsRemainingRight > 0;
break;
}
Debug.AddLine(wxString::Format("Falling through to state AVERAGE_STARTING_LOCATION, position=(%.2f, %.2f)",
currentLocation.X, currentLocation.Y));
m_calibrationAverageSamples = 0;
m_calibrationAveragedLocation.SetXY(0.0, 0.0);
m_calibrationState = CALIBRATION_STATE_AVERAGE_STARTING_LOCATION;
// fall through
case CALIBRATION_STATE_AVERAGE_STARTING_LOCATION:
m_calibrationAverageSamples++;
m_calibrationAveragedLocation += currentLocation;
status0.Printf(_("Averaging: %3d"), m_samplesToAverage - m_calibrationAverageSamples + 1);
if (m_calibrationAverageSamples < m_samplesToAverage )
{
break;
}
m_calibrationAveragedLocation /= m_calibrationAverageSamples;
m_calibrationStartingLocation = m_calibrationAveragedLocation;
m_calibrationIterations = 0;
Debug.AddLine(wxString::Format("Falling through to state GO_LEFT, startinglocation=(%.2f, %.2f)",
m_calibrationStartingLocation.X, m_calibrationStartingLocation.Y));
m_calibrationState = CALIBRATION_STATE_GO_LEFT;
// fall through
case CALIBRATION_STATE_GO_LEFT:
if (stepsRemainingLeft > 0)
{
status0.Printf(_("Left Calibration: %3d"), stepsRemainingLeft);
m_calibrationIterations++;
moveLeft = true;
x_dist = m_calibrationStartingLocation.dX(currentLocation);
y_dist = m_calibrationStartingLocation.dY(currentLocation);
GuideLog.CalibrationStep(this, "Left", stepsRemainingLeft,
x_dist, y_dist,
currentLocation, m_calibrationStartingLocation.Distance(currentLocation));
m_calibrationDetails.raSteps.push_back(wxRealPoint(x_dist, y_dist)); // Just put "left" in "ra" steps
break;
}
Debug.AddLine(wxString::Format("Falling through to state AVERAGE_CENTER_LOCATION, position=(%.2f, %.2f)",
currentLocation.X, currentLocation.Y));
m_calibrationAverageSamples = 0;
m_calibrationAveragedLocation.SetXY(0.0, 0.0);
m_calibrationState = CALIBRATION_STATE_AVERAGE_CENTER_LOCATION;
// fall through
case CALIBRATION_STATE_AVERAGE_CENTER_LOCATION:
m_calibrationAverageSamples++;
m_calibrationAveragedLocation += currentLocation;
status0.Printf(_("Averaging: %3d"), m_samplesToAverage -m_calibrationAverageSamples+1);
if (m_calibrationAverageSamples < m_samplesToAverage )
{
break;
}
m_calibrationAveragedLocation /= m_calibrationAverageSamples;
m_calibration.xAngle = m_calibrationStartingLocation.Angle(m_calibrationAveragedLocation);
m_calibration.xRate = m_calibrationStartingLocation.Distance(m_calibrationAveragedLocation) /
(m_calibrationIterations * m_calibrationStepsPerIteration);
status1.Printf(_("angle=%.1f rate=%.2f"), m_calibration.xAngle * 180. / M_PI, m_calibration.xRate);
GuideLog.CalibrationDirectComplete(this, "Left", m_calibration.xAngle, m_calibration.xRate);
Debug.AddLine(wxString::Format("LEFT calibration completes with angle=%.1f rate=%.2f", m_calibration.xAngle * 180. / M_PI, m_calibration.xRate));
Debug.AddLine(wxString::Format("distance=%.2f iterations=%d", m_calibrationStartingLocation.Distance(m_calibrationAveragedLocation), m_calibrationIterations));
m_calibrationStartingLocation = m_calibrationAveragedLocation;
m_calibrationIterations = 0;
m_calibrationState = CALIBRATION_STATE_GO_UP;
Debug.AddLine(wxString::Format("Falling through to state GO_UP, startinglocation=(%.2f, %.2f)",
m_calibrationStartingLocation.X, m_calibrationStartingLocation.Y));
// fall through
case CALIBRATION_STATE_GO_UP:
if (stepsRemainingUp > 0)
{
status0.Printf(_("up Calibration: %3d"), stepsRemainingUp);
m_calibrationIterations++;
moveUp = true;
x_dist = m_calibrationStartingLocation.dX(currentLocation);
y_dist = m_calibrationStartingLocation.dY(currentLocation);
GuideLog.CalibrationStep(this, "Up", stepsRemainingLeft,
x_dist, y_dist,
currentLocation, m_calibrationStartingLocation.Distance(currentLocation));
m_calibrationDetails.decSteps.push_back(wxRealPoint(x_dist, y_dist)); // Just put "up" in "dec" steps
break;
}
Debug.AddLine(wxString::Format("Falling through to state AVERAGE_ENDING_LOCATION, position=(%.2f, %.2f)",
currentLocation.X, currentLocation.Y));
m_calibrationAverageSamples = 0;
m_calibrationAveragedLocation.SetXY(0.0, 0.0);
m_calibrationState = CALIBRATION_STATE_AVERAGE_ENDING_LOCATION;
// fall through
case CALIBRATION_STATE_AVERAGE_ENDING_LOCATION:
m_calibrationAverageSamples++;
m_calibrationAveragedLocation += currentLocation;
status0.Printf(_("Averaging: %3d"), m_samplesToAverage -m_calibrationAverageSamples+1);
if (m_calibrationAverageSamples < m_samplesToAverage )
{
break;
}
m_calibrationAveragedLocation /= m_calibrationAverageSamples;
m_calibration.yAngle = m_calibrationAveragedLocation.Angle(m_calibrationStartingLocation);
m_calibration.yRate = m_calibrationStartingLocation.Distance(m_calibrationAveragedLocation) /
(m_calibrationIterations * m_calibrationStepsPerIteration);
status1.Printf(_("angle=%.1f rate=%.2f"), m_calibration.yAngle * 180. / M_PI, m_calibration.yRate);
GuideLog.CalibrationDirectComplete(this, "Up", m_calibration.yAngle, m_calibration.yRate);
Debug.AddLine(wxString::Format("UP calibration completes with angle=%.1f rate=%.2f", m_calibration.yAngle * 180. / M_PI, m_calibration.yRate));
Debug.AddLine(wxString::Format("distance=%.2f iterations=%d", m_calibrationStartingLocation.Distance(m_calibrationAveragedLocation), m_calibrationIterations));
m_calibrationStartingLocation = m_calibrationAveragedLocation;
m_calibrationState = CALIBRATION_STATE_RECENTER;
Debug.AddLine(wxString::Format("Falling through to state RECENTER, position=(%.2f, %.2f)",
currentLocation.X, currentLocation.Y));
// fall through
case CALIBRATION_STATE_RECENTER:
status0.Printf(_("Finish Calibration: %3d"), stepsRemainingDownAndRight/2);
moveRight = (CurrentPosition(LEFT) >= m_calibrationStepsPerIteration);
moveDown = (CurrentPosition(UP) >= m_calibrationStepsPerIteration);
if (moveRight || moveDown)
{
Debug.AddLine(wxString::Format("CurrentPosition(LEFT)=%d CurrentPosition(UP)=%d", CurrentPosition(LEFT), CurrentPosition(UP)));
break;
}
m_calibrationState = CALIBRATION_STATE_COMPLETE;
Debug.AddLine(wxString::Format("Falling through to state COMPLETE, position=(%.2f, %.2f)",
currentLocation.X, currentLocation.Y));
// fall through
case CALIBRATION_STATE_COMPLETE:
m_calibration.declination = 0.;
m_calibration.pierSide = PIER_SIDE_UNKNOWN;
m_calibration.rotatorAngle = Rotator::RotatorPosition();
SetCalibration(m_calibration);
SetCalibrationDetails(m_calibrationDetails, m_calibration.xAngle, m_calibration.yAngle);
status1 = _T("calibration complete");
GuideLog.CalibrationComplete(this);
Debug.AddLine("Calibration Complete");
break;
default:
assert(false);
break;
}
if (moveUp)
{
assert(!moveDown);
pFrame->ScheduleCalibrationMove(this, UP, m_calibrationStepsPerIteration);
}
if (moveDown)
{
assert(!moveUp);
pFrame->ScheduleCalibrationMove(this, DOWN, m_calibrationStepsPerIteration);
}
if (moveRight)
{
assert(!moveLeft);
pFrame->ScheduleCalibrationMove(this, RIGHT, m_calibrationStepsPerIteration);
}
if (moveLeft)
{
assert(!moveRight);
pFrame->ScheduleCalibrationMove(this, LEFT, m_calibrationStepsPerIteration);
}
if (m_calibrationState != CALIBRATION_STATE_COMPLETE)
{
if (status1.IsEmpty())
{
double dX = m_calibrationStartingLocation.dX(currentLocation);
double dY = m_calibrationStartingLocation.dY(currentLocation);
double dist = m_calibrationStartingLocation.Distance(currentLocation);
status1.Printf(_T("dx=%4.1f dy=%4.1f dist=%4.1f"), dX, dY, dist);
}
}
if (!status0.IsEmpty())
{
pFrame->SetStatusText(status0, 0);
}
if (!status1.IsEmpty())
{
pFrame->SetStatusText(status1, 1);
}
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
bError = true;
ClearCalibration();
}
return bError;
}
wxPoint StepGuider::GetAoMaxPos(void) const
{
return wxPoint(MaxPosition(RIGHT), MaxPosition(UP));
}
bool StepGuider::IsAtLimit(GUIDE_DIRECTION direction, bool *atLimit)
{
*atLimit = CurrentPosition(direction) == MaxPosition(direction) - 1;
return false;
}
bool PositionInBounds(float x) const { return ((x >= MinPosition()) && (x <= MaxPosition())); }
float ClampPosition(float x) const { return std::max(MinPosition(), std::min(x, MaxPosition())); }
