pub use msg_tel_sv::MsgTelSv;
pub use telemetry_sv::TelemetrySV;
pub mod msg_tel_sv {
#![allow(unused_imports)]
use super::*;
use crate::messages::gnss::*;
use crate::messages::lib::*;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, PartialEq, Clone)]
pub struct MsgTelSv {
#[cfg_attr(feature = "serde", serde(skip_serializing, alias = "sender"))]
pub sender_id: Option<u16>,
#[cfg_attr(feature = "serde", serde(rename = "wn"))]
pub wn: u16,
#[cfg_attr(feature = "serde", serde(rename = "tow"))]
pub tow: u32,
#[cfg_attr(feature = "serde", serde(rename = "n_obs"))]
pub n_obs: u8,
#[cfg_attr(feature = "serde", serde(rename = "origin_flags"))]
pub origin_flags: u8,
#[cfg_attr(feature = "serde", serde(rename = "sv_tel"))]
pub sv_tel: Vec<TelemetrySV>,
}
impl MsgTelSv {
pub fn filter_type(&self) -> Result<FilterType, u8> {
get_bit_range!(self.origin_flags, u8, u8, 7, 0).try_into()
}
pub fn set_filter_type(&mut self, filter_type: FilterType) {
set_bit_range!(&mut self.origin_flags, filter_type, u8, u8, 7, 0);
}
}
impl ConcreteMessage for MsgTelSv {
const MESSAGE_TYPE: u16 = 288;
const MESSAGE_NAME: &'static str = "MSG_TEL_SV";
}
impl SbpMessage for MsgTelSv {
fn message_name(&self) -> &'static str {
<Self as ConcreteMessage>::MESSAGE_NAME
}
fn message_type(&self) -> u16 {
<Self as ConcreteMessage>::MESSAGE_TYPE
}
fn sender_id(&self) -> Option<u16> {
self.sender_id
}
fn set_sender_id(&mut self, new_id: u16) {
self.sender_id = Some(new_id);
}
fn encoded_len(&self) -> usize {
WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN
}
#[cfg(feature = "swiftnav")]
fn gps_time(&self) -> Option<std::result::Result<time::MessageTime, time::GpsTimeError>> {
let tow_s = (self.tow as f64) / 1000.0;
#[allow(clippy::useless_conversion)]
let wn: i16 = match self.wn.try_into() {
Ok(wn) => wn,
Err(e) => return Some(Err(e.into())),
};
let gps_time = match time::GpsTime::new(wn, tow_s) {
Ok(gps_time) => gps_time,
Err(e) => return Some(Err(e.into())),
};
Some(Ok(time::MessageTime::Rover(gps_time.into())))
}
}
impl FriendlyName for MsgTelSv {
fn friendly_name() -> &'static str {
"TEL SV"
}
}
impl TryFrom<Sbp> for MsgTelSv {
type Error = TryFromSbpError;
fn try_from(msg: Sbp) -> Result<Self, Self::Error> {
match msg {
Sbp::MsgTelSv(m) => Ok(m),
_ => Err(TryFromSbpError(msg)),
}
}
}
impl WireFormat for MsgTelSv {
const MIN_LEN: usize = <u16 as WireFormat>::MIN_LEN
+ <u32 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <Vec<TelemetrySV> as WireFormat>::MIN_LEN;
fn len(&self) -> usize {
WireFormat::len(&self.wn)
+ WireFormat::len(&self.tow)
+ WireFormat::len(&self.n_obs)
+ WireFormat::len(&self.origin_flags)
+ WireFormat::len(&self.sv_tel)
}
fn write<B: BufMut>(&self, buf: &mut B) {
WireFormat::write(&self.wn, buf);
WireFormat::write(&self.tow, buf);
WireFormat::write(&self.n_obs, buf);
WireFormat::write(&self.origin_flags, buf);
WireFormat::write(&self.sv_tel, buf);
}
fn parse_unchecked<B: Buf>(buf: &mut B) -> Self {
MsgTelSv {
sender_id: None,
wn: WireFormat::parse_unchecked(buf),
tow: WireFormat::parse_unchecked(buf),
n_obs: WireFormat::parse_unchecked(buf),
origin_flags: WireFormat::parse_unchecked(buf),
sv_tel: WireFormat::parse_unchecked(buf),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FilterType {
Standalone = 0,
Differential = 1,
}
impl std::fmt::Display for FilterType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
FilterType::Standalone => f.write_str("Standalone"),
FilterType::Differential => f.write_str("Differential"),
}
}
}
impl TryFrom<u8> for FilterType {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(FilterType::Standalone),
1 => Ok(FilterType::Differential),
i => Err(i),
}
}
}
}
pub mod telemetry_sv {
#![allow(unused_imports)]
use super::*;
use crate::messages::gnss::*;
use crate::messages::lib::*;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Debug, PartialEq, Clone)]
pub struct TelemetrySV {
#[cfg_attr(feature = "serde", serde(rename = "az"))]
pub az: u8,
#[cfg_attr(feature = "serde", serde(rename = "el"))]
pub el: i8,
#[cfg_attr(feature = "serde", serde(rename = "availability_flags"))]
pub availability_flags: u8,
#[cfg_attr(feature = "serde", serde(rename = "pseudorange_residual"))]
pub pseudorange_residual: i16,
#[cfg_attr(feature = "serde", serde(rename = "phase_residual"))]
pub phase_residual: i16,
#[cfg_attr(feature = "serde", serde(rename = "outlier_flags"))]
pub outlier_flags: u8,
#[cfg_attr(feature = "serde", serde(rename = "ephemeris_flags"))]
pub ephemeris_flags: u8,
#[cfg_attr(feature = "serde", serde(rename = "correction_flags"))]
pub correction_flags: u8,
#[cfg_attr(feature = "serde", serde(rename = "sid"))]
pub sid: GnssSignal,
}
impl TelemetrySV {
pub fn measured_doppler_availability(&self) -> Result<MeasuredDopplerAvailability, u8> {
get_bit_range!(self.availability_flags, u8, u8, 3, 3).try_into()
}
pub fn set_measured_doppler_availability(
&mut self,
measured_doppler_availability: MeasuredDopplerAvailability,
) {
set_bit_range!(
&mut self.availability_flags,
measured_doppler_availability,
u8,
u8,
3,
3
);
}
pub fn computed_doppler_availability(&self) -> Result<ComputedDopplerAvailability, u8> {
get_bit_range!(self.availability_flags, u8, u8, 2, 2).try_into()
}
pub fn set_computed_doppler_availability(
&mut self,
computed_doppler_availability: ComputedDopplerAvailability,
) {
set_bit_range!(
&mut self.availability_flags,
computed_doppler_availability,
u8,
u8,
2,
2
);
}
pub fn carrierphase_availability(&self) -> Result<CarrierPhaseAvailability, u8> {
get_bit_range!(self.availability_flags, u8, u8, 1, 1).try_into()
}
pub fn set_carrierphase_availability(
&mut self,
carrierphase_availability: CarrierPhaseAvailability,
) {
set_bit_range!(
&mut self.availability_flags,
carrierphase_availability,
u8,
u8,
1,
1
);
}
pub fn pseudorange_availability(&self) -> Result<PseudorangeAvailability, u8> {
get_bit_range!(self.availability_flags, u8, u8, 0, 0).try_into()
}
pub fn set_pseudorange_availability(
&mut self,
pseudorange_availability: PseudorangeAvailability,
) {
set_bit_range!(
&mut self.availability_flags,
pseudorange_availability,
u8,
u8,
0,
0
);
}
pub fn measured_doppler_outlier(&self) -> Result<MeasuredDopplerOutlier, u8> {
get_bit_range!(self.outlier_flags, u8, u8, 4, 4).try_into()
}
pub fn set_measured_doppler_outlier(
&mut self,
measured_doppler_outlier: MeasuredDopplerOutlier,
) {
set_bit_range!(
&mut self.outlier_flags,
measured_doppler_outlier,
u8,
u8,
4,
4
);
}
pub fn computed_doppler_outlier(&self) -> Result<ComputedDopplerOutlier, u8> {
get_bit_range!(self.outlier_flags, u8, u8, 3, 3).try_into()
}
pub fn set_computed_doppler_outlier(
&mut self,
computed_doppler_outlier: ComputedDopplerOutlier,
) {
set_bit_range!(
&mut self.outlier_flags,
computed_doppler_outlier,
u8,
u8,
3,
3
);
}
pub fn carrierphase_outlier(&self) -> Result<CarrierPhaseOutlier, u8> {
get_bit_range!(self.outlier_flags, u8, u8, 2, 2).try_into()
}
pub fn set_carrierphase_outlier(&mut self, carrierphase_outlier: CarrierPhaseOutlier) {
set_bit_range!(&mut self.outlier_flags, carrierphase_outlier, u8, u8, 2, 2);
}
pub fn pseudorange_outlier(&self) -> Result<PseudorangeOutlier, u8> {
get_bit_range!(self.outlier_flags, u8, u8, 1, 0).try_into()
}
pub fn set_pseudorange_outlier(&mut self, pseudorange_outlier: PseudorangeOutlier) {
set_bit_range!(&mut self.outlier_flags, pseudorange_outlier, u8, u8, 1, 0);
}
pub fn ephemeris_available(&self) -> Result<EphemerisAvailable, u8> {
get_bit_range!(self.ephemeris_flags, u8, u8, 0, 0).try_into()
}
pub fn set_ephemeris_available(&mut self, ephemeris_available: EphemerisAvailable) {
set_bit_range!(&mut self.ephemeris_flags, ephemeris_available, u8, u8, 0, 0);
}
}
impl WireFormat for TelemetrySV {
const MIN_LEN: usize = <u8 as WireFormat>::MIN_LEN
+ <i8 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <i16 as WireFormat>::MIN_LEN
+ <i16 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <u8 as WireFormat>::MIN_LEN
+ <GnssSignal as WireFormat>::MIN_LEN;
fn len(&self) -> usize {
WireFormat::len(&self.az)
+ WireFormat::len(&self.el)
+ WireFormat::len(&self.availability_flags)
+ WireFormat::len(&self.pseudorange_residual)
+ WireFormat::len(&self.phase_residual)
+ WireFormat::len(&self.outlier_flags)
+ WireFormat::len(&self.ephemeris_flags)
+ WireFormat::len(&self.correction_flags)
+ WireFormat::len(&self.sid)
}
fn write<B: BufMut>(&self, buf: &mut B) {
WireFormat::write(&self.az, buf);
WireFormat::write(&self.el, buf);
WireFormat::write(&self.availability_flags, buf);
WireFormat::write(&self.pseudorange_residual, buf);
WireFormat::write(&self.phase_residual, buf);
WireFormat::write(&self.outlier_flags, buf);
WireFormat::write(&self.ephemeris_flags, buf);
WireFormat::write(&self.correction_flags, buf);
WireFormat::write(&self.sid, buf);
}
fn parse_unchecked<B: Buf>(buf: &mut B) -> Self {
TelemetrySV {
az: WireFormat::parse_unchecked(buf),
el: WireFormat::parse_unchecked(buf),
availability_flags: WireFormat::parse_unchecked(buf),
pseudorange_residual: WireFormat::parse_unchecked(buf),
phase_residual: WireFormat::parse_unchecked(buf),
outlier_flags: WireFormat::parse_unchecked(buf),
ephemeris_flags: WireFormat::parse_unchecked(buf),
correction_flags: WireFormat::parse_unchecked(buf),
sid: WireFormat::parse_unchecked(buf),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MeasuredDopplerAvailability {
MeasuredDopplerUnavailable = 0,
MeasuredDopplerAvailable = 1,
}
impl std::fmt::Display for MeasuredDopplerAvailability {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
MeasuredDopplerAvailability::MeasuredDopplerUnavailable => {
f.write_str("Measured-Doppler unavailable")
}
MeasuredDopplerAvailability::MeasuredDopplerAvailable => {
f.write_str("Measured-Doppler available")
}
}
}
}
impl TryFrom<u8> for MeasuredDopplerAvailability {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(MeasuredDopplerAvailability::MeasuredDopplerUnavailable),
1 => Ok(MeasuredDopplerAvailability::MeasuredDopplerAvailable),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ComputedDopplerAvailability {
ComputedDopplerUnavailable = 0,
ComputedDopplerAvailable = 1,
}
impl std::fmt::Display for ComputedDopplerAvailability {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ComputedDopplerAvailability::ComputedDopplerUnavailable => {
f.write_str("Computed-Doppler unavailable")
}
ComputedDopplerAvailability::ComputedDopplerAvailable => {
f.write_str("Computed-Doppler available")
}
}
}
}
impl TryFrom<u8> for ComputedDopplerAvailability {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(ComputedDopplerAvailability::ComputedDopplerUnavailable),
1 => Ok(ComputedDopplerAvailability::ComputedDopplerAvailable),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CarrierPhaseAvailability {
CarrierPhaseUnavailable = 0,
CarrierPhaseAvailable = 1,
}
impl std::fmt::Display for CarrierPhaseAvailability {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CarrierPhaseAvailability::CarrierPhaseUnavailable => {
f.write_str("Carrier-phase unavailable")
}
CarrierPhaseAvailability::CarrierPhaseAvailable => {
f.write_str("Carrier-phase available")
}
}
}
}
impl TryFrom<u8> for CarrierPhaseAvailability {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(CarrierPhaseAvailability::CarrierPhaseUnavailable),
1 => Ok(CarrierPhaseAvailability::CarrierPhaseAvailable),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PseudorangeAvailability {
PseudorangeUnavailable = 0,
PseudorangeAvailable = 1,
}
impl std::fmt::Display for PseudorangeAvailability {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PseudorangeAvailability::PseudorangeUnavailable => {
f.write_str("Pseudorange unavailable")
}
PseudorangeAvailability::PseudorangeAvailable => {
f.write_str("Pseudorange available")
}
}
}
}
impl TryFrom<u8> for PseudorangeAvailability {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(PseudorangeAvailability::PseudorangeUnavailable),
1 => Ok(PseudorangeAvailability::PseudorangeAvailable),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MeasuredDopplerOutlier {
MeasuredDopplerAccepted = 0,
MeasuredDopplerMarkedAsOutlier = 1,
}
impl std::fmt::Display for MeasuredDopplerOutlier {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
MeasuredDopplerOutlier::MeasuredDopplerAccepted => {
f.write_str("Measured-Doppler accepted")
}
MeasuredDopplerOutlier::MeasuredDopplerMarkedAsOutlier => {
f.write_str("Measured-Doppler marked as outlier")
}
}
}
}
impl TryFrom<u8> for MeasuredDopplerOutlier {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(MeasuredDopplerOutlier::MeasuredDopplerAccepted),
1 => Ok(MeasuredDopplerOutlier::MeasuredDopplerMarkedAsOutlier),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ComputedDopplerOutlier {
ComputedDopplerAccepted = 0,
ComputedDopplerMarkedAsOutlier = 1,
}
impl std::fmt::Display for ComputedDopplerOutlier {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ComputedDopplerOutlier::ComputedDopplerAccepted => {
f.write_str("Computed-Doppler accepted")
}
ComputedDopplerOutlier::ComputedDopplerMarkedAsOutlier => {
f.write_str("Computed-Doppler marked as outlier")
}
}
}
}
impl TryFrom<u8> for ComputedDopplerOutlier {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(ComputedDopplerOutlier::ComputedDopplerAccepted),
1 => Ok(ComputedDopplerOutlier::ComputedDopplerMarkedAsOutlier),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CarrierPhaseOutlier {
CarrierPhaseAccepted = 0,
CarrierPhaseMarkedAsOutlier = 1,
}
impl std::fmt::Display for CarrierPhaseOutlier {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CarrierPhaseOutlier::CarrierPhaseAccepted => f.write_str("Carrier-phase accepted"),
CarrierPhaseOutlier::CarrierPhaseMarkedAsOutlier => {
f.write_str("Carrier-phase marked as outlier")
}
}
}
}
impl TryFrom<u8> for CarrierPhaseOutlier {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(CarrierPhaseOutlier::CarrierPhaseAccepted),
1 => Ok(CarrierPhaseOutlier::CarrierPhaseMarkedAsOutlier),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PseudorangeOutlier {
PseudorangeAccepted = 0,
PseudorangeMarkedAsOutlier = 1,
PseudorangeMarkedAsMajorOutlier = 2,
}
impl std::fmt::Display for PseudorangeOutlier {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PseudorangeOutlier::PseudorangeAccepted => f.write_str("Pseudorange accepted"),
PseudorangeOutlier::PseudorangeMarkedAsOutlier => {
f.write_str("Pseudorange marked as outlier")
}
PseudorangeOutlier::PseudorangeMarkedAsMajorOutlier => {
f.write_str("Pseudorange marked as major outlier")
}
}
}
}
impl TryFrom<u8> for PseudorangeOutlier {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(PseudorangeOutlier::PseudorangeAccepted),
1 => Ok(PseudorangeOutlier::PseudorangeMarkedAsOutlier),
2 => Ok(PseudorangeOutlier::PseudorangeMarkedAsMajorOutlier),
i => Err(i),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EphemerisAvailable {
ValidEphemerisAvailable = 0,
NoValidEphemerisAvailable = 1,
}
impl std::fmt::Display for EphemerisAvailable {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
EphemerisAvailable::ValidEphemerisAvailable => {
f.write_str("Valid ephemeris available")
}
EphemerisAvailable::NoValidEphemerisAvailable => {
f.write_str("No valid ephemeris available (general status)")
}
}
}
}
impl TryFrom<u8> for EphemerisAvailable {
type Error = u8;
fn try_from(i: u8) -> Result<Self, u8> {
match i {
0 => Ok(EphemerisAvailable::ValidEphemerisAvailable),
1 => Ok(EphemerisAvailable::NoValidEphemerisAvailable),
i => Err(i),
}
}
}
}