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

Compare commits

base: eddy:c45d17b236462d4e221c9aace919777a1cd4d79c
Branches Tags
eddy:main
..
compare: eddy:34d22614a629b6462d5e0247238ddb4c88b6d50b
Branches Tags
eddy:main

No commits in common. "c45d17b236462d4e221c9aace919777a1cd4d79c" and "34d22614a629b6462d5e0247238ddb4c88b6d50b" have entirely different histories.
c45d17b236 ... 34d22614a6

9 changed files with 80 additions and 232 deletions
Show Stats Expand all files Collapse all files

12
cxx/asibfm700_mount.cpp
View File

@ -7,12 +7,12 @@ template <mcc::traits::mcc_range_of_input_char_range R>
AsibFM700Mount::AsibFM700Mount(AsibFM700Config config, std::shared_ptr<spdlog::logger> logger, const R& pattern_range)
: mcc::utils::MccSpdlogLogger(std::move(logger), pattern_range),
_currentConfig(std::move(config)),
base_gm_t({_currentConfig.astromEngineState},
{_currentConfig.hardwareConfig},
{_currentConfig.pecData},
AsibFM700Telemetry{_astromEngine, _pec, _hardware},
slew_model_t{_telemetry, _hardware, _pzFuncs},
guiding_model_t{_telemetry, _hardware, _pzFuncs})
base_gm_t(std::make_tuple(_currentConfig.astromEngineState),
std::make_tuple(_currentConfig.hardwareConfig),
std::make_tuple(_currentConfig.pecData),
std::make_tuple(std::ref(_astromEngine), std::ref(_pec), std::ref(_hardware)),
std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)),
std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)))
{
}

3
cxx/asibfm700_mount.h
View File

@ -29,9 +29,6 @@ class AsibFM700Mount : public mcc::utils::MccSpdlogLogger,
AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger>>;
public:
typedef AsibFM700SlewModel<mcc::utils::MccSpdlogLogger> slew_model_t;
typedef AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger> guiding_model_t;
template <mcc::traits::mcc_range_of_input_char_range R = decltype(LOGGER_DEFAULT_FORMAT)>
AsibFM700Mount(AsibFM700Config config,
std::shared_ptr<spdlog::logger> logger,

46
cxx/mcc_generic_mount.h
View File

@ -32,22 +32,6 @@ struct MccPZoneWrapper {
pz_inzone_func_t inZone;
pz_timeto_func_t timeTo;
pz_timefrom_func_t timeFrom;
MccPZoneWrapper(MccPZoneWrapper&& other)
: inZone(std::move(other.inZone)), timeTo(std::move(other.timeTo)), timeFrom(std::move(other.timeFrom)) {};
MccPZoneWrapper& operator=(MccPZoneWrapper&& other)
{
if (this != &other) {
inZone = std::move(other.inZone);
timeTo = std::move(other.timeTo);
timeFrom = std::move(other.timeFrom);
}
return *this;
};
MccPZoneWrapper() = default;
};
@ -72,18 +56,24 @@ public:
static constexpr MccMountType mountType = pec_t::mountType;
MccGenericMount(ASTROM_ENGINE_T aengine,
HARDWARE_T hw,
PEC_T pec,
TELEMETRY_T tmtry,
SLEWMODEL_T smodel,
GUIDINGMODEL_T gmodel)
: _astromEngine(std::move(aengine)),
_hardware(std::move(hw)),
_pec(std::move(pec)),
_telemetry(std::move(tmtry)),
_slewModel(std::move(smodel)),
_guidingModel(std::move(gmodel))
template <traits::mcc_tuple_c ASTROM_ENGINE_CTOR_T,
traits::mcc_tuple_c HARDWARE_CTOR_T,
traits::mcc_tuple_c PEC_CTOR_T,
traits::mcc_tuple_c TELEMETRY_CTOR_T,
traits::mcc_tuple_c SLEWMODEL_CTOR_T,
traits::mcc_tuple_c GUIDINGMODEL_CTOR_T>
MccGenericMount(ASTROM_ENGINE_CTOR_T aengine_ctor_args,
HARDWARE_CTOR_T hw_ctor_args,
PEC_CTOR_T pec_ctor_args,
TELEMETRY_CTOR_T t_ctor_args,
SLEWMODEL_CTOR_T smodel_ctor_args,
GUIDINGMODEL_CTOR_T gmodel_ctor_args)
: _astromEngine(std::make_from_tuple<ASTROM_ENGINE_T>(std::move(aengine_ctor_args))),
_hardware(std::make_from_tuple<HARDWARE_T>(std::move(hw_ctor_args))),
_pec(std::make_from_tuple<PEC_T>(std::move(pec_ctor_args))),
_telemetry(std::make_from_tuple<TELEMETRY_T>(std::move(t_ctor_args))),
_slewModel(std::make_from_tuple<SLEWMODEL_T>(std::move(smodel_ctor_args))),
_guidingModel(std::make_from_tuple<GUIDINGMODEL_T>(std::move(gmodel_ctor_args)))
{
}

7
cxx/mcc_guiding_model.h
View File

@ -116,8 +116,7 @@ public:
template <traits::mcc_mount_telemetry_c TELEMETRY_T,
traits::mcc_mount_hardware_c HARDWARE_T,
traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T,
// traits::mcc_tuple_c PZ_T,
traits::mcc_tuple_c PZ_T,
typename... LoggerCtorArgTs>
MccSimpleGuidingModel(TELEMETRY_T& telemetry,
HARDWARE_T& hardware,
@ -133,9 +132,7 @@ public:
template <traits::mcc_mount_telemetry_c TELEMETRY_T,
traits::mcc_mount_hardware_c HARDWARE_T,
traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T
// traits::mcc_tuple_c PZ_T
>
traits::mcc_tuple_c PZ_T>
MccSimpleGuidingModel(TELEMETRY_T& telemetry, HARDWARE_T& hardware, PZ_T& prohibited_zone)
requires(std::same_as<LoggerT, MccNullLogger>)
{

19
cxx/mcc_mount_concepts.h
View File

@ -429,7 +429,7 @@ concept mcc_prohibited_zone_c =
// static constexpr member to represent inifite duration
requires requires {
requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t const>;
requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t>;
[]() {
constexpr auto val = T::infiniteDuration;
return val;
@ -438,7 +438,7 @@ concept mcc_prohibited_zone_c =
// static constexpr member to represent zero duration
requires requires {
requires std::same_as<decltype(T::zeroDuration), typename T::duration_t const>;
requires std::same_as<decltype(T::zeroDuration), typename T::duration_t>;
[]() {
constexpr auto val = T::zeroDuration;
return val;
@ -449,13 +449,13 @@ concept mcc_prohibited_zone_c =
// the type 'T' must define a static constexpr member of type MccCoordPairKind
// to declarate type of coordinate pair used to describe the zone.
// This coordinate pair must be used as input in the 'inZone' class method.
// requires requires {
// requires std::same_as<decltype(T::zoneCoordPairKind), const MccCoordPairKind>;
// []() {
// constexpr MccCoordPairKind val = T::zoneCoordPairKind;
// return val;
// }(); // to ensure that 'zoneCoordPairKind' can be used at compile-time context
// };
requires requires {
requires std::same_as<decltype(T::zoneCoordPairKind), const MccCoordPairKind>;
[]() {
constexpr MccCoordPairKind val = T::zoneCoordPairKind;
return val;
}(); // to ensure that 'zoneCoordPairKind' can be used at compile-time context
};
// return a name of the zone
{ t_const.name() } -> mcc_formattable;
@ -506,6 +506,7 @@ concept mcc_irange_of_pzones_c = mcc_mount_telemetry_data_c<TelemetryDataT> && s
mcc_prohibited_zone_c<std::ranges::range_value_t<T>, TelemetryDataT>;
/* MOUNT GENERIC CONTROLS */

2
cxx/mcc_mount_pz.h
View File

@ -243,6 +243,4 @@ private:
typedef MccAltLimitPZ<MccAltLimitKind::MIN_ALT_LIMIT> MccMinAltPZ;
typedef MccAltLimitPZ<MccAltLimitKind::MAX_ALT_LIMIT> MccMaxAltPZ;
static_assert(std::movable<MccMinAltPZ>);
} // namespace mcc

165
cxx/mcc_mount_pz_holder.h
View File

@ -1,165 +0,0 @@
#pragma once
/* MOUNT CONTROL COMPONENTS LIBRARY */
/* AN DEFAULT IMPLEMENTATION OF PROHIBITED ZONES HOLDER */
#include "mcc_mount_concepts.h"
namespace mcc
{
template <traits::mcc_mount_telemetry_data_c TelemetryDataT>
class MccPZoneHolder
{
public:
typedef TelemetryDataT telemetry_data_t;
// a type to which the result of calling prohibited zone class methods 'timeTo' and 'timeFrom' will be converted
typedef std::chrono::duration<double> duration_t; // seconds as floating-point number
// adaptor class for prohibited zones
struct MccPZoneWrapper {
using duration_t = MccPZoneHolder::duration_t;
static constexpr duration_t infiniteDuration{std::numeric_limits<double>::infinity()};
static constexpr duration_t zeroDuration{0.0};
typedef std::function<bool(const TelemetryDataT&)> pz_inzone_func_t;
typedef std::function<duration_t(const TelemetryDataT&)> pz_timeto_func_t;
typedef std::function<duration_t(const TelemetryDataT&)> pz_timefrom_func_t;
MccCoordPairKind coordPairKind;
const std::function<std::string()> name;
pz_inzone_func_t inZone;
pz_timeto_func_t timeTo;
pz_timefrom_func_t timeFrom;
MccPZoneWrapper(MccPZoneWrapper&& other)
: inZone(std::move(other.inZone)), timeTo(std::move(other.timeTo)), timeFrom(std::move(other.timeFrom)) {};
MccPZoneWrapper& operator=(MccPZoneWrapper&& other)
{
if (this != &other) {
inZone = std::move(other.inZone);
timeTo = std::move(other.timeTo);
timeFrom = std::move(other.timeFrom);
}
return *this;
};
MccPZoneWrapper() = default;
};
size_t pzNumberOfZones() const { return _pzWrapperVec.size(); }
// add zone/zones
template <traits::mcc_prohibited_zone_c<telemetry_data_t> ZT,
traits::mcc_prohibited_zone_c<telemetry_data_t>... ZTs>
size_t pzAddZone(ZT zone, ZTs... zones)
{
auto zone_ptr = std::make_shared<ZT>(std::move(zone));
using d_t = typename MccPZoneWrapper::duration_t;
_pzWrapperVec.emplace_back(
{.coordPairKind = ZT::zoneCoordPairKind,
.name = [zone_ptr]() { return std::format("{}", zone_ptr->name()); },
.inZone = [zone_ptr](const telemetry_data_t& tmry_data) { return zone_ptr->inZone(tmry_data); },
.timeTo =
[zone_ptr](const telemetry_data_t& tmry_data) {
auto d = zone_ptr->timeTo(tmry_data);
if constexpr (std::same_as<typename ZT::duration_t, d_t>) {
return d;
} else {
if (d == ZT::infiniteDuration) {
return MccPZoneWrapper::infiniteDuration;
} else if (d == ZT::zeroDuration) {
return MccPZoneWrapper::zeroDuration;
}
return std::chrono::duration_cast<d_t>(d);
}
},
.timeFrom =
[zone_ptr](const telemetry_data_t& tmry_data) {
auto d = zone_ptr->timeFrom(tmry_data);
if constexpr (std::same_as<typename ZT::duration_t, d_t>) {
return d;
} else {
if (d == ZT::infiniteDuration) {
return MccPZoneWrapper::infiniteDuration;
} else if (d == ZT::zeroDuration) {
return MccPZoneWrapper::zeroDuration;
}
return std::chrono::duration_cast<d_t>(d);
}
}});
if constexpr (sizeof...(ZTs)) {
pzAddZone(std::move(zones)...);
}
return _pzWrapperVec.size();
}
void pzClearZones()
{
// stop mount here?!!
_pzWrapperVec.clear();
}
// visitors
template <std::invocable<MccPZoneWrapper> FT>
auto pzForeachZone(FT&& func)
requires std::same_as<std::invoke_result_t<FT, MccPZoneWrapper>, void>
{
for (auto& wr : _pzWrapperVec) {
std::forward<FT>(func)(wr);
}
}
template <std::invocable<MccPZoneWrapper> FT,
std::ranges::output_range<std::invoke_result_t<FT, MccPZoneWrapper>> ResT =
std::vector<std::invoke_result_t<FT, MccPZoneWrapper>>>
auto pzForeachZone(FT&& func)
requires(!std::same_as<std::invoke_result_t<FT, MccPZoneWrapper>, void>)
{
ResT result;
for (auto& wr : _pzWrapperVec) {
std::back_inserter(result) = std::forward<FT>(func)(wr);
}
return result;
}
template <std::ranges::output_range<bool> RT>
bool pzInZone(const telemetry_data_t& tdata, RT& result)
{
bool in_zone = false;
auto const p_tdata = &tdata;
result = pzForeachZone<RT>([&in_zone, p_tdata](auto& wr) {
bool r = wr.inZone(*p_tdata);
in_zone |= r;
return r;
});
return in_zone;
}
protected:
std::vector<MccPZoneWrapper> _pzWrapperVec{};
};
} // namespace mcc

6
cxx/mcc_slew_model.h
View File

@ -126,8 +126,7 @@ public:
template <traits::mcc_mount_telemetry_c TELEMETRY_T,
traits::mcc_mount_hardware_c HARDWARE_T,
traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T,
// traits::mcc_tuple_c PZ_T, // std::tuple of prohibited zones
traits::mcc_tuple_c PZ_T, // std::tuple of prohibited zones
typename... LoggerCtorArgTs>
MccSimpleSlewModel(TELEMETRY_T& telemetry,
HARDWARE_T& hardware,
@ -143,8 +142,7 @@ public:
template <traits::mcc_mount_telemetry_c TELEMETRY_T,
traits::mcc_mount_hardware_c HARDWARE_T,
traits::mcc_irange_of_pzones_c<typename TELEMETRY_T::mount_telemetry_data_t> PZ_T
// traits::mcc_tuple_c PZ_T // std::tuple of prohibited zones
traits::mcc_tuple_c PZ_T // std::tuple of prohibited zones
>
MccSimpleSlewModel(TELEMETRY_T& telemetry, HARDWARE_T& hardware, PZ_T& prohibited_zone)
requires(std::same_as<LoggerT, MccNullLogger>)

52
cxx/mcc_spdlog.h
View File

@ -46,25 +46,52 @@ public:
virtual ~MccSpdlogLogger() = default;
void setLogLevel(loglevel_t log_level) { _loggerSPtr->set_level(log_level); }
void setLogLevel(loglevel_t log_level)
{
_loggerSPtr->set_level(log_level);
}
loglevel_t getLogLevel() const { return _loggerSPtr->level(); }
loglevel_t getLogLevel() const
{
return _loggerSPtr->level();
}
void logMessage(loglevel_t level, const std::string& msg) { _loggerSPtr->log(level, msg); }
void logMessage(loglevel_t level, const std::string& msg)
{
_loggerSPtr->log(level, msg);
}
// specialized for given level methods
void logCritical(const std::string& msg) { logMessage(spdlog::level::critical, msg); }
void logCritical(const std::string& msg)
{
logMessage(spdlog::level::critical, msg);
}
void logError(const std::string& msg) { logMessage(spdlog::level::err, msg); }
void logError(const std::string& msg)
{
logMessage(spdlog::level::err, msg);
}
void logWarn(const std::string& msg) { logMessage(spdlog::level::warn, msg); }
void logWarn(const std::string& msg)
{
logMessage(spdlog::level::warn, msg);
}
void logInfo(const std::string& msg) { logMessage(spdlog::level::info, msg); }
void logInfo(const std::string& msg)
{
logMessage(spdlog::level::info, msg);
}
void logDebug(const std::string& msg) { logMessage(spdlog::level::debug, msg); }
void logDebug(const std::string& msg)
{
logMessage(spdlog::level::debug, msg);
}
void logTrace(const std::string& msg) { logMessage(spdlog::level::trace, msg); }
void logTrace(const std::string& msg)
{
logMessage(spdlog::level::trace, msg);
}
template <traits::mcc_formattable... ArgTs>
void logMessage(spdlog::level::level_enum level, spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
@ -149,7 +176,12 @@ protected:
_loggerSPtr->set_pattern(_currentLogPattern);
}
void addMarkToPatternIdx(const char* mark, size_t after_idx = 1) { addMarkToPatternIdx(std::string_view{mark}); }
void addMarkToPatternIdx(const char* mark, size_t after_idx = 1)
{
addMarkToPatternIdx(std::string_view{mark});
}
};
} // namespace mcc::utils