eddy/mountcontrol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MccSimpleSlewingModel: the code has been rewritten in accordance with the

Browse Source 
changes in Eddy's LibSidServo
This commit is contained in:
Timur A. Fatkhullin 2025-12-03 00:35:52 +03:00
parent 54419b8e60
commit 7c9612c3a2
5 changed files with 35 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
asibfm700/asibfm700_mount.cpp
View File

@ -183,8 +183,8 @@ Asibfm700Mount::error_t Asibfm700Mount::initMount()
mpars.brakingAccelX = _hardwareConfig.hwConfig.Yconf.accel; // Sidereal defines HA-axis as Y-axis
mpars.brakingAccelY = _hardwareConfig.hwConfig.Xconf.accel; // Sidereal defines DEC-axis as X-axis
} else {
mpars.brakingAccelX = MCC_Y_ACCELERATION; // Sidereal defines HA-axis as Y-axis
mpars.brakingAccelY = MCC_X_ACCELERATION; // Sidereal defines DEC-axis as X-axis
mpars.brakingAccelX = 0.165806; // Sidereal defines HA-axis as Y-axis
mpars.brakingAccelY = 0.219911; // Sidereal defines DEC-axis as X-axis
}
auto st_err = setSlewingParams(mpars);
if (st_err) {

2
asibfm700/asibfm700_servocontroller.cpp
View File

@ -123,7 +123,7 @@ AsibFM700ServoController::error_t AsibFM700ServoController::hardwareSetState(har
// according to"SiTech protocol notes" X is DEC-axis and Y is HA-axis
coordval_pair_t cvalpair{.X{.val = state.Y, .t = tp}, .Y{.val = state.X, .t = tp}};
coordpair_t cpair{.X = state.endptY, .Y = state.endptX};
// coordpair_t cpair{.X = state.endptY, .Y = state.endptX};
// correctTo is asynchronous function!!!

2
asibfm700/asibfm700_servocontroller.h
View File

@ -83,7 +83,7 @@ public:
// the movement vector (i.e. sign of movement speed)
// this point is needed as Sidereal controller commands require not only moving speed but
// also 'target' point (point at which mount will stop)
double endptX, endptY;
// double endptX, endptY;
};

2
mcc/CMakeLists.txt
View File

@ -80,7 +80,7 @@ set(MCC_LIBRARY mcc)
add_library(${MCC_LIBRARY} INTERFACE ${MCC_LIBRARY_SRC})
target_compile_features(${MCC_LIBRARY} INTERFACE cxx_std_23)
target_compile_definitions(${MCC_LIBRARY} INTERFACE SPDLOG_USE_STD_FORMAT=1 SPDLOG_FMT_EXTERNAL=0)
target_link_libraries(${MCC_LIBRARY} INTERFACE spdlog Threads::Threads)
target_link_libraries(${MCC_LIBRARY} INTERFACE spdlog Threads::Threads atomic)
target_include_directories(${MCC_LIBRARY} INTERFACE ${ERFA_INCLUDE_DIR} ${BSPLINES_INCLUDE_DIR})
target_include_directories(${MCC_LIBRARY} INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>

100
mcc/mcc_slewing_model.h
View File

@ -124,7 +124,7 @@ public:
MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT logger)
: _stopSlewing(new std::atomic_bool()),
_currentParamsMutex(new std::mutex),
_lastError(MccSimpleSlewingModelErrorCode::ERROR_OK)
_lastError(new std::atomic<error_t>())
{
std::ostringstream os;
os << std::this_thread::get_id();
@ -132,6 +132,7 @@ public:
logger.logDebug(std::format("Create MccSimpleSlewingModel class instance (thread: {})", os.str()));
*_stopSlewing = true;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_OK;
_checkTargetFunc = [controls, logger, this]() mutable -> error_t {
typename CONTROLS_T::error_t t_err;
@ -181,7 +182,7 @@ public:
_slewingFunc = [controls, logger = std::move(logger), this](bool slew_and_stop) mutable -> error_t {
// reset error
_lastError = MccSimpleSlewingModelErrorCode::ERROR_OK;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_OK;
double braking_accelX, braking_accelY;
double min_time_to_pzone_in_secs;
@ -226,7 +227,7 @@ public:
t_err = controls->telemetryData(&tdata);
if (t_err) {
return _lastError =
return *_lastError =
mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY);
}
}
@ -236,47 +237,6 @@ public:
bool in_zone;
std::vector<bool> in_zone_vec;
/*
auto pz_err = controls->inPZone(tdata.target, &in_zone, &in_zone_vec);
if (pz_err) {
*_stopSlewing = true;
return _lastError =
mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
if (in_zone) {
*_stopSlewing = true;
size_t i = 0;
for (; i < in_zone_vec.size(); ++i) {
if (in_zone_vec[i]) {
break;
}
}
logger.logError("target point is in prohibited zone (zone index: {})! Entered target coordinates:", i);
logger.logError(std::format(" RA-APP, DEC-APP, HA, LST: {}, {}, {}, {}",
mcc::MccAngle{tdata.target.RA_APP}.sexagesimal(true),
mcc::MccAngle{tdata.target.DEC_APP}.sexagesimal(),
mcc::MccAngle{tdata.target.HA}.sexagesimal(true),
mcc::MccAngle{tdata.LST}.sexagesimal(true)));
logger.logError(std::format(" AZ, ZD, ALT: {}, {}, {}", mcc::MccAngle{tdata.target.AZ}.sexagesimal(),
mcc::MccAngle{tdata.target.ZD}.sexagesimal(),
mcc::MccAngle{tdata.target.ALT}.sexagesimal()));
logger.logError(std::format(" hardware X, Y: {}, {}", mcc::MccAngle{tdata.target.X}.sexagesimal(),
mcc::MccAngle{tdata.target.Y}.sexagesimal()));
return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE;
}
if (*_stopSlewing) {
return _lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
*/
MccCelestialPoint cpt;
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
@ -292,14 +252,14 @@ public:
auto hw_err = controls->hardwareGetState(&hw_state);
if (hw_err) {
*_stopSlewing = true;
return _lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
return *_lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
}
hw_state.X = (double)tdata.target.X;
hw_state.Y = (double)tdata.target.Y;
hw_state.endptX = (double)tdata.target.X;
hw_state.endptY = (double)tdata.target.Y;
// hw_state.endptX = (double)tdata.target.X;
// hw_state.endptY = (double)tdata.target.Y;
{
std::lock_guard lock{*_currentParamsMutex};
@ -311,7 +271,7 @@ public:
if (*_stopSlewing) {
logger.logDebug("slewing was stopped!");
return _lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
return *_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
// start slewing
@ -336,15 +296,14 @@ public:
hw_err = controls->hardwareSetState(hw_state);
if (hw_err) {
*_stopSlewing = true;
return _lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
return *_lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
}
logger.logDebug(" the 'hardwareSetState' method performed successfully!");
double dist, dx, dy;
// double dist, dx, dy;
double dist;
// bool adjust_mode = false;
// static constexpr auto sideral_rate2 = slewing_params_t::sideralRate * slewing_params_t::sideralRate;
std::chrono::steady_clock::time_point start_slewing_tp, last_adjust_tp;
start_slewing_tp = std::chrono::steady_clock::now();
@ -369,7 +328,7 @@ public:
t_err = controls->waitForTelemetryData(&tdata, _currentParams.telemetryTimeout);
if (t_err) {
_lastError = mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY);
*_lastError = mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY);
break;
// *_stopSlewing = true;
// return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY);
@ -377,7 +336,7 @@ public:
}
if (*_stopSlewing) {
_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
break;
// return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
@ -437,7 +396,7 @@ public:
in_zone_vec.clear();
auto pz_err = controls->inPZone(cpt, &in_zone, &in_zone_vec);
if (pz_err) {
_lastError =
*_lastError =
mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
break;
// *_stopSlewing = true;
@ -465,7 +424,7 @@ public:
logger.logError(std::format(" hardware X, Y: {}, {}", mcc::MccAngle{tdata.X}.sexagesimal(),
mcc::MccAngle{tdata.Y}.sexagesimal()));
_lastError = MccSimpleSlewingModelErrorCode::ERROR_NEAR_PZONE;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_NEAR_PZONE;
break;
// *_stopSlewing = true;
// return MccSimpleSlewingModelErrorCode::ERROR_NEAR_PZONE;
@ -478,7 +437,7 @@ public:
if ((std::chrono::steady_clock::now() - start_slewing_tp) > _currentParams.slewTimeout) {
logger.logError("slewing process timeout!");
_lastError = MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT;
break;
// return MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT;
}
@ -488,7 +447,7 @@ public:
hw_err = controls->hardwareGetState(&hw_state);
if (hw_err) {
_lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
*_lastError = mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
break;
// *_stopSlewing = true;
// return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
@ -512,7 +471,8 @@ public:
t_err = controls->targetToMountDist(&dist);
if (t_err) {
_lastError = mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY);
*_lastError =
mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY);
break;
// *_stopSlewing = true;
// return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY);
@ -530,7 +490,7 @@ public:
if (*_stopSlewing) {
_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
break;
// return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
@ -560,7 +520,7 @@ public:
hw_err = controls->hardwareSetState(hw_state);
if (hw_err) {
_lastError = MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE;
break;
// *_stopSlewing = true;
// return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
@ -576,7 +536,7 @@ public:
hw_err = controls->hardwareGetState(&hw_state);
if (hw_err) {
_lastError = MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE;
break;
// *_stopSlewing = true;
// return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE);
@ -587,7 +547,7 @@ public:
}
if (*_stopSlewing) {
_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
*_lastError = MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
break;
// return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
@ -607,7 +567,7 @@ public:
t_err = controls->waitForTelemetryData(&tdata, _currentParams.telemetryTimeout);
if (t_err) {
return _lastError =
return *_lastError =
mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY);
}
}
@ -628,7 +588,7 @@ public:
mcc::MccAngle{tdata.ZD}.sexagesimal()));
}
return _lastError = MccSimpleSlewingModelErrorCode::ERROR_OK;
return *_lastError = MccSimpleSlewingModelErrorCode::ERROR_OK;
};
}
@ -651,9 +611,9 @@ public:
*_stopSlewing = false;
// check for target in p-zone
_lastError = _checkTargetFunc();
if (_lastError) { // return here immidiately
return _lastError;
*_lastError = _checkTargetFunc();
if (_lastError->load()) { // return here immidiately
return *_lastError;
}
// asynchronous slewing process
@ -696,7 +656,7 @@ public:
error_t slewingLastError() const
{
return _lastError;
return *_lastError;
}
protected:
@ -707,7 +667,7 @@ protected:
slewing_params_t _currentParams{};
std::unique_ptr<std::mutex> _currentParamsMutex{};
error_t _lastError;
std::unique_ptr<std::atomic<error_t>> _lastError;
std::future<error_t> _slewFuncFuture{};
};