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-10-28 01:11:34 +03:00
parent bdfc5dbc1c
commit 85dfa2e9a5
5 changed files with 337 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

392
asibfm700/asibfm700_configfile.h
View File

@@ -524,222 +524,334 @@ protected:
return ec;
};
void updateAll()
public:
/* the most usefull config fields */
template <mcc::traits::mcc_time_duration_c DT>
DT hardwarePollingPeriod() const
{
hardwarePollingPeriod = getValue<decltype(hardwarePollingPeriod)>("hardwarePollingPeriod").value_or({});
return std::chrono::duration_cast<DT>(
getValue<std::chrono::milliseconds>("hardwarePollingPeriod").value_or(std::chrono::milliseconds{}));
};
// CCTE
std::chrono::milliseconds hardwarePollingPeriod() const
{
return hardwarePollingPeriod<std::chrono::milliseconds>();
};
siteLatitude = getValue<mcc::MccAngle>("siteLatitude").value_or({});
siteLongitude = getValue<mcc::MccAngle>("siteLongitude").value_or({});
siteElevation = getValue<double>("siteElevation").value_or({});
refractWavelength = getValue<double>("refractWavelength").value_or({});
template <mcc::mcc_angle_c T>
T siteLatitude() const
{
return static_cast<double>(getValue<mcc::MccAngle>("siteLatitude").value_or(mcc::MccAngle{}));
};
leapSecondFilename = getValue<std::string>("leapSecondFilename").value_or({});
bulletinAFilename = getValue<std::string>("bulletinAFilename").value_or({});
mcc::MccAngle siteLatitude() const
{
return siteLatitude<mcc::MccAngle>();
};
// prohibited zones
template <mcc::mcc_angle_c T>
T siteLongitude() const
{
return static_cast<double>(getValue<mcc::MccAngle>("siteLongitude").value_or(mcc::MccAngle{}));
};
pzMinAltitude = getValue<mcc::MccAngle>("pzMinAltitude").value_or({});
pzLimitSwitchHAMin = getValue<mcc::MccAngle>("pzLimitSwitchHAMin").value_or({});
pzLimitSwitchHAMax = getValue<mcc::MccAngle>("pzLimitSwitchHAMax").value_or({});
mcc::MccAngle siteLongitude() const
{
return siteLongitude<mcc::MccAngle>();
};
template <typename T>
T siteElevation() const
requires std::is_arithmetic_v<T>
{
return getValue<double>("siteElevation").value_or(0.0);
}
double siteElevation() const
{
return getValue<double>("siteElevation").value_or(0.0);
};
template <typename T>
T refractWavelength() const
requires std::is_arithmetic_v<T>
{
return getValue<double>("refractWavelength").value_or(0.0);
}
double refractWavelength() const
{
return getValue<double>("refractWavelength").value_or(0.0);
};
template <mcc::traits::mcc_view_or_output_char_range R>
R leapSecondFilename() const
{
R r;
if constexpr (std::ranges::view<R>) {
std::string const& val = getValue<std::string>("leapSecondFilename").value_or("");
r = R{val.begin(), val.end()};
} else {
std::string val = getValue<std::string>("leapSecondFilename").value_or("");
std::ranges::copy(val, std::back_inserter(r));
}
return r;
}
std::string_view leapSecondFilename() const
{
return leapSecondFilename<std::string_view>();
};
template <mcc::traits::mcc_view_or_output_char_range R>
R bulletinAFilename() const
{
R r;
if constexpr (std::ranges::view<R>) {
std::string const& val = getValue<std::string>("bulletinAFilename").value_or("");
r = R{val.begin(), val.end()};
} else {
std::string val = getValue<std::string>("bulletinAFilename").value_or("");
std::ranges::copy(val, std::back_inserter(r));
}
return r;
}
std::string_view bulletinAFilename() const
{
return bulletinAFilename<std::string_view>();
};
// hardware config
template <mcc::mcc_angle_c T>
T pzMinAltitude() const
{
return static_cast<double>(getValue<mcc::MccAngle>("pzMinAltitude").value_or(mcc::MccAngle{}));
};
servoControllerConfig.hwConfig = {};
mcc::MccAngle pzMinAltitude() const
{
return pzMinAltitude<mcc::MccAngle>();
};
servoControllerConfig.MountDevPath = getValue<std::string>("MountDevPath").value_or({});
servoControllerConfig.EncoderDevPath = getValue<std::string>("EncoderDevPath").value_or({});
servoControllerConfig.EncoderXDevPath = getValue<std::string>("EncoderXDevPath").value_or({});
servoControllerConfig.EncoderYDevPath = getValue<std::string>("EncoderYDevPath").value_or({});
template <mcc::mcc_angle_c T>
T pzLimitSwitchHAMin() const
{
return static_cast<double>(getValue<mcc::MccAngle>("pzLimitSwitchHAMin").value_or(mcc::MccAngle{}));
};
servoControllerConfig.devConfig.MountDevPath = servoControllerConfig.MountDevPath.data();
servoControllerConfig.devConfig.EncoderDevPath = servoControllerConfig.EncoderDevPath.data();
servoControllerConfig.devConfig.EncoderXDevPath = servoControllerConfig.EncoderXDevPath.data();
servoControllerConfig.devConfig.EncoderYDevPath = servoControllerConfig.EncoderYDevPath.data();
mcc::MccAngle pzLimitSwitchHAMin() const
{
return pzLimitSwitchHAMin<mcc::MccAngle>();
};
servoControllerConfig.devConfig.RunModel = getValue<int>("RunModel").value_or({});
servoControllerConfig.devConfig.MountDevSpeed = getValue<int>("MountDevSpeed").value_or({});
servoControllerConfig.devConfig.EncoderDevSpeed = getValue<int>("EncoderDevSpeed").value_or({});
servoControllerConfig.devConfig.SepEncoder = getValue<int>("SepEncoder").value_or({});
template <mcc::mcc_angle_c T>
T pzLimitSwitchHAMax() const
{
return static_cast<double>(getValue<mcc::MccAngle>("pzLimitSwitchHAMax").value_or(mcc::MccAngle{}));
};
mcc::MccAngle pzLimitSwitchHAMax() const
{
return pzLimitSwitchHAMax<mcc::MccAngle>();
};
AsibFM700ServoController::hardware_config_t servoControllerConfig() const
{
AsibFM700ServoController::hardware_config_t hw_cfg;
hw_cfg.hwConfig = {};
hw_cfg.MountDevPath = getValue<std::string>("MountDevPath").value_or({});
hw_cfg.EncoderDevPath = getValue<std::string>("EncoderDevPath").value_or({});
hw_cfg.EncoderXDevPath = getValue<std::string>("EncoderXDevPath").value_or({});
hw_cfg.EncoderYDevPath = getValue<std::string>("EncoderYDevPath").value_or({});
hw_cfg.devConfig.MountDevPath = hw_cfg.MountDevPath.data();
hw_cfg.devConfig.EncoderDevPath = hw_cfg.EncoderDevPath.data();
hw_cfg.devConfig.EncoderXDevPath = hw_cfg.EncoderXDevPath.data();
hw_cfg.devConfig.EncoderYDevPath = hw_cfg.EncoderYDevPath.data();
hw_cfg.devConfig.RunModel = getValue<int>("RunModel").value_or({});
hw_cfg.devConfig.MountDevSpeed = getValue<int>("MountDevSpeed").value_or({});
hw_cfg.devConfig.EncoderDevSpeed = getValue<int>("EncoderDevSpeed").value_or({});
hw_cfg.devConfig.SepEncoder = getValue<int>("SepEncoder").value_or({});
std::chrono::duration<double> secs; // seconds as floating-point
secs = getValue<std::chrono::milliseconds>("MountReqInterval").value_or({});
servoControllerConfig.devConfig.MountReqInterval = secs.count();
hw_cfg.devConfig.MountReqInterval = secs.count();
secs = getValue<std::chrono::milliseconds>("EncoderReqInterval").value_or({});
servoControllerConfig.devConfig.EncoderReqInterval = secs.count();
hw_cfg.devConfig.EncoderReqInterval = secs.count();
secs = getValue<std::chrono::milliseconds>("EncoderSpeedInterval").value_or({});
servoControllerConfig.devConfig.EncoderSpeedInterval = secs.count();
hw_cfg.devConfig.EncoderSpeedInterval = secs.count();
std::vector<double> pid = getValue<std::vector<double>>("XPIDC").value_or({});
if (pid.size() > 2) {
servoControllerConfig.devConfig.XPIDC.P = pid[0];
servoControllerConfig.devConfig.XPIDC.I = pid[1];
servoControllerConfig.devConfig.XPIDC.D = pid[2];
hw_cfg.devConfig.XPIDC.P = pid[0];
hw_cfg.devConfig.XPIDC.I = pid[1];
hw_cfg.devConfig.XPIDC.D = pid[2];
}
pid = getValue<std::vector<double>>("XPIDV").value_or({});
if (pid.size() > 2) {
servoControllerConfig.devConfig.XPIDV.P = pid[0];
servoControllerConfig.devConfig.XPIDV.I = pid[1];
servoControllerConfig.devConfig.XPIDV.D = pid[2];
hw_cfg.devConfig.XPIDV.P = pid[0];
hw_cfg.devConfig.XPIDV.I = pid[1];
hw_cfg.devConfig.XPIDV.D = pid[2];
}
pid = getValue<std::vector<double>>("YPIDC").value_or({});
if (pid.size() > 2) {
servoControllerConfig.devConfig.YPIDC.P = pid[0];
servoControllerConfig.devConfig.YPIDC.I = pid[1];
servoControllerConfig.devConfig.YPIDC.D = pid[2];
hw_cfg.devConfig.YPIDC.P = pid[0];
hw_cfg.devConfig.YPIDC.I = pid[1];
hw_cfg.devConfig.YPIDC.D = pid[2];
}
pid = getValue<std::vector<double>>("YPIDV").value_or({});
if (pid.size() > 2) {
servoControllerConfig.devConfig.YPIDV.P = pid[0];
servoControllerConfig.devConfig.YPIDV.I = pid[1];
servoControllerConfig.devConfig.YPIDV.D = pid[2];
hw_cfg.devConfig.YPIDV.P = pid[0];
hw_cfg.devConfig.YPIDV.I = pid[1];
hw_cfg.devConfig.YPIDV.D = pid[2];
}
return hw_cfg;
}
// slew and track parameters
mcc::MccSimpleMovingModelParams movingModelParams() const
{
static constexpr double arcsecs2rad = std::numbers::pi / 180.0 / 3600.0; // arcseconds to radians
movingModelParams.telemetryTimeout =
getValue<decltype(movingModelParams.telemetryTimeout)>("telemetryTimeout").value_or({});
mcc::MccSimpleMovingModelParams pars;
movingModelParams.minTimeToPZone =
getValue<decltype(movingModelParams.minTimeToPZone)>("minTimeToPZone").value_or({});
pars.telemetryTimeout =
getValue<decltype(pars.telemetryTimeout)>("telemetryTimeout").value_or(pars.telemetryTimeout);
movingModelParams.updatingPZoneInterval =
getValue<decltype(movingModelParams.updatingPZoneInterval)>("updatingPZoneInterval").value_or({});
pars.minTimeToPZone = getValue<decltype(pars.minTimeToPZone)>("minTimeToPZone").value_or(pars.minTimeToPZone);
movingModelParams.slewToleranceRadius =
getValue<decltype(movingModelParams.slewToleranceRadius)>("slewToleranceRadius").value_or({}) * arcsecs2rad;
pars.updatingPZoneInterval = getValue<decltype(pars.updatingPZoneInterval)>("updatingPZoneInterval")
.value_or(pars.updatingPZoneInterval);
movingModelParams.adjustCoordDiff =
getValue<decltype(movingModelParams.adjustCoordDiff)>("adjustCoordDiff").value_or({}) * arcsecs2rad;
movingModelParams.adjustCycleInterval =
getValue<decltype(movingModelParams.adjustCycleInterval)>("adjustCycleInterval").value_or({});
movingModelParams.slewTimeout = getValue<decltype(movingModelParams.slewTimeout)>("slewTimeout").value_or({});
movingModelParams.timeShiftToTargetPoint =
getValue<decltype(movingModelParams.timeShiftToTargetPoint)>("timeShiftToTargetPoint").value_or({});
movingModelParams.trackingCycleInterval =
getValue<decltype(movingModelParams.trackingCycleInterval)>("trackingCycleInterval").value_or({});
movingModelParams.trackingMaxCoordDiff =
getValue<decltype(movingModelParams.trackingMaxCoordDiff)>("trackingMaxCoordDiff").value_or({}) *
pars.slewToleranceRadius =
getValue<decltype(pars.slewToleranceRadius)>("slewToleranceRadius").value_or(pars.slewToleranceRadius) *
arcsecs2rad;
// PCM data
pars.adjustCoordDiff =
getValue<decltype(pars.adjustCoordDiff)>("adjustCoordDiff").value_or(pars.adjustCoordDiff) * arcsecs2rad;
pcmData.type = getValue<decltype(pcmData.type)>("pcmType").value_or({});
pars.adjustCycleInterval =
getValue<decltype(pars.adjustCycleInterval)>("adjustCycleInterval").value_or(pars.adjustCycleInterval);
pcmData.siteLatitude = getValue<mcc::MccAngle>("siteLatitude").value_or({});
pars.slewTimeout = getValue<decltype(pars.slewTimeout)>("slewTimeout").value_or(pars.slewTimeout);
pid = getValue<std::vector<double>>("pcmGeomCoeffs").value_or({});
if (pid.size() >= 9) { // must be 9 coefficients
pcmData.geomCoefficients = {.zeroPointX = pid[0],
.zeroPointY = pid[1],
.collimationErr = pid[2],
.nonperpendErr = pid[3],
.misalignErr1 = pid[4],
.misalignErr2 = pid[5],
.tubeFlexure = pid[6],
.forkFlexure = pid[7],
.DECaxisFlexure = pid[8]};
pars.timeShiftToTargetPoint = getValue<decltype(pars.timeShiftToTargetPoint)>("timeShiftToTargetPoint")
.value_or(pars.timeShiftToTargetPoint);
pars.trackingCycleInterval = getValue<decltype(pars.trackingCycleInterval)>("trackingCycleInterval")
.value_or(pars.trackingCycleInterval);
pars.trackingMaxCoordDiff =
getValue<decltype(pars.trackingMaxCoordDiff)>("trackingMaxCoordDiff").value_or(pars.trackingMaxCoordDiff) *
arcsecs2rad;
return pars;
}
Asibfm700PCM::pcm_data_t pcmData() const
{
Asibfm700PCM::pcm_data_t pcm_data;
std::vector<double> empty_vec;
pcm_data.type = getValue<decltype(pcm_data.type)>("pcmType").value_or(pcm_data.type);
pcm_data.siteLatitude = getValue<mcc::MccAngle>("siteLatitude").value_or(pcm_data.siteLatitude);
std::vector<double> vec = getValue<std::vector<double>>("pcmGeomCoeffs").value_or(empty_vec);
if (vec.size() >= 9) { // must be 9 coefficients
pcm_data.geomCoefficients = {.zeroPointX = vec[0],
.zeroPointY = vec[1],
.collimationErr = vec[2],
.nonperpendErr = vec[3],
.misalignErr1 = vec[4],
.misalignErr2 = vec[5],
.tubeFlexure = vec[6],
.forkFlexure = vec[7],
.DECaxisFlexure = vec[8]};
}
std::vector<size_t> dd = getValue<decltype(dd)>("pcmBsplineDegree").value_or({});
std::vector<size_t> dd = getValue<decltype(dd)>("pcmBsplineDegree").value_or(dd);
if (dd.size() >= 2) {
pcmData.bspline.bsplDegreeX = dd[0] > 0 ? dd[0] : 3;
pcmData.bspline.bsplDegreeY = dd[1] > 0 ? dd[1] : 3;
pcm_data.bspline.bsplDegreeX = dd[0] > 0 ? dd[0] : 3;
pcm_data.bspline.bsplDegreeY = dd[1] > 0 ? dd[1] : 3;
}
pid = getValue<std::vector<double>>("pcmBsplineXknots").value_or({});
vec = getValue<std::vector<double>>("pcmBsplineXknots").value_or(empty_vec);
// pid must contains interior and border (single point for each border) knots so minimal length must be 2
if (pid.size() >= 2) {
if (vec.size() >= 2) {
// generate full knots array (with border knots)
size_t Nknots = pid.size() + pcmData.bspline.bsplDegreeX * 2 - 2;
pcmData.bspline.knotsX.resize(Nknots);
size_t Nknots = vec.size() + pcm_data.bspline.bsplDegreeX * 2 - 2;
pcm_data.bspline.knotsX.resize(Nknots);
for (size_t i = 0; i <= pcmData.bspline.bsplDegreeX; ++i) { // border knots
pcmData.bspline.knotsX[i] = pid[0];
pcmData.bspline.knotsX[Nknots - i - 1] = pid.back();
for (size_t i = 0; i <= pcm_data.bspline.bsplDegreeX; ++i) { // border knots
pcm_data.bspline.knotsX[i] = vec[0];
pcm_data.bspline.knotsX[Nknots - i - 1] = vec.back();
}
for (size_t i = 0; i < (pid.size() - 2); ++i) { // interior knots
pcmData.bspline.knotsX[i + pcmData.bspline.bsplDegreeX] = pid[1 + i];
for (size_t i = 0; i < (vec.size() - 2); ++i) { // interior knots
pcm_data.bspline.knotsX[i + pcm_data.bspline.bsplDegreeX] = vec[1 + i];
}
}
pid = getValue<std::vector<double>>("pcmBsplineYknots").value_or({});
vec = getValue<std::vector<double>>("pcmBsplineYknots").value_or(empty_vec);
// pid must contains interior and border (single point for each border) knots so minimal length must be 2
if (pid.size() >= 2) {
if (vec.size() >= 2) {
// generate full knots array (with border knots)
size_t Nknots = pid.size() + pcmData.bspline.bsplDegreeY * 2 - 2;
pcmData.bspline.knotsY.resize(Nknots);
size_t Nknots = vec.size() + pcm_data.bspline.bsplDegreeY * 2 - 2;
pcm_data.bspline.knotsY.resize(Nknots);
for (size_t i = 0; i <= pcmData.bspline.bsplDegreeY; ++i) { // border knots
pcmData.bspline.knotsY[i] = pid[0];
pcmData.bspline.knotsY[Nknots - i - 1] = pid.back();
for (size_t i = 0; i <= pcm_data.bspline.bsplDegreeY; ++i) { // border knots
pcm_data.bspline.knotsY[i] = vec[0];
pcm_data.bspline.knotsY[Nknots - i - 1] = vec.back();
}
for (size_t i = 0; i < (pid.size() - 2); ++i) { // interior knots
pcmData.bspline.knotsY[i + pcmData.bspline.bsplDegreeY] = pid[1 + i];
for (size_t i = 0; i < (vec.size() - 2); ++i) { // interior knots
pcm_data.bspline.knotsY[i + pcm_data.bspline.bsplDegreeY] = vec[1 + i];
}
}
// minimal allowed number of B-spline coefficients
size_t Ncoeffs = pcmData.type == mcc::MccDefaultPCMType::PCM_TYPE_GEOMETRY
size_t Ncoeffs = pcm_data.type == mcc::MccDefaultPCMType::PCM_TYPE_GEOMETRY
? 0
: (pcmData.bspline.knotsX.size() - pcmData.bspline.bsplDegreeX - 1) *
(pcmData.bspline.knotsY.size() - pcmData.bspline.bsplDegreeY - 1);
: (pcm_data.bspline.knotsX.size() - pcm_data.bspline.bsplDegreeX - 1) *
(pcm_data.bspline.knotsY.size() - pcm_data.bspline.bsplDegreeY - 1);
pid = getValue<std::vector<double>>("pcmBsplineXcoeffs").value_or({});
vec = getValue<std::vector<double>>("pcmBsplineXcoeffs").value_or(empty_vec);
if (pid.size() >= Ncoeffs) {
pcmData.bspline.coeffsX.resize(Ncoeffs);
if (vec.size() >= Ncoeffs) {
pcm_data.bspline.coeffsX.resize(Ncoeffs);
for (size_t i = 0; i < Ncoeffs; ++i) {
pcmData.bspline.coeffsX[i] = pid[i];
pcm_data.bspline.coeffsX[i] = vec[i];
}
}
pid = getValue<std::vector<double>>("pcmBsplineYcoeffs").value_or({});
vec = getValue<std::vector<double>>("pcmBsplineYcoeffs").value_or(empty_vec);
if (pid.size() >= Ncoeffs) {
pcmData.bspline.coeffsY.resize(Ncoeffs);
if (vec.size() >= Ncoeffs) {
pcm_data.bspline.coeffsY.resize(Ncoeffs);
for (size_t i = 0; i < Ncoeffs; ++i) {
pcmData.bspline.coeffsY[i] = pid[i];
pcm_data.bspline.coeffsY[i] = vec[i];
}
}
return pcm_data;
}
public:
std::chrono::milliseconds hardwarePollingPeriod{};
mcc::MccAngle siteLatitude{};
mcc::MccAngle siteLongitude{};
double siteElevation{};
double refractWavelength{};
std::string leapSecondFilename{};
std::string bulletinAFilename{};
mcc::MccAngle pzMinAltitude{};
mcc::MccAngle pzLimitSwitchHAMin{};
mcc::MccAngle pzLimitSwitchHAMax{};
AsibFM700ServoController::hardware_config_t servoControllerConfig{};
mcc::MccSimpleMovingModelParams movingModelParams{};
Asibfm700PCM::pcm_data_t pcmData{};
Asibfm700MountConfig() : base_t(Asibfm700MountConfigDefaults) {}
@@ -763,9 +875,6 @@ public:
fst.close();
ec = base_t::fromCharRange(buffer, deserializer);
if (!ec) {
updateAll();
}
} catch (std::ios_base::failure const& ex) {
ec = ex.code();
} catch (std::length_error const& ex) {
@@ -779,17 +888,6 @@ public:
return ec;
}
template <typename T>
std::error_code setValue(std::string_view key, const T& value)
{
auto ec = base_t::setValue(key, value);
if (!ec) {
updateAll();
}
return ec;
}
};