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-18 19:05:41 +03:00
parent e7c2826b5c
commit 464c262e08
12 changed files with 419 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
cxx/CMakeLists.txt
View File

@ -123,13 +123,19 @@ set(CNTR_PROTO_LIB comm_proto)
add_library(${CNTR_PROTO_LIB} STATIC ${CNTR_PROTO_LIB_SRC})
set(MCC_LIBRARY_SRC mcc_mount_concepts.h mcc_mount.h mcc_mount_coord.h mcc_mount_events_states.h mcc_finite_state_machine.h
mcc_mount_pec.h mcc_mount_pz.h mcc_traits.h mcc_mount_telemetry.h mcc_mount_config.h mcc_mount_astro_erfa.h mcc_astrom_iers.h mcc_astrom_iers_default.h mcc_utils.h)
set(MCC_LIBRARY_SRC mcc_mount_concepts.h mcc_fsm_mount.h mcc_mount_coord.h mcc_mount_events_states.h mcc_finite_state_machine.h
mcc_mount_pec.h mcc_mount_pz.h mcc_traits.h mcc_mount_telemetry.h mcc_mount_config.h mcc_mount_astro_erfa.h mcc_astrom_iers.h mcc_astrom_iers_default.h
mcc_utils.h mcc_spdlog.h)
set(MCC_LIBRARY mcc)
add_library(${MCC_LIBRARY} INTERFACE ${MCC_LIBRARY_SRC})
target_compile_features(${MCC_LIBRARY} INTERFACE cxx_std_23)
target_include_directories(${MCC_LIBRARY} INTERFACE ${FITPACK_INCLUDE_DIR})
set(ASIBFM700_LIB_SRC asibfm700_hardware.h asibfm700_hardware.cpp)
set(ASIBFM700_LIB asibfm700)
add_library(${ASIBFM700_LIB} STATIC ${ASIBFM700_LIB_SRC})
# set(MOUNT_SERVER_APP_SRC mount.h mount_state.h mount_server.cpp comm_server.h comm_server_endpoint.h comm_server_configfile.h mount_astrom.h
# mount_astrom_default.h mcc_coord.h mount_pz.h mcc_fsm.h mcc_fsm_utils.h mcc_finite_state_machine.h mcc_mount_events_states.h)
# set(MOUNT_SERVER_APP mount_server)

138
cxx/asibfm700_hardware.cpp Normal file
View File

@ -0,0 +1,138 @@
#include "asibfm700_hardware.h"
using namespace asibfm700;
/* error category implementation */
const char* AsibFM700HardwareErrorCategory::name() const noexcept
{
return "ASTROSIB FM700 MOUNT HARDWARE ERROR CATEGORY";
}
std::string AsibFM700HardwareErrorCategory::message(int ec) const
{
AsibFM700HardwareErrorCode code = static_cast<AsibFM700HardwareErrorCode>(ec);
std::string msg;
switch (code) {
case AsibFM700HardwareErrorCode::ERROR_OK:
msg = "OK";
case asibfm700::AsibFM700HardwareErrorCode::ERROR_FATAL:
msg = "fatal hardware error";
case AsibFM700HardwareErrorCode::ERROR_BADFORMAT:
msg = "wrong arguments of function";
case AsibFM700HardwareErrorCode::ERROR_ENCODERDEV:
msg = "encoder device error or can't open";
case AsibFM700HardwareErrorCode::ERROR_MOUNTDEV:
msg = "mount device error or can't open";
case AsibFM700HardwareErrorCode::ERROR_FAILED:
msg = "failed to run command - protocol error";
default:
msg = "UNKNOWN ERROR";
}
return msg;
}
const AsibFM700HardwareErrorCategory& AsibFM700HardwareErrorCategory::get()
{
static const AsibFM700HardwareErrorCategory constInst;
return constInst;
}
/* AsibFM700Hardware CLASS IMPLEMENTATION */
/* static methods */
// void AsibFM700Hardware::moveInst(AsibFM700Hardware* from, AsibFM700Hardware* to)
// {
// to->_hwConfig = std::move(from->_hwConfig);
// to->_deviceConfig = std::move(from->_deviceConfig);
// from->_deviceConfig.MountDevPath = nullptr;
// from->_deviceConfig.EncoderDevPath = nullptr;
// from->_deviceConfig.EncoderXDevPath = nullptr;
// from->_deviceConfig.EncoderYDevPath = nullptr;
// }
/* constructors and destructor */
AsibFM700Hardware::AsibFM700Hardware(const hardware_config_t& conf) : _hardwareConfig(conf)
{
_hardwareConfig.devConfig.MountDevPath = const_cast<char*>(_hardwareConfig.MountDevPath.c_str());
_hardwareConfig.devConfig.EncoderDevPath = const_cast<char*>(_hardwareConfig.EncoderDevPath.c_str());
_hardwareConfig.devConfig.EncoderXDevPath = const_cast<char*>(_hardwareConfig.EncoderXDevPath.c_str());
_hardwareConfig.devConfig.EncoderYDevPath = const_cast<char*>(_hardwareConfig.EncoderYDevPath.c_str());
}
// AsibFM700Hardware::AsibFM700Hardware(AsibFM700Hardware&& other)
// {
// moveInst(&other, this);
// }
// AsibFM700Hardware& AsibFM700Hardware::operator=(AsibFM700Hardware&& other)
// {
// moveInst(&other, this);
// return *this;
// }
AsibFM700Hardware::~AsibFM700Hardware() {}
std::string_view AsibFM700Hardware::id() const
{
return "Sidereal Technology Servo II controller";
}
AsibFM700Hardware::error_t AsibFM700Hardware::setPos(AsibFM700Hardware::axes_pos_t pos)
{
double X = pos.x, Y = pos.y;
auto err = static_cast<AsibFM700HardwareErrorCode>(Mount.moveTo(&X, &Y));
return err;
}
AsibFM700Hardware::error_t AsibFM700Hardware::getPos(AsibFM700Hardware::axes_pos_t& pos)
{
mountdata_t data;
auto err = static_cast<AsibFM700HardwareErrorCode>(Mount.getMountData(&data));
if (err == AsibFM700HardwareErrorCode::ERROR_OK) {
// time point from sidservo library is 'struct timeval', i.e., seconds and
// microseconds ellapsed from UNIX time epoch
using secs_t = std::chrono::duration<double>;
secs_t secs = secs_t{1.0 * data.encposition.msrtime.tv_sec + 1.0E-6 * data.encposition.msrtime.tv_usec};
pos.time_point = time_point_t{std::chrono::duration_cast<time_point_t::duration>(secs)};
pos.x = data.encposition.X;
pos.y = data.encposition.Y;
}
return err;
}
AsibFM700Hardware::error_t AsibFM700Hardware::stop()
{
auto err = static_cast<AsibFM700HardwareErrorCode>(Mount.stop());
return err;
}
AsibFM700Hardware::error_t AsibFM700Hardware::init()
{
auto err = static_cast<AsibFM700HardwareErrorCode>(Mount.init(&_hardwareConfig.devConfig));
return err;
}

128
cxx/asibfm700_hardware.h Normal file
View File

@ -0,0 +1,128 @@
#pragma once
/* AstroSIB-FM700 FORK MOUNT CONTROL LIBRARY */
/* HARDWARE WRAPPER IMPLEMENTATION */
#include "../LibSidServo/sidservo.h"
#include "mcc_mount_concepts.h"
#include "mcc_mount_coord.h"
namespace asibfm700
{
/* error codes enum definition */
enum class AsibFM700HardwareErrorCode : int {
// error codes from sidservo library
ERROR_OK = MCC_E_OK,
ERROR_FATAL = MCC_E_FATAL,
ERROR_BADFORMAT = MCC_E_BADFORMAT,
ERROR_ENCODERDEV = MCC_E_ENCODERDEV,
ERROR_MOUNTDEV = MCC_E_MOUNTDEV,
ERROR_FAILED = MCC_E_FAILED,
// my codes ...
};
// error category
struct AsibFM700HardwareErrorCategory : public std::error_category {
const char* name() const noexcept;
std::string message(int ec) const;
static const AsibFM700HardwareErrorCategory& get();
};
inline std::error_code make_error_code(AsibFM700HardwareErrorCode ec)
{
return std::error_code(static_cast<int>(ec), AsibFM700HardwareErrorCategory::get());
}
} // namespace asibfm700
namespace std
{
template <>
class is_error_code_enum<asibfm700::AsibFM700HardwareErrorCode> : public true_type
{
};
} // namespace std
namespace asibfm700
{
class AsibFM700Hardware final
{
public:
// definitions from concept
typedef std::error_code error_t;
typedef mcc::MccAngle coord_t;
typedef std::chrono::system_clock::time_point time_point_t; // UTC time
struct axes_pos_t {
time_point_t time_point;
coord_t x, y;
};
// c++ish wrapper to 'conf_t' struct
struct device_config_t {
std::string MountDevPath; // path to mount device
int MountDevSpeed; // serial speed
std::string EncoderDevPath; // path to encoder device
int EncoderDevSpeed; // serial speed
int SepEncoder; // ==1 if encoder works as separate serial device, ==2 if there's new version with two devices
std::string EncoderXDevPath; // paths to new controller devices
std::string EncoderYDevPath;
double MountReqInterval; // interval between subsequent mount requests (seconds)
double EncoderReqInterval; // interval between subsequent encoder requests (seconds)
};
struct hardware_config_t {
// the 'char*' fields from conf_t:
// wrap it to std::string
std::string MountDevPath;
std::string EncoderDevPath;
std::string EncoderXDevPath;
std::string EncoderYDevPath;
conf_t devConfig;
hardware_configuration_t hwConfig;
};
AsibFM700Hardware(const hardware_config_t& conf);
~AsibFM700Hardware();
AsibFM700Hardware(const AsibFM700Hardware&) = delete;
AsibFM700Hardware& operator=(const AsibFM700Hardware&) = delete;
AsibFM700Hardware(AsibFM700Hardware&&) = default;
AsibFM700Hardware& operator=(AsibFM700Hardware&&) = default;
std::string_view id() const;
error_t setPos(axes_pos_t);
error_t getPos(axes_pos_t&);
error_t stop();
error_t init();
private:
hardware_config_t _hardwareConfig;
// static void moveInst(AsibFM700Hardware* from, AsibFM700Hardware* to);
};
static_assert(mcc::traits::mcc_mount_hardware_c<AsibFM700Hardware>, "AsibFM700Hardware!!!");
} // namespace asibfm700

6
cxx/mcc_finite_state_machine.h
View File

@ -7,6 +7,7 @@
#include <concepts>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <string_view>
@ -318,7 +319,7 @@ protected:
std::vector<std::string_view> _eventID{};
std::recursive_mutex _transitionMutex{};
std::future<void> _currentStateThreadFuture;
static MccFiniteStateMachine& copyInstance(const MccFiniteStateMachine* from, MccFiniteStateMachine* to)
{
@ -400,7 +401,6 @@ public:
if constexpr (requires(curr_state_t inst) {
{ inst.exit(std::declval<EvT&>()) };
}) {
// std::get<curr_state_t>(*states).exit(event);
std::get<curr_state_t>(*states).exit(*p_event);
} else if constexpr (requires(curr_state_t inst) {
{ inst.exit() };
@ -412,7 +412,6 @@ public:
if constexpr (requires(EvT inst) {
{ inst.onTransit() };
}) {
// event.onTransit();
p_event->onTransit();
}
@ -423,7 +422,6 @@ public:
if constexpr (requires(to_state_t inst) {
{ inst.enter(std::declval<EvT&>()) };
}) {
// std::get<to_state_t>(*states).enter(event);
std::get<to_state_t>(*states).enter(*p_event);
} else if constexpr (requires(to_state_t inst) {
{ inst.enter() };

79
cxx/mcc_mount.h → cxx/mcc_fsm_mount.h
View File

@ -2,41 +2,44 @@
/* MOUNT CONTROL COMPONENTS LIBRARY */
/* AN GENERIC MOUNT CLASS IMPLEMENTATION */
// #include <atomic>
/* AN GENERIC MOUNT CLASS IMPLEMENTATION BASED ON FINITE STATE MACHINE */
#include <chrono>
// #include <concepts>
// #include <cstdint>
#include <functional>
#include <string_view>
#include "spdlog/sinks/null_sink.h"
#include "mcc_finite_state_machine.h"
#include "mcc_mount_concepts.h"
#include "mcc_mount_coord.h"
#include "mcc_spdlog.h"
#include "mcc_traits.h"
// #include "mount_astrom.h"
// #include "mcc_mount_pz.h"
#include "mcc_mount_concepts.h"
#include "mcc_finite_state_machine.h"
#include "mcc_mount_events_states.h"
namespace mcc
{
template <traits::mcc_mount_config_c MOUNT_CONFIG>
class MccMount : public fsm::MccFiniteStateMachine, public utils::MccSpdlogLogger
template <traits::mcc_mount_controls_c MOUNT_CONTROLS>
class MccMount : public fsm::MccFiniteStateMachine, public utils::MccSpdlogLogger, protected MOUNT_CONTROLS
{
// declare these classes as friends to allow them access protected members 'slewModel' and 'guidingModel'
friend class MccMountStateSlew<MccMount>;
friend class MccMountStateGuiding<MccMount>;
public:
typedef MOUNT_CONFIG mount_config_t;
typedef decltype(mount_config_t::telemetry) mount_telemetry_t;
typedef MOUNT_CONTROLS mount_controls_t;
typedef decltype(mount_controls_t::telemetry) mount_telemetry_t;
typedef typename mount_telemetry_t::mount_telemetry_data_t mount_telemetry_data_t;
typedef decltype(mount_config_t::astrometryEngine) astrom_engine_t;
typedef decltype(mount_config_t::PEC) pec_t;
typedef decltype(mount_config_t::hardware) hardware_t;
typedef decltype(mount_config_t::slewModel) slew_model_t;
typedef decltype(mount_config_t::guidingModel) guiding_model_t;
typedef decltype(mount_controls_t::astrometryEngine) astrom_engine_t;
typedef decltype(mount_controls_t::PEC) pec_t;
typedef decltype(mount_controls_t::hardware) hardware_t;
typedef decltype(mount_controls_t::slewModel) slew_model_t;
typedef decltype(mount_controls_t::guidingModel) guiding_model_t;
typedef typename slew_model_t::slew_params_t slew_params_t;
@ -44,16 +47,13 @@ public:
/* constructors and destructor */
template <fsm::traits::fsm_state_c InitStateT, traits::mcc_input_char_range LogMarkT = std::string_view>
MccMount(mount_config_t mount_config,
MccMount(mount_controls_t mount_controls,
InitStateT,
std::shared_ptr<spdlog::logger> logger = spdlog::null_logger_mt("NULL"),
const LogMarkT& logger_mark = "[MOUNT]")
: fsm::MccFiniteStateMachine(InitStateT{}),
utils::MccSpdlogLogger(logger),
_mountConfig(std::move(mount_config)),
_mountTelemetry(_mountConfig.telemetry),
_slewModel(_mountConfig.slewModel),
_guidingModel(_mountConfig.guidingModel)
mount_controls_t(std::move(mount_controls))
{
addMarkToPatternIdx(logger_mark);
@ -87,24 +87,11 @@ public:
void startGuiding() {}
// mount_config_t mountConfig() const
// {
// return _mountConfig;
// }
// returns "mount_config_t&" or "mount_config_t const&"
decltype(auto) mountConfig(this auto&& self)
{
auto& config_ref = std::forward<decltype(self)>(self)._mountConfig;
return config_ref;
}
mount_telemetry_data_t mountTelemetryData() const
{
mount_telemetry_data_t mnt_data;
auto err = _mountTelemetry.data(mnt_data);
auto err = this->telemetry.data();
if (err) {
// log ....
}
@ -149,11 +136,6 @@ public:
protected:
mount_config_t _mountConfig;
mount_telemetry_t& _mountTelemetry;
slew_model_t& _slewModel;
guiding_model_t& _guidingModel;
// a type to which the result of calling prohibited zone class methods 'timeTo' and 'timeFrom' will be converted
typedef std::chrono::duration<double> pz_duration_t; // seconds as floating-point number
@ -191,13 +173,14 @@ protected:
}; // end of MccMount class
namespace traits
{
// given mount class must be a descendant of MccMount
template <typename T>
concept mcc_mount_c = requires(T t) { []<typename... Ts>(MccMount<Ts...>*) {}(&t); };
// namespace traits
// {
} // namespace traits
// // given mount class must be a descendant of MccMount
// template <typename T>
// concept mcc_mount_c = requires(T t) { []<typename... Ts>(MccMount<Ts...>*) {}(&t); };
// } // namespace traits
} // namespace mcc

73
cxx/mcc_mount_concepts.h
View File

@ -4,10 +4,10 @@
#include <concepts>
#include "mcc_finite_state_machine.h"
#include "mcc_mount_coord.h"
#include "mcc_traits.h"
/* SOME LIBRARY-WIDE DECLARATIONS */
namespace mcc
@ -63,6 +63,22 @@ namespace mcc::traits
{
/* GENERIC LOGGER */
template <typename T>
concept mcc_logger_c = requires(T t, const T t_const) {
typename T::loglevel_t;
{ t.setLogLevel(std::declval<typename T::loglevel_t>()) };
{ t_const.getLogLevel() } -> std::same_as<typename T::loglevel_t>;
{ t.logMessage(std::declval<typename T::loglevel_t>(), std::declval<const std::string&>()) };
{ t.logError(std::declval<const std::string&>()) };
{ t.logDebug(std::declval<const std::string&>()) };
{ t.logWarn(std::declval<const std::string&>()) };
{ t.logInfo(std::declval<const std::string&>()) };
};
/* ASTROMETRY-RELATED COMPUTATION ENGINE */
template <typename T>
@ -171,6 +187,7 @@ concept mcc_mount_hardware_c = !std::copyable<T> && std::movable<T> && requires(
{ t.setPos(std::declval<typename T::axes_pos_t>()) } -> std::same_as<typename T::error_t>;
{ t.getPos(std::declval<typename T::axes_pos_t&>()) } -> std::same_as<typename T::error_t>;
{ t.stop() } -> std::same_as<typename T::error_t>;
{ t.init() } -> std::same_as<typename T::error_t>;
};
@ -235,12 +252,14 @@ concept mcc_mount_telemetry_c = requires(T t, const T t_const) {
// // a class that at least contains celestial (equatorial and horizontal) coordinates
// requires requires(typename T::mount_telemetry_data_t telemetry) {
// typename T::mount_telemetry_data_t::coord_t;
// requires std::same_as<decltype(telemetry.mntRA), typename T::mount_telemetry_data_t::coord_t>; // apparent
// RA requires std::same_as<decltype(telemetry.mntDEC), typename T::mount_telemetry_data_t::coord_t>; //
// apparent DEC requires std::same_as<decltype(telemetry.mntHA), typename T::mount_telemetry_data_t::coord_t>;
// // hour angle requires std::same_as<decltype(telemetry.mntAZ), typename T::mount_telemetry_data_t::coord_t>;
// // azimuth requires std::same_as<decltype(telemetry.mntALT), typename T::mount_telemetry_data_t::coord_t>; //
// altitude
// requires std::same_as<decltype(telemetry.mntRA), typename T::mount_telemetry_data_t::coord_t>; //
// apparent RA requires std::same_as<decltype(telemetry.mntDEC), typename
// T::mount_telemetry_data_t::coord_t>; // apparent DEC requires std::same_as<decltype(telemetry.mntHA),
// typename T::mount_telemetry_data_t::coord_t>;
// // hour angle requires std::same_as<decltype(telemetry.mntAZ), typename
// T::mount_telemetry_data_t::coord_t>;
// // azimuth requires std::same_as<decltype(telemetry.mntALT), typename
// T::mount_telemetry_data_t::coord_t>; // altitude
// };
requires mcc_mount_telemetry_data_c<typename T::mount_telemetry_data_t>;
@ -336,8 +355,8 @@ concept mcc_prohibited_zone_c =
// for given coordinates and time the method computes a time to reach the zone.
// implementation of the method must assume that input coordinates are apparent RA and DEC at given time point,
// while the time point is one from which computation should be performed (e.g. current time moment)
// implementation of the method must assume that input coordinates are apparent RA and DEC at given time
// point, while the time point is one from which computation should be performed (e.g. current time moment)
{
t.timeTo(std::declval<typename T::coord_t>(), std::declval<typename T::coord_t>(),
std::declval<typename T::time_point_t>())
@ -369,11 +388,11 @@ concept mcc_prohibited_zone_c =
/* MOUNT GENERIC CONFIGURATION */
/* MOUNT GENERIC CONTROLS */
template <typename T>
concept mcc_mount_config_c = std::movable<T> && requires(T t) {
concept mcc_mount_controls_c = std::move_constructible<T> && std::movable<T> && requires(T t) {
requires mcc_astrom_engine_c<decltype(t.astrometryEngine)>;
requires mcc_mount_pec_c<decltype(t.PEC)>;
requires mcc_mount_hardware_c<decltype(t.hardware)>;
@ -388,5 +407,37 @@ concept mcc_mount_config_c = std::movable<T> && requires(T t) {
};
/* GENERIC MOUNT CONCEPTS */
template <typename T>
concept mcc_mount_c = requires(T t) {
// the class must define typename 'mount_controls_t' and it must be its base class
requires mcc_mount_controls_c<typename T::mount_controls_t>;
requires std::derived_from<T, typename T::mount_controls_t>;
// deduced from 'mount_controls_t' typenames
requires mcc_mount_telemetry_c<typename T::mount_telemetry_t>;
requires std::same_as<typename T::mount_telemetry_data_t, typename T::mount_telemetry_t::mount_telemetry_data_t>;
requires mcc_astrom_engine_c<typename T::astrom_engine_t>;
requires mcc_mount_pec_c<typename T::pec_t>;
requires mcc_mount_hardware_c<typename T::hardware_t>;
requires mcc_slew_model_c<typename T::slew_model_t, typename T::mount_telemetry_t>;
requires mcc_guiding_model_c<typename T::guiding_model_t, typename T::mount_telemetry_t>;
requires std::same_as<typename T::slew_params_t, typename T::slew_model_t::slew_params_t>;
// public method
{ t.mountTelemetryData() } -> std::same_as<typename T::mount_telemetry_data_t>;
};
// generic with logging methods
template <typename T>
concept mcc_log_mount_c = mcc_mount_c<T> && mcc_logger_c<T>;
// a generic Finite State Machine mount with logging methods
template <typename T>
concept mcc_fsm_log_mount_c = std::derived_from<T, fsm::MccFiniteStateMachine> && mcc_log_mount_c<T>;
} // namespace mcc::traits

11
cxx/mcc_mount_coord.h
View File

@ -349,11 +349,18 @@ public:
}
// unary '-' and '+'
template <typename SelfT>
SelfT& operator-(this SelfT& self)
SelfT operator-(this SelfT& self)
{
self._angleInRads = -self._angleInRads;
SelfT res = -self._angleInRads;
return res;
}
template <typename SelfT>
SelfT operator+(this SelfT& self)
{
return self;
}
};

66
cxx/mcc_mount_events_states.h
View File

@ -3,12 +3,13 @@
/* MOUNT CONTROL COMPONENTS LIBRARY */
/*
* BASIC EVENTS AND MOUNT STATES DEFINITIONS (REFERENCE IMPLEMENTATION)
* BASIC EVENTS AND MOUNT STATES DEFINITIONS (POSSIBLE IMPLEMENTATION)
*
*/
#include <format>
#include "mcc_mount.h"
#include "mcc_mount_concepts.h"
namespace mcc
{
@ -19,7 +20,7 @@ namespace mcc
// a base class for mount state machine events
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
class MccMountEventBase
{
public:
@ -41,7 +42,7 @@ protected:
// transit to IDLE state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventIDLE : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -55,7 +56,7 @@ struct MccMountEventIDLE : public MccMountEventBase<MountT> {
// transit to initialization state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventInit : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -69,7 +70,7 @@ struct MccMountEventInit : public MccMountEventBase<MountT> {
// transit to error state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventError : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -91,7 +92,7 @@ protected:
// transit to slew state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventSlew : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -113,7 +114,7 @@ protected:
// transit to guiding state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventGuiding : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -127,7 +128,7 @@ struct MccMountEventGuiding : public MccMountEventBase<MountT> {
// transit to stop state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventStop : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -159,7 +160,7 @@ protected:
// transit to shutdown state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventShutdown : public MccMountEventBase<MountT> {
typedef MccMountEventBase<MountT> base_t;
@ -173,7 +174,7 @@ struct MccMountEventShutdown : public MccMountEventBase<MountT> {
/* MOUNT STATE MACHINE STATES */
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateBase {
// template <std::derived_from<MccMountEventBase<MountT>> EvT>
// void exit(this auto&& self, EvT& event)
@ -214,45 +215,46 @@ protected:
void exitLog(this auto&& self, EvT& event)
{
using self_t = std::remove_cvref_t<decltype(self)>;
event.mount().logDebug("Exit from '{}' state due to '{}' event ...", self_t::ID, EvT::ID);
event.mount().logDebug(std::format("Exit from '{}' state due to '{}' event ...", self_t::ID, EvT::ID));
}
template <std::derived_from<MccMountEventBase<MountT>> EvT>
void enterLog(this auto&& self, EvT& event)
{
using self_t = std::remove_cvref_t<decltype(self)>;
event.mount().logDebug("Enter to '{}' state due to '{}' event ...", self_t::ID, EvT::ID);
event.mount().logDebug(std::format("Enter to '{}' state due to '{}' event ...", self_t::ID, EvT::ID));
}
};
// just forward declarations
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateIDLE;
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateInit;
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateError;
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateSlew;
template <traits::mcc_mount_c MountT, fsm::traits::fsm_event_c TrEvT = MccMountEventStop<MountT>>
template <traits::mcc_fsm_log_mount_c MountT, fsm::traits::fsm_event_c TrEvT = MccMountEventStop<MountT>>
struct MccMountStateStop;
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateGuiding;
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateShutdown;
// stop state
template <traits::mcc_mount_c MountT, fsm::traits::fsm_event_c TrEvT>
template <traits::mcc_fsm_log_mount_c MountT, fsm::traits::fsm_event_c TrEvT>
struct MccMountStateStop : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-STOP-STATE";
@ -287,7 +289,7 @@ struct MccMountStateStop : MccMountStateBase<MountT> {
mount.stopMount();
if constexpr (std::same_as<EvT, MccMountEventStop<MountT>>) {
mount.logInfo("Stop reason: {}", event.reason());
mount.logInfo(std::format("Stop reason: {}", event.reason()));
// normal behavior (transit to IDLE state after stopping)
mount.template dispatchEvent<MccMountEventIDLE<MountT>>({mount});
@ -300,7 +302,7 @@ struct MccMountStateStop : MccMountStateBase<MountT> {
// initialization state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateInit : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-INIT-STATE";
@ -329,7 +331,7 @@ struct MccMountStateInit : MccMountStateBase<MountT> {
// error state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateError : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-ERROR-STATE";
@ -348,9 +350,9 @@ struct MccMountStateError : MccMountStateBase<MountT> {
{
this->exitLog(event);
event.mount().logWarn(
event.mount().logWarn(std::format(
"The mount is in the error state!!! One must correct it before transit to any states! Event type is '{}'",
EvT::ID);
EvT::ID));
}
void exit(MccMountEventIDLE<MountT>& event)
@ -372,8 +374,8 @@ struct MccMountStateError : MccMountStateBase<MountT> {
auto err = event.eventData();
event.mount().logError("The mount is in the error state: code = {}, category = {}, message = '{}'", err.value(),
err.category().name(), err.message());
event.mount().logError(std::format("The mount is in the error state: code = {}, category = {}, message = '{}'",
err.value(), err.category().name(), err.message()));
}
// template <std::derived_from<MccMountEventBase<MountT>> EvT>
// void enter(EvT& event)
@ -391,7 +393,7 @@ struct MccMountStateError : MccMountStateBase<MountT> {
// IDLE state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateIDLE : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-IDLE-STATE";
@ -419,7 +421,7 @@ struct MccMountStateIDLE : MccMountStateBase<MountT> {
// shutdown state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateShutdown : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-SHUTDOWN-STATE";
@ -445,7 +447,7 @@ struct MccMountStateShutdown : MccMountStateBase<MountT> {
// slew state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateSlew : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-SLEW-STATE";
@ -478,7 +480,7 @@ struct MccMountStateSlew : MccMountStateBase<MountT> {
// guiding state
template <traits::mcc_mount_c MountT>
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateGuiding : MccMountStateBase<MountT> {
static constexpr std::string_view ID = "MCC-MOUNT-GUIDING-STATE";

1
cxx/mcc_mount_pz.h
View File

@ -53,6 +53,7 @@ public:
// : "ALTLIMIT-UNKNOWN"),
: _altLimit(alt_limit), _latitude(lat), _abs_lat(std::abs(_latitude)), _lat_lim(pi2 - _abs_lat)
{
_lat_lim = pi2 - _abs_lat;
_altLimit.normalize<MccAngle::NORM_KIND_90_90>();
}

2
cxx/mcc_mount_telemetry.h
View File

@ -3,7 +3,7 @@
/* MOUNT CONTROL COMPONENTS LIBRARY */
/* MOUNT TELEMETRY OBJECT POSSIBLE IMPLEMENTATION */
/* MOUNT TELEMETRY OBJECT POSSIBLE GENERIC IMPLEMENTATION */
#include <mutex>

5
cxx/mcc_traits.h
View File

@ -164,8 +164,9 @@ concept mcc_nonconst_lvref = std::is_lvalue_reference_v<T> && !std::is_const_v<s
template <typename T>
concept mcc_error_c = std::convertible_to<T, bool>;
// concept mcc_error_c = std::convertible_to<T, bool> && mcc_formattable<T>;
concept mcc_error_c = std::convertible_to<T, bool> || requires(const T t) {
{ t.operator bool() };
};
namespace details
{

2
cxx/mount_astrom.h
View File

@ -16,8 +16,8 @@
#endif
#include "mcc_traits.h"
#include "mcc_utils.h"
#include "mount_astrom_default.h"
#include "utils.h"
namespace erfa
{