130 lines
3.9 KiB
C++
130 lines
3.9 KiB
C++
#include <iostream>
|
|
|
|
#include <random>
|
|
|
|
#include "mcc_pcm.h"
|
|
#include "mcc_serializer.h"
|
|
#include "mcc_telemetry.h"
|
|
|
|
static std::random_device rd;
|
|
static std::mt19937 gen(rd());
|
|
static std::uniform_int_distribution<long> tm_distrib(100, 700);
|
|
static std::uniform_real_distribution<double> x_distrib(1000, 7000);
|
|
static std::uniform_real_distribution<double> y_distrib(1000, 7000);
|
|
static std::uniform_real_distribution<double> xs_distrib(100, 700);
|
|
static std::uniform_real_distribution<double> ys_distrib(100, 700);
|
|
|
|
struct hw_t {
|
|
static constexpr std::string_view hardwareName{"HW-TEST"};
|
|
|
|
typedef int error_t;
|
|
|
|
enum class hardware_movement_state_t : int {
|
|
HW_MOVE_ERROR = -1,
|
|
HW_MOVE_STOPPED = 0,
|
|
HW_MOVE_STOPPING,
|
|
HW_MOVE_SLEWING,
|
|
HW_MOVE_ADJUSTING,
|
|
HW_MOVE_TRACKING,
|
|
HW_MOVE_GUIDING
|
|
};
|
|
|
|
struct hardware_state_t {
|
|
mcc::impl::MccGenXY XY{1.0, 1.0}, speedXY{2.0, 2.0};
|
|
hardware_movement_state_t movementState{hardware_movement_state_t::HW_MOVE_STOPPED};
|
|
};
|
|
|
|
|
|
error_t hardwareSetState(hardware_state_t const&)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
error_t hardwareGetState(hardware_state_t* state)
|
|
{
|
|
auto ms = std::chrono::milliseconds(tm_distrib(gen));
|
|
std::cout << "\tgetState running " << ms << " ...";
|
|
|
|
std::this_thread::sleep_for(ms);
|
|
|
|
std::cout << "\tdone!\n";
|
|
|
|
*state = hardware_state_t{.XY{x_distrib(gen), y_distrib(gen)}, .speedXY{xs_distrib(gen), ys_distrib(gen)}};
|
|
|
|
return 0;
|
|
}
|
|
|
|
error_t hardwareInit()
|
|
{
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct std::formatter<hw_t::hardware_movement_state_t, char> : std::formatter<std::string_view> {
|
|
auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
|
|
{
|
|
return formatter<std::string_view>::format(e == hw_t::hardware_movement_state_t::HW_MOVE_ERROR ? "ERROR"
|
|
: e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPED ? "STOPPED"
|
|
: e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPING ? "STOPPING"
|
|
: e == hw_t::hardware_movement_state_t::HW_MOVE_SLEWING ? "SLEWING"
|
|
: e == hw_t::hardware_movement_state_t::HW_MOVE_TRACKING ? "TRACKING"
|
|
: "UNKNOWN",
|
|
ctx);
|
|
}
|
|
};
|
|
|
|
|
|
// template <>
|
|
// struct std::formatter<hw_t::hardware_movement_state_t, char>
|
|
// : std::formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>, char> {
|
|
// auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
|
|
// {
|
|
// return formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>>::format(
|
|
// std::underlying_type_t<hw_t::hardware_movement_state_t>(e), ctx);
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
static_assert(mcc::mcc_hardware_c<hw_t>, "!!!!!");
|
|
|
|
|
|
typedef mcc::impl::MccTelemetry<hw_t> t_t;
|
|
|
|
int main()
|
|
{
|
|
hw_t hw;
|
|
mcc::impl::MccMountDefaultForkPec pcm;
|
|
|
|
t_t tlm(&hw, &pcm);
|
|
typename t_t::telemetry_data_t tdata;
|
|
|
|
for (int i = 0; i < 20; ++i) {
|
|
std::cout << std::format("{}-th run\n", i + 1);
|
|
|
|
auto err = tlm.telemetryData(&tdata);
|
|
std::cout << "\tgot hw: XY = {" << tdata.hwState.XY.x() << ", " << tdata.hwState.XY.y() << "}; speedXY = {"
|
|
<< tdata.hwState.speedXY.x() << ", " << tdata.hwState.speedXY.y() << "}\n";
|
|
if (err) {
|
|
std::cout << "ERR: " << err.message() << "\n";
|
|
}
|
|
}
|
|
|
|
|
|
mcc::impl::MccSerializer<typename t_t::telemetry_data_t> ser;
|
|
|
|
std::string str;
|
|
|
|
auto err = ser(str, tdata);
|
|
if (err) {
|
|
std::cout << "ERR: " << err.message() << "\n";
|
|
} else {
|
|
std::cout << "\n\n";
|
|
std::cout << str << "\n";
|
|
}
|
|
|
|
return 0;
|
|
}
|