502 lines
20 KiB
C++
502 lines
20 KiB
C++
#pragma once
|
|
|
|
#include <filesystem>
|
|
|
|
|
|
#include <mcc/mcc_keyvalue.h>
|
|
#include <mcc/mcc_pcm.h>
|
|
#include "mcc/mcc_pzone.h"
|
|
|
|
namespace asibfm700
|
|
{
|
|
|
|
static constexpr double SAORAS_LATITUDE = 43.646711_degs;
|
|
static constexpr double SAORAS_LONGITUDE = 41.440732_degs;
|
|
|
|
|
|
template <mcc::impl::mcc_record_value_c T>
|
|
struct config_record_t : mcc::impl::mcc_simple_kv_record_t<T> {
|
|
std::vector<std::string_view> head_comment;
|
|
std::string_view inline_comment;
|
|
};
|
|
|
|
|
|
template <mcc::impl::mcc_record_value_c T>
|
|
static config_record_t<T> make_config_record(
|
|
std::string_view key,
|
|
T value,
|
|
std::vector<std::string_view> hcomm = {},
|
|
std::string_view icomm = {},
|
|
mcc::impl::mcc_serialization_params_t const& spars = mcc::impl::mcc_serialization_params_t{})
|
|
{
|
|
return config_record_t<T>{key, value, value, spars, hcomm, icomm};
|
|
}
|
|
|
|
|
|
static auto Asibfm700MountConfigurationDefaults = std::make_tuple(
|
|
|
|
/* geographic coordinates of the observation site */
|
|
|
|
make_config_record("siteLatitude", mcc::impl::MccAngle(SAORAS_LATITUDE), {" site latitude in degrees"}),
|
|
make_config_record("siteLongitude", mcc::impl::MccAngle(SAORAS_LONGITUDE), {" site longitude in degrees"}),
|
|
make_config_record("siteElevation", 2070.0, {" site elevation in meters"}),
|
|
|
|
/* celestial coordinate transformation */
|
|
|
|
make_config_record("refractWavelength", 0.55, {" wavelength at which refraction is calculated (in mkm)"}),
|
|
make_config_record("leapSecondFilename", std::string(), {" an empty filename means default precompiled string"}),
|
|
make_config_record("bulletinAFilename", std::string(), {" an empty filename means default precompiled string"}),
|
|
|
|
/* pointing correction model */
|
|
|
|
// PCM type
|
|
make_config_record(
|
|
"pcmType",
|
|
mcc::impl::MccDefaultPCMType::PCM_TYPE_GEOMETRY,
|
|
{" PCM type:", " a case-sensetive string:", " GEOMETRY - 'classic' geometry-based correction coefficients",
|
|
" GEOMETRY-BSPLINE - previous one and additional 2D B-spline corrections",
|
|
" BSPLINE - pure 2D B-spline corrections"}),
|
|
|
|
// PCM geometrical coefficients
|
|
make_config_record("pcmGeomCoeffs",
|
|
std::vector<double>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
|
{" PCM geometrical coefficients"}),
|
|
|
|
// make_config_record("pcmBsplineDegree", std::vector<size_t>{3, 3}, {"PCM B-spline degrees"}),
|
|
|
|
// PCM B-spline knots along X-axis (HA-angle or azimuth). By default from 0 to 2*PI radians
|
|
// NOTE: The first and last values are interpretated as border knots!!!
|
|
// Thus the array length must be equal to or greater than 2!
|
|
make_config_record(
|
|
"pcmBsplineXknots",
|
|
mcc::impl::mccGenerateBsplineKnots(0.0, 360.0_degs, 8),
|
|
{" PCM B-spline knots along X-axis (HA-angle or azimuth).", " By default from 0 to 2*PI radians.",
|
|
" NOTE: The first and last values are interpretated as border knots!!!",
|
|
" Thus the array length must be equal to or greater than 2!"}),
|
|
|
|
// PCM B-spline knots along Y-axis (declination or zenithal distance).
|
|
// By default from -SAORAS-latitude to PI/2 radians
|
|
// NOTE: The first and last values are interpretated as border knots!!!
|
|
// Thus the array length must be equal to or greater than 2!
|
|
make_config_record("pcmBsplineYknots",
|
|
mcc::impl::mccGenerateBsplineKnots(-SAORAS_LATITUDE, 90.0_degs, 8),
|
|
{" PCM B-spline knots along Y-axis (declination or zenithal distance).",
|
|
" By default from -SAORAS-latitude to PI/2 radians.",
|
|
" NOTE: The first and last values are interpretated as border knots!!!",
|
|
" Thus the array length must be equal to or greater than 2!"}),
|
|
|
|
// PCM B-spline coeffs for along X-axis (HA-angle or azimuth)
|
|
make_config_record("pcmBsplineXcoeffs",
|
|
std::vector<double>{},
|
|
{" PCM B-spline coeffs for along X-axis (HA-angle)"}),
|
|
|
|
// PCM B-spline coeffs for along Y-axis (declination or zenithal distance)
|
|
make_config_record("pcmBsplineYcoeffs",
|
|
std::vector<double>{},
|
|
{" PCM B-spline coeffs for along Y-axis (declination angle)"}),
|
|
|
|
// inverse PCM B-spline coeffs for along X-axis (HA-angle or azimuth)
|
|
make_config_record("pcmInverseBsplineXcoeffs",
|
|
std::vector<double>{},
|
|
{" Inverse PCM B-spline coeffs for along X-axis (HA-angle)"}),
|
|
|
|
// inverse PCM B-spline coeffs for along Y-axis (declination or zenithal distance)
|
|
make_config_record("pcmInverseBsplineYcoeffs",
|
|
std::vector<double>{},
|
|
{" Inverse PCM B-spline coeffs for along Y-axis (declination angle)"}),
|
|
|
|
|
|
/* prohibited zones */
|
|
|
|
// minimal altitude (default: 10.0 degrees and SAO RAS latitude)
|
|
make_config_record("altLimPZ",
|
|
mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT>{10.0_degs, SAORAS_LATITUDE},
|
|
{" minimal altitude prohibited zone"}),
|
|
|
|
// HA-axis limit switch
|
|
make_config_record(
|
|
"axisLimitSwitchHA",
|
|
mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS>{-170.0_degs, 170.0_degs, nullptr},
|
|
{" HA-axis limit switch stop angles"}),
|
|
|
|
// DEC-axis limit switch
|
|
make_config_record(
|
|
"axisLimitSwitchDEC",
|
|
mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_DEC_OBS>{-90.0_degs, 90.0_degs, nullptr},
|
|
{" DEC-axis limit switch stop angles"}),
|
|
|
|
|
|
/* hardware-related */
|
|
|
|
// hardware mode: 1 - model mode, otherwise real mode
|
|
make_config_record("RunModel", 0, {" hardware mode: 1 - model mode, otherwise real mode"}),
|
|
|
|
// mount serial device paths
|
|
make_config_record("MountDevPath", std::string("/dev/ttyUSB0"), {" mount serial device paths"}),
|
|
|
|
// mount serial device speed
|
|
make_config_record("MountDevSpeed", 19200, {" mount serial device speed"}),
|
|
|
|
// motor encoders serial device path
|
|
make_config_record("EncoderDevPath", std::string(""), {" motor encoders serial device path"}),
|
|
|
|
// X-axis encoder serial device path
|
|
make_config_record("EncoderXDevPath", std::string("/dev/encoder_X0"), {" X-axis encoder serial device path"}),
|
|
|
|
// Y-axis encoder serial device path
|
|
make_config_record("EncoderYDevPath", std::string("/dev/encoder_Y0"), {" Y-axis encoder serial device path"}),
|
|
|
|
// encoders serial device speed
|
|
make_config_record("EncoderDevSpeed", 153000, {" encoders serial device speed"}),
|
|
|
|
// ==1 if encoder works as separate serial device, ==2 if there's new version with two devices
|
|
make_config_record(
|
|
"SepEncoder",
|
|
2,
|
|
{" ==1 if encoder works as separate serial device, ==2 if there's new version with two devices"}),
|
|
|
|
|
|
// mount polling interval in millisecs
|
|
make_config_record("MountReqInterval", std::chrono::milliseconds(100), {" mount polling interval in millisecs"}),
|
|
|
|
// encoders polling interval in millisecs
|
|
make_config_record("EncoderReqInterval", std::chrono::milliseconds(1), {" encoders polling interval in millisecs"}),
|
|
|
|
// mount axes rate calculation interval in millisecs
|
|
make_config_record("EncoderSpeedInterval",
|
|
std::chrono::milliseconds(50),
|
|
{" mount axes rate calculation interval in millisecs"}),
|
|
|
|
make_config_record("PIDMaxDt",
|
|
std::chrono::milliseconds(1000),
|
|
{" maximal PID refresh time interval in millisecs",
|
|
" NOTE: if PID data will be refreshed with interval longer than this value (e.g. user polls "
|
|
" encoder data too rarely)",
|
|
" then the PID 'expired' data will be cleared and new computing loop is started"}),
|
|
|
|
make_config_record("PIDRefreshDt", std::chrono::milliseconds(100), {" PID refresh interval"}),
|
|
|
|
make_config_record("PIDCycleDt",
|
|
std::chrono::milliseconds(5000),
|
|
{" PID I cycle time (analog of 'RC' for PID on opamps)"}),
|
|
|
|
|
|
|
|
// // X-axis coordinate PID P,I,D-params
|
|
// make_config_record("XPIDC", std::vector<double>{0.5, 0.1, 0.2}, {" X-axis coordinate PID P,I,D-params"}),
|
|
|
|
// X-axis rate PID P,I,D-params
|
|
make_config_record("XPIDV", std::vector<double>{0.09, 0.0, 0.05}, {" X-axis rate PID P,I,D-params"}),
|
|
|
|
// // Y-axis coordinate PID P, I, D-params
|
|
// make_config_record("YPIDC", std::vector<double>{0.5, 0.1, 0.2}, {" Y-axis coordinate PID P, I, D-params"}),
|
|
|
|
// Y-axis rate PID P,I,D-params
|
|
make_config_record("YPIDV", std::vector<double>{0.09, 0.0, 0.05}, {" Y-axis rate PID P,I,D-params"}),
|
|
|
|
|
|
// maximal moving rate (degrees per second) along HA-axis (Y-axis of Sidereal servo microcontroller)
|
|
make_config_record(
|
|
"hwMaxRateHA",
|
|
mcc::impl::MccAngle(8.0_degs),
|
|
{" maximal moving rate (degrees per second) along HA-axis (Y-axis of Sidereal servo microcontroller)"}),
|
|
|
|
// maximal moving rate (degrees per second) along DEC-axis (X-axis of Sidereal servo microcontroller)
|
|
make_config_record(
|
|
"hwMaxRateDEC",
|
|
mcc::impl::MccAngle(10.0_degs),
|
|
{" maximal moving rate (degrees per second) along DEC-axis (X-axis of Sidereal servo microcontroller)"}),
|
|
|
|
make_config_record("MaxPointingErr",
|
|
mcc::impl::MccAngle(8.0_degs),
|
|
{" slewing-to-pointing mode angular limit in degrees"}),
|
|
|
|
make_config_record("MaxFinePointingErr",
|
|
mcc::impl::MccAngle(1.5_degs),
|
|
{" pointing-to-guiding mode angular limit in degrees"}),
|
|
|
|
make_config_record("MaxGuidingErr",
|
|
mcc::impl::MccAngle(0.5_arcsecs),
|
|
{" guiding 'good'-flag error cirle radius (mount-to-target distance) in degrees"}),
|
|
|
|
make_config_record("XEncZero", (int64_t)0, {" X-axis encoder zero-point in ticks"}),
|
|
|
|
make_config_record("YEncZero", (int64_t)0, {" Y-axis encoder zero-point in ticks"}),
|
|
|
|
|
|
/* movement related common parameters */
|
|
|
|
// timeout for telemetry updating in milliseconds
|
|
make_config_record("telemetryTimeout",
|
|
std::chrono::milliseconds(3000),
|
|
{" timeout for telemetry updating in milliseconds"}),
|
|
|
|
// mount stopping process timeout in seconds
|
|
make_config_record("stopTimeout", std::chrono::seconds(30), {" mount stopping process timeout in seconds"}),
|
|
|
|
// minimal allowed time in seconds to prohibited zone
|
|
make_config_record("minTimeToPZone",
|
|
std::chrono::seconds(10),
|
|
{" minimal allowed time in seconds to prohibited zone"}),
|
|
|
|
/* slewing and tracking parameters */
|
|
|
|
// telemetry request interval (in millisecs) in slewing mode
|
|
make_config_record("slewingTelemetryInterval",
|
|
std::chrono::milliseconds(100),
|
|
{" telemetry request interval (in millisecs) in slewing mode"}),
|
|
|
|
|
|
// slew process timeout in seconds
|
|
make_config_record("slewTimeout", std::chrono::seconds(3600), {" slew process timeout in seconds"}),
|
|
|
|
// slewing trajectory filename (used for debugging purposes)
|
|
// if it is an empty - just skip saving
|
|
make_config_record("slewingPathFilename",
|
|
std::string(),
|
|
{" slewing trajectory filename", "if it is an empty - just skip saving"}),
|
|
|
|
|
|
make_config_record("trackingTelemetryInterval",
|
|
std::chrono::milliseconds(100),
|
|
{" telemetry request interval (in millisecs) in tracking mode"}),
|
|
|
|
|
|
// maximal valid target-to-mount distance for tracking process (arcsecs)
|
|
// if current distance is greater than assume current mount coordinate as target point
|
|
make_config_record("trackingMaxCoordDiff",
|
|
20.0,
|
|
{" maximal valid target-to-mount distance for tracking process (arcsecs)",
|
|
" if current distance is greater than assume current mount coordinate as target point"}),
|
|
|
|
make_config_record("trackingPathFilename",
|
|
std::string(),
|
|
{" tracking trajectory filename", "if it is an empty - just skip saving"})
|
|
|
|
|
|
);
|
|
|
|
class Asibfm700MountConfiguration : public mcc::impl::MccKeyValueHolder<decltype(Asibfm700MountConfigurationDefaults)>
|
|
{
|
|
using base_t = mcc::impl::MccKeyValueHolder<decltype(Asibfm700MountConfigurationDefaults)>;
|
|
|
|
public:
|
|
Asibfm700MountConfiguration() : base_t(Asibfm700MountConfigurationDefaults)
|
|
{
|
|
// fill comments
|
|
|
|
auto get_comm = [this]<size_t I>() {
|
|
auto& rec = std::get<I>(Asibfm700MountConfigurationDefaults);
|
|
for (auto const& comm : rec.head_comment) {
|
|
if (comm.size()) {
|
|
_headComment[_hashes[I]].emplace_back(std::string{comm.begin(), comm.end()});
|
|
} else {
|
|
_headComment[_hashes[I]].emplace_back(std::nullopt);
|
|
}
|
|
}
|
|
_inlineComment[_hashes[I]] = rec.inline_comment;
|
|
};
|
|
|
|
[&]<size_t... Is>(std::index_sequence<Is...>) {
|
|
(get_comm.template operator()<Is>(), ...);
|
|
}(std::make_index_sequence<Asibfm700MountConfiguration::NUMBER_OF_RECORDS>{});
|
|
}
|
|
|
|
~Asibfm700MountConfiguration() = default;
|
|
|
|
std::error_code load(const std::filesystem::path& path)
|
|
{
|
|
std::string buffer;
|
|
|
|
std::error_code ec;
|
|
auto sz = std::filesystem::file_size(path, ec);
|
|
|
|
if (!ec && sz) {
|
|
std::ifstream fst(path);
|
|
|
|
try {
|
|
buffer.resize(sz);
|
|
|
|
fst.read(buffer.data(), sz);
|
|
|
|
fst.close();
|
|
|
|
// remove possible header (see "save" method)
|
|
size_t nskip = headerLines;
|
|
if (!std::regex_match(buffer, headerRx)) {
|
|
nskip = 0;
|
|
}
|
|
ec = base_t::fromCharRange(buffer, nskip);
|
|
if (!ec) {
|
|
// remove possible spaces in filenames
|
|
|
|
std::string val = getValue<std::string>("leapSecondFilename").value_or("");
|
|
auto fname = mcc::utils::trimSpaces(val);
|
|
setValue("leapSecondFilename", fname);
|
|
|
|
|
|
val = getValue<std::string>("bulletinAFilename").value_or("");
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("bulletinAFilename", fname);
|
|
|
|
val = getValue<std::string>("MountDevPath").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("MountDevPath", fname);
|
|
|
|
val = getValue<std::string>("EncoderDevPath").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("EncoderDevPath", fname);
|
|
|
|
val = getValue<std::string>("EncoderXDevPath").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("EncoderXDevPath", fname);
|
|
|
|
val = getValue<std::string>("EncoderYDevPath").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("EncoderYDevPath", fname);
|
|
|
|
val = getValue<std::string>("slewingPathFilename").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("slewingPathFilename", fname);
|
|
|
|
val = getValue<std::string>("trackingPathFilename").value_or(std::string{});
|
|
fname = mcc::utils::trimSpaces(val);
|
|
setValue("trackingPathFilename", fname);
|
|
}
|
|
} catch (std::ios_base::failure const& ex) {
|
|
ec = ex.code();
|
|
} catch (std::length_error const& ex) {
|
|
ec = std::make_error_code(std::errc::no_buffer_space);
|
|
} catch (std::bad_alloc const& ex) {
|
|
ec = std::make_error_code(std::errc::not_enough_memory);
|
|
} catch (...) {
|
|
ec = std::make_error_code(std::errc::operation_canceled);
|
|
}
|
|
|
|
_lastConfigPath = path;
|
|
}
|
|
|
|
return ec;
|
|
}
|
|
|
|
std::error_code reloadCurrentConfig()
|
|
{
|
|
return load(_lastConfigPath);
|
|
}
|
|
|
|
|
|
std::error_code save(const std::filesystem::path& path)
|
|
{
|
|
std::error_code ec;
|
|
std::string buff;
|
|
|
|
ec = toCharRange(buff);
|
|
if (ec) {
|
|
return ec;
|
|
}
|
|
|
|
std::ofstream fst(path, std::ios_base::trunc);
|
|
if (!fst.is_open()) {
|
|
ec = std::make_error_code(std::errc::io_error);
|
|
} else {
|
|
try {
|
|
fst << generateHeader();
|
|
fst << buff;
|
|
} catch (std::ios_base::failure const& ex) {
|
|
ec = ex.code();
|
|
} catch (...) {
|
|
ec = std::make_error_code(std::errc::operation_canceled);
|
|
}
|
|
}
|
|
|
|
return ec;
|
|
}
|
|
|
|
std::error_code save()
|
|
{
|
|
return save(_lastConfigPath);
|
|
}
|
|
|
|
std::error_code dumpDefaultsToFile(const std::filesystem::path& path)
|
|
{
|
|
std::error_code ec{};
|
|
std::string output_buffer;
|
|
|
|
auto write_rec = [&output_buffer, &ec, this]<size_t I = 0>(this auto& self) {
|
|
if constexpr (I < NUMBER_OF_RECORDS) {
|
|
// add an empty string within records
|
|
std::format_to(std::back_inserter(output_buffer), "{}", DEFAULT_RECORD_DELIMITER);
|
|
|
|
ec = formatRecord<I>(output_buffer, DEFAULT_RECORD_DELIMITER, true);
|
|
if (ec) {
|
|
return;
|
|
}
|
|
|
|
|
|
self.template operator()<I + 1>();
|
|
}
|
|
};
|
|
|
|
write_rec();
|
|
if (!ec) {
|
|
std::ofstream fst(path, std::ios_base::trunc);
|
|
if (!fst.is_open()) {
|
|
ec = std::make_error_code(std::errc::io_error);
|
|
} else {
|
|
try {
|
|
fst << generateHeader();
|
|
fst << output_buffer;
|
|
} catch (std::ios_base::failure const& ex) {
|
|
ec = ex.code();
|
|
} catch (...) {
|
|
ec = std::make_error_code(std::errc::operation_canceled);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ec;
|
|
}
|
|
|
|
|
|
std::filesystem::path configFilename() const
|
|
{
|
|
return _lastConfigPath;
|
|
}
|
|
|
|
private:
|
|
std::filesystem::path _lastConfigPath{};
|
|
|
|
static constexpr size_t headerLines = 5; // number of lines in the header
|
|
|
|
static std::string generateHeader()
|
|
{
|
|
std::string s{
|
|
"#\n"
|
|
"# ASTROSIB FM-700 MOUNT CONFIGURATION\n"
|
|
"#\n"};
|
|
|
|
std::format_to(
|
|
std::back_inserter(s), "# (created at {:%FT%T} UTC)\n#\n",
|
|
std::chrono::round<std::chrono::duration<int64_t, std::ratio<1, 10>>>(std::chrono::system_clock::now()));
|
|
|
|
// auto time_stamp =
|
|
// std::chrono::round<std::chrono::duration<int64_t, std::ratio<1, 10>>>(std::chrono::system_clock::now());
|
|
// std::string s = std::format(
|
|
// "{0:}{1:}{0:} ASTROSIB FM-700 MOUNT CONFIGURATION{1:}{0:}{1:}{0:} (created at {2:%FT%T}
|
|
// UTC){1:}{0:}{1:}", COMMENT_SEQ, rec_delim, time_stamp);
|
|
|
|
return s;
|
|
}
|
|
|
|
// regex for buffer started with standard header
|
|
inline static const std::regex headerRx{
|
|
"^[ \\n]*"
|
|
"# *\\n"
|
|
"# *ASTROSIB FM-700 MOUNT CONFIGURATION *\\n"
|
|
"# *\\n"
|
|
"# *\\(created at 20[0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9] UTC\\) *\\n"
|
|
"# *\\n"
|
|
"[\\s\\S]*"};
|
|
};
|
|
|
|
} // namespace asibfm700
|