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

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2025-08-28 00:43:55 +03:00
parent 45f655dc90
commit 2e5e1918e1
5 changed files with 271 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
mcc/mcc_tracking_model.h
View File

@@ -17,9 +17,11 @@ enum class MccSimpleTrackingModelErrorCode : int {
ERROR_OK,
ERROR_HW_GETSTATE,
ERROR_HW_SETSTATE,
ERROR_PCM_COMP,
ERROR_TELEMETRY_TIMEOUT,
ERROR_PZONE_CONTAINER_COMP,
ERROR_IN_PZONE,
ERROR_NEAR_PZONE,
ERROR_UNEXPECTED_AXIS_RATES
};
@@ -41,12 +43,9 @@ class is_error_code_enum<mcc::MccSimpleTrackingModelErrorCode> : public true_typ
namespace mcc
{
template <MccMountType MOUNT_TYPE>
class MccSimpleTrackingModel
{
public:
static constexpr MccMountType mountType = MOUNT_TYPE;
typedef std::error_code error_t;
struct tracking_params_t {
@@ -56,68 +55,126 @@ public:
double trackSpeedY{};
std::chrono::seconds telemetryTimeout{3};
// minimal time to prohibited zone. if it is lesser then exit with error
std::chrono::seconds minTimeToPZone{10};
};
template <mcc_generic_mount_c MountT>
MccSimpleTrackingModel(MountT* mount) : _stopTracking(new std::atomic_bool())
template <mcc_telemetry_data_c TelemetryT,
mcc_hardware_c HardwareT,
mcc_PCM_c PcmT,
mcc_pzone_container_c PZoneContT>
MccSimpleTrackingModel(TelemetryT* telemetry, HardwareT* hardware, PcmT* pcm, PZoneContT* pz_cont)
: _stopTracking(new std::atomic_bool())
{
*_stopTracking = false;
if constexpr (mccIsEquatorialMount(mountType)) {
if constexpr (mccIsEquatorialMount(PcmT::mountType)) {
_currentTrackParams.trackSpeedX = tracking_params_t::sideralRate; // move along HA-axis with sideral rate
_currentTrackParams.trackSpeedY = 0.0;
}
_trackingFunc = [mount, this]() -> error_t {
typename MountT::hardware_state_t hw_state;
_trackingFunc = [telemetry, hardware, pcm, pz_cont, this]() -> error_t {
MccCelestialPoint cpt;
typename HardwareT::hardware_state_t hw_state;
// compute position in future
auto err = hardware->hardwareGetState(&hw_state);
if (err) {
return mcc_deduce_error(err, MccSimpleTrackingModelErrorCode::ERROR_HW_GETSTATE);
}
cpt.time_point = std::chrono::time_point_cast<decltype(cpt.time_point)>(hw_state.time_point);
if constexpr (mccIsEquatorialMount(PcmT::mountType)) {
cpt.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP;
} else if constexpr (mccIsAltAzMount(PcmT::mountType)) {
cpt.pair_kind = MccCoordPairKind::COORDS_KIND_AZALT;
static_assert(false, "NOT IMPLEMENTED!");
} else {
static_assert(false, "UNKNOW MOUNT TYPE!");
}
cpt.X = hw_state.X;
cpt.Y = hw_state.Y;
struct {
double dx, dy;
} pcm_res;
auto pcm_err = pcm->computePCM(cpt, &pcm_res);
if (pcm_err) {
return mcc_deduce_error(pcm_err, MccSimpleTrackingModelErrorCode::ERROR_PCM_COMP);
}
// to celestial coordinates
cpt.X += pcm_res.dx;
cpt.Y += pcm_res.dy;
if constexpr (mccIsEquatorialMount(PcmT::mountType)) {
cpt.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP;
if constexpr (mccIsEquatorialMount(mountType)) {
// just set sideral rate once
auto err = mount->hardwareGetState(&hw_state);
if (err) {
return mcc_deduce_error(err, MccSimpleTrackingModelErrorCode::ERROR_HW_GETSTATE);
}
// hw_state.time_point;
hw_state.speedX = _currentTrackParams.trackSpeedX;
hw_state.speedY = _currentTrackParams.trackSpeedY;
hw_state.moving_type = MountT::hardware_moving_state_t::HW_MOVE_TRACKING;
hw_state.moving_type = HardwareT::hardware_moving_state_t::HW_MOVE_TRACKING;
err = mount->hardwareSetState(std::move(hw_state));
err = hardware->hardwareSetState(std::move(hw_state));
if (err) {
return mcc_deduce_error(err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
}
// control prohibited zones
MccTelemetryData tdata;
std::vector<bool> pz_flags;
bool inzone_flag;
std::vector<std::chrono::duration<double>> pz_timeto; // in seconds
// std::vector<bool> pz_flags;
// bool inzone_flag;
while (!*_stopTracking) {
auto t_err = mount->waitForTelemetryData(&tdata, _currentTrackParams.telemetryTimeout);
auto pz_err = pz_cont->timeToPZone(tdata, &pz_timeto);
if (pz_err) {
return mcc_deduce_error(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
for (size_t i = 0; i < pz_cont->sizePZones(); ++i) {
if (pz_timeto[i] <= _currentTrackParams.minTimeToPZone) {
return MccSimpleTrackingModelErrorCode::ERROR_NEAR_PZONE;
}
}
auto t_err = telemetry->waitForTelemetryData(&tdata, _currentTrackParams.telemetryTimeout);
if (t_err) {
return mcc_deduce_error(t_err, MccSimpleTrackingModelErrorCode::ERROR_TELEMETRY_TIMEOUT);
}
if (*_stopTracking) {
break;
}
// check for current axis speed
if (utils::isEqual(tdata.speedX, 0.0) && utils::isEqual(tdata.speedY, 0.0)) {
// unhandled stop state?!!!
return MccSimpleTrackingModelErrorCode::ERROR_UNEXPECTED_AXIS_RATES;
}
auto pz_err = mount->inPZone(tdata, &inzone_flag, &pz_flags);
if (pz_err) {
return mcc_deduce_error(t_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
// auto pz_err = mount->inPZone(tdata, &inzone_flag, &pz_flags);
// if (pz_err) {
// return mcc_deduce_error(t_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
// }
if (inzone_flag) {
// logging
return MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE;
}
// if (inzone_flag) {
// // logging
// return MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE;
// }
}
return MccSimpleTrackingModelErrorCode::ERROR_OK;
} else if constexpr (mccIsAltAzMount(mountType)) {
} else if constexpr (mccIsAltAzMount(PcmT::mountType)) {
static_assert(false, "NOT IMPLEMENTED!");
} else {
static_assert(false, "UNKNOW MOUNT TYPE!");