mavlink / MAVSDK / 13298134957

Telemetry::Telemetry(System& system) : PluginBase(), _impl{std::make_unique<TelemetryImpl>(system)}

{}

Telemetry::PositionHandle Telemetry::subscribe_position(const PositionCallback& callback)

    return _impl->subscribe_position(callback);

void Telemetry::unsubscribe_position(PositionHandle handle)

    _impl->unsubscribe_position(handle);

}

Telemetry::Position Telemetry::position() const

    return _impl->position();

Telemetry::HomeHandle Telemetry::subscribe_home(const HomeCallback& callback)

    return _impl->subscribe_home(callback);

void Telemetry::unsubscribe_home(HomeHandle handle)

    _impl->unsubscribe_home(handle);

}

Telemetry::Position Telemetry::home() const

    return _impl->home();

Telemetry::InAirHandle Telemetry::subscribe_in_air(const InAirCallback& callback)

    return _impl->subscribe_in_air(callback);

void Telemetry::unsubscribe_in_air(InAirHandle handle)

    _impl->unsubscribe_in_air(handle);

}

bool Telemetry::in_air() const

    return _impl->in_air();

Telemetry::LandedStateHandle Telemetry::subscribe_landed_state(const LandedStateCallback& callback)

    return _impl->subscribe_landed_state(callback);

void Telemetry::unsubscribe_landed_state(LandedStateHandle handle)

    _impl->unsubscribe_landed_state(handle);

}

Telemetry::LandedState Telemetry::landed_state() const

    return _impl->landed_state();

Telemetry::ArmedHandle Telemetry::subscribe_armed(const ArmedCallback& callback)

    return _impl->subscribe_armed(callback);

void Telemetry::unsubscribe_armed(ArmedHandle handle)

    _impl->unsubscribe_armed(handle);

}

bool Telemetry::armed() const

    return _impl->armed();

Telemetry::VtolStateHandle Telemetry::subscribe_vtol_state(const VtolStateCallback& callback)

    return _impl->subscribe_vtol_state(callback);

void Telemetry::unsubscribe_vtol_state(VtolStateHandle handle)

    _impl->unsubscribe_vtol_state(handle);

}

Telemetry::VtolState Telemetry::vtol_state() const

    return _impl->vtol_state();

Telemetry::subscribe_attitude_quaternion(const AttitudeQuaternionCallback& callback)

    return _impl->subscribe_attitude_quaternion(callback);

void Telemetry::unsubscribe_attitude_quaternion(AttitudeQuaternionHandle handle)

    _impl->unsubscribe_attitude_quaternion(handle);

}

Telemetry::Quaternion Telemetry::attitude_quaternion() const

    return _impl->attitude_quaternion();

Telemetry::subscribe_attitude_euler(const AttitudeEulerCallback& callback)

    return _impl->subscribe_attitude_euler(callback);

void Telemetry::unsubscribe_attitude_euler(AttitudeEulerHandle handle)

    _impl->unsubscribe_attitude_euler(handle);

}

Telemetry::EulerAngle Telemetry::attitude_euler() const

    return _impl->attitude_euler();

Telemetry::AttitudeAngularVelocityBodyHandle Telemetry::subscribe_attitude_angular_velocity_body(

    return _impl->subscribe_attitude_angular_velocity_body(callback);

void Telemetry::unsubscribe_attitude_angular_velocity_body(AttitudeAngularVelocityBodyHandle handle)

    _impl->unsubscribe_attitude_angular_velocity_body(handle);

}

Telemetry::AngularVelocityBody Telemetry::attitude_angular_velocity_body() const

    return _impl->attitude_angular_velocity_body();

Telemetry::VelocityNedHandle Telemetry::subscribe_velocity_ned(const VelocityNedCallback& callback)

    return _impl->subscribe_velocity_ned(callback);

void Telemetry::unsubscribe_velocity_ned(VelocityNedHandle handle)

    _impl->unsubscribe_velocity_ned(handle);

}

Telemetry::VelocityNed Telemetry::velocity_ned() const

    return _impl->velocity_ned();

Telemetry::GpsInfoHandle Telemetry::subscribe_gps_info(const GpsInfoCallback& callback)

    return _impl->subscribe_gps_info(callback);

void Telemetry::unsubscribe_gps_info(GpsInfoHandle handle)

    _impl->unsubscribe_gps_info(handle);

}

Telemetry::GpsInfo Telemetry::gps_info() const

    return _impl->gps_info();

Telemetry::RawGpsHandle Telemetry::subscribe_raw_gps(const RawGpsCallback& callback)

    return _impl->subscribe_raw_gps(callback);

void Telemetry::unsubscribe_raw_gps(RawGpsHandle handle)

    _impl->unsubscribe_raw_gps(handle);

}

Telemetry::RawGps Telemetry::raw_gps() const

    return _impl->raw_gps();

Telemetry::BatteryHandle Telemetry::subscribe_battery(const BatteryCallback& callback)

    return _impl->subscribe_battery(callback);

void Telemetry::unsubscribe_battery(BatteryHandle handle)

    _impl->unsubscribe_battery(handle);

}

Telemetry::Battery Telemetry::battery() const

    return _impl->battery();

Telemetry::FlightModeHandle Telemetry::subscribe_flight_mode(const FlightModeCallback& callback)

    return _impl->subscribe_flight_mode(callback);

void Telemetry::unsubscribe_flight_mode(FlightModeHandle handle)

    _impl->unsubscribe_flight_mode(handle);

}

Telemetry::FlightMode Telemetry::flight_mode() const

    return _impl->flight_mode();

Telemetry::HealthHandle Telemetry::subscribe_health(const HealthCallback& callback)

    return _impl->subscribe_health(callback);

void Telemetry::unsubscribe_health(HealthHandle handle)

    _impl->unsubscribe_health(handle);

}

Telemetry::Health Telemetry::health() const

    return _impl->health();

Telemetry::RcStatusHandle Telemetry::subscribe_rc_status(const RcStatusCallback& callback)

    return _impl->subscribe_rc_status(callback);

void Telemetry::unsubscribe_rc_status(RcStatusHandle handle)

    _impl->unsubscribe_rc_status(handle);

}

Telemetry::RcStatus Telemetry::rc_status() const

    return _impl->rc_status();

Telemetry::StatusText Telemetry::status_text() const

    return _impl->status_text();

Telemetry::subscribe_actuator_control_target(const ActuatorControlTargetCallback& callback)

    return _impl->subscribe_actuator_control_target(callback);

void Telemetry::unsubscribe_actuator_control_target(ActuatorControlTargetHandle handle)

    _impl->unsubscribe_actuator_control_target(handle);

}

Telemetry::ActuatorControlTarget Telemetry::actuator_control_target() const

    return _impl->actuator_control_target();

Telemetry::subscribe_actuator_output_status(const ActuatorOutputStatusCallback& callback)

    return _impl->subscribe_actuator_output_status(callback);

void Telemetry::unsubscribe_actuator_output_status(ActuatorOutputStatusHandle handle)

    _impl->unsubscribe_actuator_output_status(handle);

}

Telemetry::ActuatorOutputStatus Telemetry::actuator_output_status() const

    return _impl->actuator_output_status();

Telemetry::OdometryHandle Telemetry::subscribe_odometry(const OdometryCallback& callback)

    return _impl->subscribe_odometry(callback);

void Telemetry::unsubscribe_odometry(OdometryHandle handle)

    _impl->unsubscribe_odometry(handle);

}

Telemetry::Odometry Telemetry::odometry() const

    return _impl->odometry();

Telemetry::subscribe_position_velocity_ned(const PositionVelocityNedCallback& callback)

    return _impl->subscribe_position_velocity_ned(callback);

void Telemetry::unsubscribe_position_velocity_ned(PositionVelocityNedHandle handle)

    _impl->unsubscribe_position_velocity_ned(handle);

}

Telemetry::PositionVelocityNed Telemetry::position_velocity_ned() const

    return _impl->position_velocity_ned();

Telemetry::GroundTruthHandle Telemetry::subscribe_ground_truth(const GroundTruthCallback& callback)

    return _impl->subscribe_ground_truth(callback);

void Telemetry::unsubscribe_ground_truth(GroundTruthHandle handle)

    _impl->unsubscribe_ground_truth(handle);

}

Telemetry::GroundTruth Telemetry::ground_truth() const

    return _impl->ground_truth();

Telemetry::subscribe_fixedwing_metrics(const FixedwingMetricsCallback& callback)

    return _impl->subscribe_fixedwing_metrics(callback);

void Telemetry::unsubscribe_fixedwing_metrics(FixedwingMetricsHandle handle)

    _impl->unsubscribe_fixedwing_metrics(handle);

}

Telemetry::FixedwingMetrics Telemetry::fixedwing_metrics() const

    return _impl->fixedwing_metrics();

Telemetry::ImuHandle Telemetry::subscribe_imu(const ImuCallback& callback)

    return _impl->subscribe_imu(callback);

void Telemetry::unsubscribe_imu(ImuHandle handle)

    _impl->unsubscribe_imu(handle);

}

Telemetry::Imu Telemetry::imu() const

    return _impl->imu();

Telemetry::ScaledImuHandle Telemetry::subscribe_scaled_imu(const ScaledImuCallback& callback)

    return _impl->subscribe_scaled_imu(callback);

void Telemetry::unsubscribe_scaled_imu(ScaledImuHandle handle)

    _impl->unsubscribe_scaled_imu(handle);

}

Telemetry::Imu Telemetry::scaled_imu() const

    return _impl->scaled_imu();

Telemetry::RawImuHandle Telemetry::subscribe_raw_imu(const RawImuCallback& callback)

    return _impl->subscribe_raw_imu(callback);

void Telemetry::unsubscribe_raw_imu(RawImuHandle handle)

    _impl->unsubscribe_raw_imu(handle);

}

Telemetry::Imu Telemetry::raw_imu() const

    return _impl->raw_imu();

Telemetry::HealthAllOkHandle Telemetry::subscribe_health_all_ok(const HealthAllOkCallback& callback)

    return _impl->subscribe_health_all_ok(callback);

void Telemetry::unsubscribe_health_all_ok(HealthAllOkHandle handle)

    _impl->unsubscribe_health_all_ok(handle);

}

bool Telemetry::health_all_ok() const

    return _impl->health_all_ok();

Telemetry::subscribe_unix_epoch_time(const UnixEpochTimeCallback& callback)

    return _impl->subscribe_unix_epoch_time(callback);

void Telemetry::unsubscribe_unix_epoch_time(UnixEpochTimeHandle handle)

    _impl->unsubscribe_unix_epoch_time(handle);

}

uint64_t Telemetry::unix_epoch_time() const

    return _impl->unix_epoch_time();

Telemetry::subscribe_distance_sensor(const DistanceSensorCallback& callback)

    return _impl->subscribe_distance_sensor(callback);

void Telemetry::unsubscribe_distance_sensor(DistanceSensorHandle handle)

    _impl->unsubscribe_distance_sensor(handle);

}

Telemetry::DistanceSensor Telemetry::distance_sensor() const

    return _impl->distance_sensor();

Telemetry::subscribe_scaled_pressure(const ScaledPressureCallback& callback)

    return _impl->subscribe_scaled_pressure(callback);

void Telemetry::unsubscribe_scaled_pressure(ScaledPressureHandle handle)

    _impl->unsubscribe_scaled_pressure(handle);

}

Telemetry::ScaledPressure Telemetry::scaled_pressure() const

    return _impl->scaled_pressure();

Telemetry::HeadingHandle Telemetry::subscribe_heading(const HeadingCallback& callback)

    return _impl->subscribe_heading(callback);

void Telemetry::unsubscribe_heading(HeadingHandle handle)

    _impl->unsubscribe_heading(handle);

}

Telemetry::Heading Telemetry::heading() const

    return _impl->heading();

Telemetry::AltitudeHandle Telemetry::subscribe_altitude(const AltitudeCallback& callback)

    return _impl->subscribe_altitude(callback);

void Telemetry::unsubscribe_altitude(AltitudeHandle handle)

    _impl->unsubscribe_altitude(handle);

}

Telemetry::Altitude Telemetry::altitude() const

    return _impl->altitude();

void Telemetry::set_rate_position_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_position_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_position(double rate_hz) const

    return _impl->set_rate_position(rate_hz);

void Telemetry::set_rate_home_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_home_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_home(double rate_hz) const

    return _impl->set_rate_home(rate_hz);

void Telemetry::set_rate_in_air_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_in_air_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_in_air(double rate_hz) const

    return _impl->set_rate_in_air(rate_hz);

void Telemetry::set_rate_landed_state_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_landed_state_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_landed_state(double rate_hz) const

    return _impl->set_rate_landed_state(rate_hz);

void Telemetry::set_rate_vtol_state_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_vtol_state_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_vtol_state(double rate_hz) const

    return _impl->set_rate_vtol_state(rate_hz);

void Telemetry::set_rate_attitude_quaternion_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_attitude_quaternion_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_attitude_quaternion(double rate_hz) const

    return _impl->set_rate_attitude_quaternion(rate_hz);

void Telemetry::set_rate_attitude_euler_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_attitude_euler_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_attitude_euler(double rate_hz) const

    return _impl->set_rate_attitude_euler(rate_hz);

void Telemetry::set_rate_velocity_ned_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_velocity_ned_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_velocity_ned(double rate_hz) const

    return _impl->set_rate_velocity_ned(rate_hz);

void Telemetry::set_rate_gps_info_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_gps_info_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_gps_info(double rate_hz) const

    return _impl->set_rate_gps_info(rate_hz);

void Telemetry::set_rate_battery_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_battery_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_battery(double rate_hz) const

    return _impl->set_rate_battery(rate_hz);

void Telemetry::set_rate_rc_status_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_rc_status_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_rc_status(double rate_hz) const

    return _impl->set_rate_rc_status(rate_hz);

void Telemetry::set_rate_actuator_control_target_async(

    _impl->set_rate_actuator_control_target_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_actuator_control_target(double rate_hz) const

    return _impl->set_rate_actuator_control_target(rate_hz);

void Telemetry::set_rate_actuator_output_status_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_actuator_output_status_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_actuator_output_status(double rate_hz) const

    return _impl->set_rate_actuator_output_status(rate_hz);

void Telemetry::set_rate_odometry_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_odometry_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_odometry(double rate_hz) const

    return _impl->set_rate_odometry(rate_hz);

void Telemetry::set_rate_position_velocity_ned_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_position_velocity_ned_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_position_velocity_ned(double rate_hz) const

    return _impl->set_rate_position_velocity_ned(rate_hz);

void Telemetry::set_rate_ground_truth_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_ground_truth_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_ground_truth(double rate_hz) const

    return _impl->set_rate_ground_truth(rate_hz);

void Telemetry::set_rate_fixedwing_metrics_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_fixedwing_metrics_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_fixedwing_metrics(double rate_hz) const

    return _impl->set_rate_fixedwing_metrics(rate_hz);

void Telemetry::set_rate_imu_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_imu_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_imu(double rate_hz) const

    return _impl->set_rate_imu(rate_hz);

void Telemetry::set_rate_scaled_imu_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_scaled_imu_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_scaled_imu(double rate_hz) const

    return _impl->set_rate_scaled_imu(rate_hz);

void Telemetry::set_rate_raw_imu_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_raw_imu_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_raw_imu(double rate_hz) const

    return _impl->set_rate_raw_imu(rate_hz);

void Telemetry::set_rate_unix_epoch_time_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_unix_epoch_time_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_unix_epoch_time(double rate_hz) const

    return _impl->set_rate_unix_epoch_time(rate_hz);

void Telemetry::set_rate_distance_sensor_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_distance_sensor_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_distance_sensor(double rate_hz) const

    return _impl->set_rate_distance_sensor(rate_hz);

void Telemetry::set_rate_altitude_async(double rate_hz, const ResultCallback callback)

    _impl->set_rate_altitude_async(rate_hz, callback);

}

Telemetry::Result Telemetry::set_rate_altitude(double rate_hz) const

    return _impl->set_rate_altitude(rate_hz);

void Telemetry::get_gps_global_origin_async(const GetGpsGlobalOriginCallback callback)

    _impl->get_gps_global_origin_async(callback);

}

std::pair<Telemetry::Result, Telemetry::GpsGlobalOrigin> Telemetry::get_gps_global_origin() const

    return _impl->get_gps_global_origin();

bool operator==(const Telemetry::Position& lhs, const Telemetry::Position& rhs)

    return ((std::isnan(rhs.latitude_deg) && std::isnan(lhs.latitude_deg)) ||

            rhs.latitude_deg == lhs.latitude_deg) &&

           ((std::isnan(rhs.longitude_deg) && std::isnan(lhs.longitude_deg)) ||

            rhs.longitude_deg == lhs.longitude_deg) &&

           ((std::isnan(rhs.absolute_altitude_m) && std::isnan(lhs.absolute_altitude_m)) ||

            rhs.absolute_altitude_m == lhs.absolute_altitude_m) &&

           ((std::isnan(rhs.relative_altitude_m) && std::isnan(lhs.relative_altitude_m)) ||

            rhs.relative_altitude_m == lhs.relative_altitude_m);

std::ostream& operator<<(std::ostream& str, Telemetry::Position const& position)

    str << std::setprecision(15);

    str << "position:" << '\n' << "{\n";

    str << "    latitude_deg: " << position.latitude_deg << '\n';

    str << "    longitude_deg: " << position.longitude_deg << '\n';

    str << "    absolute_altitude_m: " << position.absolute_altitude_m << '\n';

    str << "    relative_altitude_m: " << position.relative_altitude_m << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::Heading& lhs, const Telemetry::Heading& rhs)

        (std::isnan(rhs.heading_deg) && std::isnan(lhs.heading_deg)) ||

        rhs.heading_deg == lhs.heading_deg);

std::ostream& operator<<(std::ostream& str, Telemetry::Heading const& heading)

    str << std::setprecision(15);

    str << "heading:" << '\n' << "{\n";

    str << "    heading_deg: " << heading.heading_deg << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::Quaternion& lhs, const Telemetry::Quaternion& rhs)

    return ((std::isnan(rhs.w) && std::isnan(lhs.w)) || rhs.w == lhs.w) &&

           ((std::isnan(rhs.x) && std::isnan(lhs.x)) || rhs.x == lhs.x) &&

           ((std::isnan(rhs.y) && std::isnan(lhs.y)) || rhs.y == lhs.y) &&

           ((std::isnan(rhs.z) && std::isnan(lhs.z)) || rhs.z == lhs.z) &&

           (rhs.timestamp_us == lhs.timestamp_us);

std::ostream& operator<<(std::ostream& str, Telemetry::Quaternion const& quaternion)

    str << std::setprecision(15);

    str << "quaternion:" << '\n' << "{\n";

    str << "    w: " << quaternion.w << '\n';

    str << "    x: " << quaternion.x << '\n';

    str << "    y: " << quaternion.y << '\n';

    str << "    z: " << quaternion.z << '\n';

    str << "    timestamp_us: " << quaternion.timestamp_us << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::EulerAngle& lhs, const Telemetry::EulerAngle& rhs)

    return ((std::isnan(rhs.roll_deg) && std::isnan(lhs.roll_deg)) ||

            rhs.roll_deg == lhs.roll_deg) &&

           ((std::isnan(rhs.pitch_deg) && std::isnan(lhs.pitch_deg)) ||

            rhs.pitch_deg == lhs.pitch_deg) &&

           ((std::isnan(rhs.yaw_deg) && std::isnan(lhs.yaw_deg)) || rhs.yaw_deg == lhs.yaw_deg) &&

           (rhs.timestamp_us == lhs.timestamp_us);

std::ostream& operator<<(std::ostream& str, Telemetry::EulerAngle const& euler_angle)

    str << std::setprecision(15);

    str << "euler_angle:" << '\n' << "{\n";

    str << "    roll_deg: " << euler_angle.roll_deg << '\n';

    str << "    pitch_deg: " << euler_angle.pitch_deg << '\n';

    str << "    yaw_deg: " << euler_angle.yaw_deg << '\n';

    str << "    timestamp_us: " << euler_angle.timestamp_us << '\n';

    str << '}';

    return str;

bool operator==(

    return ((std::isnan(rhs.roll_rad_s) && std::isnan(lhs.roll_rad_s)) ||

            rhs.roll_rad_s == lhs.roll_rad_s) &&

           ((std::isnan(rhs.pitch_rad_s) && std::isnan(lhs.pitch_rad_s)) ||

            rhs.pitch_rad_s == lhs.pitch_rad_s) &&

           ((std::isnan(rhs.yaw_rad_s) && std::isnan(lhs.yaw_rad_s)) ||

            rhs.yaw_rad_s == lhs.yaw_rad_s);

operator<<(std::ostream& str, Telemetry::AngularVelocityBody const& angular_velocity_body)

    str << std::setprecision(15);

    str << "angular_velocity_body:" << '\n' << "{\n";

    str << "    roll_rad_s: " << angular_velocity_body.roll_rad_s << '\n';

    str << "    pitch_rad_s: " << angular_velocity_body.pitch_rad_s << '\n';

    str << "    yaw_rad_s: " << angular_velocity_body.yaw_rad_s << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::GpsInfo& lhs, const Telemetry::GpsInfo& rhs)

    return (rhs.num_satellites == lhs.num_satellites) && (rhs.fix_type == lhs.fix_type);

std::ostream& operator<<(std::ostream& str, Telemetry::GpsInfo const& gps_info)

    str << std::setprecision(15);

    str << "gps_info:" << '\n' << "{\n";

    str << "    num_satellites: " << gps_info.num_satellites << '\n';

    str << "    fix_type: " << gps_info.fix_type << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::RawGps& lhs, const Telemetry::RawGps& rhs)

    return (rhs.timestamp_us == lhs.timestamp_us) &&

           ((std::isnan(rhs.latitude_deg) && std::isnan(lhs.latitude_deg)) ||

            rhs.latitude_deg == lhs.latitude_deg) &&

           ((std::isnan(rhs.longitude_deg) && std::isnan(lhs.longitude_deg)) ||

            rhs.longitude_deg == lhs.longitude_deg) &&

           ((std::isnan(rhs.absolute_altitude_m) && std::isnan(lhs.absolute_altitude_m)) ||

            rhs.absolute_altitude_m == lhs.absolute_altitude_m) &&

           ((std::isnan(rhs.hdop) && std::isnan(lhs.hdop)) || rhs.hdop == lhs.hdop) &&

           ((std::isnan(rhs.vdop) && std::isnan(lhs.vdop)) || rhs.vdop == lhs.vdop) &&

           ((std::isnan(rhs.velocity_m_s) && std::isnan(lhs.velocity_m_s)) ||

            rhs.velocity_m_s == lhs.velocity_m_s) &&

           ((std::isnan(rhs.cog_deg) && std::isnan(lhs.cog_deg)) || rhs.cog_deg == lhs.cog_deg) &&

           ((std::isnan(rhs.altitude_ellipsoid_m) && std::isnan(lhs.altitude_ellipsoid_m)) ||

            rhs.altitude_ellipsoid_m == lhs.altitude_ellipsoid_m) &&

           ((std::isnan(rhs.horizontal_uncertainty_m) &&

             std::isnan(lhs.horizontal_uncertainty_m)) ||

            rhs.horizontal_uncertainty_m == lhs.horizontal_uncertainty_m) &&

           ((std::isnan(rhs.vertical_uncertainty_m) && std::isnan(lhs.vertical_uncertainty_m)) ||

            rhs.vertical_uncertainty_m == lhs.vertical_uncertainty_m) &&

           ((std::isnan(rhs.velocity_uncertainty_m_s) &&

             std::isnan(lhs.velocity_uncertainty_m_s)) ||

            rhs.velocity_uncertainty_m_s == lhs.velocity_uncertainty_m_s) &&

           ((std::isnan(rhs.heading_uncertainty_deg) && std::isnan(lhs.heading_uncertainty_deg)) ||

            rhs.heading_uncertainty_deg == lhs.heading_uncertainty_deg) &&

           ((std::isnan(rhs.yaw_deg) && std::isnan(lhs.yaw_deg)) || rhs.yaw_deg == lhs.yaw_deg);

std::ostream& operator<<(std::ostream& str, Telemetry::RawGps const& raw_gps)

    str << std::setprecision(15);

    str << "raw_gps:" << '\n' << "{\n";

    str << "    timestamp_us: " << raw_gps.timestamp_us << '\n';

    str << "    latitude_deg: " << raw_gps.latitude_deg << '\n';

    str << "    longitude_deg: " << raw_gps.longitude_deg << '\n';

    str << "    absolute_altitude_m: " << raw_gps.absolute_altitude_m << '\n';

    str << "    hdop: " << raw_gps.hdop << '\n';

    str << "    vdop: " << raw_gps.vdop << '\n';

    str << "    velocity_m_s: " << raw_gps.velocity_m_s << '\n';

    str << "    cog_deg: " << raw_gps.cog_deg << '\n';

    str << "    altitude_ellipsoid_m: " << raw_gps.altitude_ellipsoid_m << '\n';

    str << "    horizontal_uncertainty_m: " << raw_gps.horizontal_uncertainty_m << '\n';

    str << "    vertical_uncertainty_m: " << raw_gps.vertical_uncertainty_m << '\n';

    str << "    velocity_uncertainty_m_s: " << raw_gps.velocity_uncertainty_m_s << '\n';

    str << "    heading_uncertainty_deg: " << raw_gps.heading_uncertainty_deg << '\n';

    str << "    yaw_deg: " << raw_gps.yaw_deg << '\n';

    str << '}';

    return str;

bool operator==(const Telemetry::Battery& lhs, const Telemetry::Battery& rhs)

    return (rhs.id == lhs.id) &&

           ((std::isnan(rhs.temperature_degc) && std::isnan(lhs.temperature_degc)) ||

            rhs.temperature_degc == lhs.temperature_degc) &&

           ((std::isnan(rhs.voltage_v) && std::isnan(lhs.voltage_v)) ||

            rhs.voltage_v == lhs.voltage_v) &&

           ((std::isnan(rhs.current_battery_a) && std::isnan(lhs.current_battery_a)) ||

            rhs.current_battery_a == lhs.current_battery_a) &&

           ((std::isnan(rhs.capacity_consumed_ah) && std::isnan(lhs.capacity_consumed_ah)) ||

            rhs.capacity_consumed_ah == lhs.capacity_consumed_ah) &&

           ((std::isnan(rhs.remaining_percent) && std::isnan(lhs.remaining_percent)) ||

            rhs.remaining_percent == lhs.remaining_percent);