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-07-21 00:33:06 +03:00
parent 9cd52267d6
commit 6d65efd0af
6 changed files with 323 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
cxx/mcc_slew_model.h
View File

@@ -19,7 +19,6 @@ namespace mcc
* [azimuth, zenithal distance] (see sources code below)
*/
template <traits::mcc_mount_telemetry_c TELEMETRY_T>
class MccSimpleSlewModel
{
public:
@@ -37,26 +36,47 @@ public:
};
template <traits::mcc_mount_hardware_c HARDWARE_T,
traits::mcc_astrom_engine_c ASTROM_T,
traits::mcc_mount_pec_c PEC_T>
MccSimpleSlewModel(HARDWARE_T& hardware, ASTROM_T& astrom_engine, PEC_T& pec)
template <traits::mcc_mount_controls_c MOUNT_CONTROLS_T>
MccSimpleSlewModel(MOUNT_CONTROLS_T& mount_controls)
{
const auto p_hardware = &hardware;
const auto p_astrom_engine = &astrom_engine;
const auto p_pec = &pec;
// deduce controls types
using astrom_engine_t = decltype(mount_controls.astrometryEngine);
using hardware_t = decltype(mount_controls.hardware);
using pec_t = decltype(mount_controls.PEC);
using telemetry_t = decltype(mount_controls.telemetry);
using tpl_pz_t = decltype(mount_controls.prohibitedZones);
static constexpr size_t Nzones = std::tuple_size_v<tpl_pz_t>;
const auto p_mount_controls = &mount_controls;
// prohibited zones related lambdas
auto check_zones = [p_mount_controls]<size_t... Is>(std::array<bool, sizeof...(Is)>& result,
std::index_sequence<Is...>) {
((result[Is] = std::get<Is>(p_mount_controls->prohibitedZones).inZone(p_mount_controls->telemetry.data())),
...);
bool flag = false;
((flag |= result[Is]), ...);
return flag;
};
_slewFunc = [p_mount_controls](this auto&& self, const slew_params_t& slew_pars) {
auto& astrom_engine = p_mount_controls->astrometryEngine;
auto& hardware = p_mount_controls->hardware;
auto& pec = p_mount_controls->PEC;
auto& telemetry = p_mount_controls->telemetry;
_slewFunc = [p_hardware, p_astrom_engine, p_pec](this auto&& self, const slew_params_t& slew_pars,
TELEMETRY_T& telemetry) {
using coord_t = typename ASTROM_T::coord_t;
using jd_t = typename ASTROM_T::juldate_t;
using coord_t = typename astrom_engine_t::coord_t;
using jd_t = typename astrom_engine_t::juldate_t;
typename HARDWARE_T::axes_pos_t ax_pos;
typename hardware_t::axes_pos_t ax_pos;
error_t res_err;
typename ASTROM_T::error_t ast_err;
typename astrom_engine_t::error_t ast_err;
typename pec_t::error_t pec_err;
if (slew_pars.coordPairKind == mcc::MccCoordPairKind::COORDS_KIND_XY) {
// trivial case (the pair is interpretated as raw encoder coordinates)
@@ -66,26 +86,24 @@ public:
mcc::MccCoordPairKind::COORDS_KIND_RADEC_ICRS) { // catalog coordinates
jd_t jd;
coord_t ra_app, dec_app, ha, az, alt;
typename ASTROM_T::eo_t eo;
typename astrom_engine_t::eo_t eo;
ast_err = p_astrom_engine->greg2jul(std::chrono::system_clock::now(), jd);
ast_err = astrom_engine->greg2jul(std::chrono::system_clock::now(), jd);
if (!ast_err) {
ast_err = p_astrom_engine->icrs2obs(slew_pars.x, slew_pars.y, jd, ra_app, dec_app, ha, az, alt, eo);
ast_err = astrom_engine->icrs2obs(slew_pars.x, slew_pars.y, jd, ra_app, dec_app, ha, az, alt, eo);
if (!ast_err) {
if constexpr (mccIsEquatorialMount(PEC_T::mountType)) {
if constexpr (mccIsEquatorialMount(pec_t::mountType)) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_HADEC_APP,
.x = ha,
.y = dec_app,
.stop = slew_pars.stop},
telemetry);
} else if constexpr (mccIsAltAzMount(PEC_T::mountType)) {
.stop = slew_pars.stop});
} else if constexpr (mccIsAltAzMount(pec_t::mountType)) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_AZALT,
.x = az,
.y = alt,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
}
@@ -94,78 +112,73 @@ public:
} else if (slew_pars.coordPairKind == mcc::MccCoordPairKind::COORDS_KIND_RADEC_APP) { // apparent
jd_t jd;
typename ASTROM_T::eo_t eo;
typename astrom_engine_t::eo_t eo;
ast_err = p_astrom_engine->greg2jul(std::chrono::system_clock::now(), jd);
ast_err = astrom_engine->greg2jul(std::chrono::system_clock::now(), jd);
if (!ast_err) {
typename ASTROM_T::sideral_time_t lst;
ast_err = p_astrom_engine->apparentSiderTime(jd, lst, true);
typename astrom_engine_t::sideral_time_t lst;
ast_err = astrom_engine->apparentSiderTime(jd, lst, true);
if (!ast_err) {
ast_err = p_astrom_engine->eqOrigins(jd, eo);
ast_err = astrom_engine->eqOrigins(jd, eo);
if (!ast_err) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_HADEC_APP,
.x = lst - slew_pars.x + eo, // HA = LST - RA_APP + EO
.y = slew_pars.y,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
}
}
} else if (slew_pars.coordPairKind == mcc::MccCoordPairKind::COORDS_KIND_HADEC_APP) { // apparent
if constexpr (mccIsEquatorialMount(PEC_T::mountType)) { // compute encoder coordinates
if constexpr (mccIsEquatorialMount(pec_t::mountType)) { // compute encoder coordinates
coord_t eps = 1.0 / 3600.0 * std::numbers::pi / 180.0;
typename PEC_T::pec_result_t pec_res;
typename pec_t::pec_result_t pec_res;
auto err = p_pec->reverseCompute(slew_pars.x, slew_pars.y, pec_res, eps, 10);
if (!err) {
pec_err = pec->reverseCompute(slew_pars.x, slew_pars.y, pec_res, eps, 10);
if (!pec_err) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_XY,
.x = slew_pars.x - pec_res.dx,
.y = slew_pars.y - pec_res.dy,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
} else if constexpr (mccIsAltAzMount(PEC_T::mountType)) {
} else if constexpr (mccIsAltAzMount(pec_t::mountType)) {
coord_t az, alt;
ast_err = p_astrom_engine->hadec2azalt(slew_pars.x, slew_pars.y, az, alt);
ast_err = astrom_engine->hadec2azalt(slew_pars.x, slew_pars.y, az, alt);
if (!ast_err) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_AZALT,
.x = az,
.y = alt,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
}
} else if (slew_pars.coordPairKind == mcc::MccCoordPairKind::COORDS_KIND_AZALT) {
if constexpr (mccIsEquatorialMount(PEC_T::mountType)) {
if constexpr (mccIsEquatorialMount(pec_t::mountType)) {
coord_t ha, dec;
ast_err = p_astrom_engine->azalt2hadec(slew_pars.x, slew_pars.y, ha, dec);
ast_err = astrom_engine->azalt2hadec(slew_pars.x, slew_pars.y, ha, dec);
if (!ast_err) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_HADEC_APP,
.x = ha,
.y = dec,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
} else if constexpr (mccIsAltAzMount(PEC_T::mountType)) { // compute encoder coordinates
} else if constexpr (mccIsAltAzMount(pec_t::mountType)) { // compute encoder coordinates
coord_t eps = 1.0 / 3600.0 * std::numbers::pi / 180.0;
typename PEC_T::pec_result_t pec_res;
typename pec_t::pec_result_t pec_res;
auto err = p_pec->reverseCompute(slew_pars.x, slew_pars.y, pec_res, eps, 10);
if (!err) {
pec_err = pec->reverseCompute(slew_pars.x, slew_pars.y, pec_res, eps, 10);
if (!pec_err) {
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_XY,
.x = slew_pars.x - pec_res.dx,
.y = slew_pars.y - pec_res.dy,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
} else {
@@ -178,32 +191,57 @@ public:
res_err = self({.coordPairKind = mcc::MccCoordPairKind::COORDS_KIND_AZALT,
.x = slew_pars.x,
.y = std::numbers::pi / 2.0 - slew_pars.y,
.stop = slew_pars.stop},
telemetry);
.stop = slew_pars.stop});
}
if (res_err) {
return res_err;
}
if (!ast_err) {
auto err = p_hardware->setPos(std::move(ax_pos));
if (pec_err) {
// ???????????
return std::error_code(); // !!!!!!!!!!!!!!!
}
while (true) {
if (!ast_err) {
typename telemetry_t::error_t t_err;
typename telemetry_t::mount_telemetry_data_t t_data;
// move mount (it is assumed this is asynchronous operation!!!)
typename hardware_t::error_t err = hardware->setPos(std::move(ax_pos));
std::array<bool, Nzones> pz_result;
if (!err) {
//
// what is the condition for mount reaches given position?!!
//
while (true) {
t_err = telemetry.data(t_data);
if (t_err) {
// ?????????!!!!!!!!!!
}
// check prohibited zones
if (check_zones(pz_result, std::make_index_sequence<Nzones>{})) {
// stop mount ?!!!!!!!!!!!!!!!!!!!!!
// return in-zone-error-code
}
}
}
}
};
}
error_t slew(const slew_params_t& pars, TELEMETRY_T& telemetry)
error_t slew(const slew_params_t& pars)
{
error_t res_err = _slewFunc(pars, telemetry);
error_t res_err = _slewFunc(pars);
return res_err;
}
protected:
std::function<error_t(const slew_params_t&, TELEMETRY_T&)> _slewFunc{};
std::function<error_t(const slew_params_t&)> _slewFunc{};
};