Struct Meas3DecodedEpoch 

pub struct Meas3DecodedEpoch {
    pub antenna_id: u8,
    pub common_flags: u8,
    pub total_clock_jump_ms: i32,
    pub reference_epoch_interval_ms: u32,
    pub is_reference_epoch: bool,
    pub reference_epoch_contains_pr_rate: bool,
    pub satellites: Vec<Meas3Satellite>,
    /* private fields */
}

One decoded Meas3 epoch for a single antenna.

Fields

antenna_id: u8

common_flags: u8

total_clock_jump_ms: i32

reference_epoch_interval_ms: u32

is_reference_epoch: bool

reference_epoch_contains_pr_rate: bool

satellites: Vec<Meas3Satellite>

Implementations

impl Meas3DecodedEpoch

pub fn tow_seconds(&self) -> f64

pub fn tow_ms(&self) -> u32

Examples found in repository

examples/decode_meas3.rs (line 69)

fn flush_bundles(
    bundles: &mut HashMap<u8, Meas3BlockSet>,
    decoder: &mut Meas3Decoder,
) -> Result<(), Box<dyn Error>> {
    let mut antenna_ids: Vec<u8> = bundles.keys().copied().collect();
    antenna_ids.sort_unstable();

    for antenna_id in antenna_ids {
        if let Some(block_set) = bundles.get(&antenna_id) {
            if block_set.ranges.is_none() {
                continue;
            }

            let epoch = decoder.decode_block_set(block_set)?;
            println!(
                "TOW {} WNc {} antenna {}: {} satellites, {} measurements",
                epoch.tow_ms(),
                epoch.wnc(),
                epoch.antenna_id,
                epoch.num_satellites(),
                epoch.num_measurements()
            );

            for satellite in epoch.satellites.iter().take(4) {
                let signal_summary = satellite
                    .measurements
                    .iter()
                    .map(|meas| match meas.cn0_dbhz() {
                        Some(cn0) => format!("{}:{cn0:.2}dB-Hz", meas.signal_type),
                        None => meas.signal_type.to_string(),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                println!("  {}  {}", satellite.sat_id, signal_summary);
            }
        }
    }

    bundles.clear();
    Ok(())
}

pub fn wnc(&self) -> u16

Examples found in repository

examples/decode_meas3.rs (line 70)

fn flush_bundles(
    bundles: &mut HashMap<u8, Meas3BlockSet>,
    decoder: &mut Meas3Decoder,
) -> Result<(), Box<dyn Error>> {
    let mut antenna_ids: Vec<u8> = bundles.keys().copied().collect();
    antenna_ids.sort_unstable();

    for antenna_id in antenna_ids {
        if let Some(block_set) = bundles.get(&antenna_id) {
            if block_set.ranges.is_none() {
                continue;
            }

            let epoch = decoder.decode_block_set(block_set)?;
            println!(
                "TOW {} WNc {} antenna {}: {} satellites, {} measurements",
                epoch.tow_ms(),
                epoch.wnc(),
                epoch.antenna_id,
                epoch.num_satellites(),
                epoch.num_measurements()
            );

            for satellite in epoch.satellites.iter().take(4) {
                let signal_summary = satellite
                    .measurements
                    .iter()
                    .map(|meas| match meas.cn0_dbhz() {
                        Some(cn0) => format!("{}:{cn0:.2}dB-Hz", meas.signal_type),
                        None => meas.signal_type.to_string(),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                println!("  {}  {}", satellite.sat_id, signal_summary);
            }
        }
    }

    bundles.clear();
    Ok(())
}

pub fn num_satellites(&self) -> usize

Examples found in repository

examples/decode_meas3.rs (line 72)

fn flush_bundles(
    bundles: &mut HashMap<u8, Meas3BlockSet>,
    decoder: &mut Meas3Decoder,
) -> Result<(), Box<dyn Error>> {
    let mut antenna_ids: Vec<u8> = bundles.keys().copied().collect();
    antenna_ids.sort_unstable();

    for antenna_id in antenna_ids {
        if let Some(block_set) = bundles.get(&antenna_id) {
            if block_set.ranges.is_none() {
                continue;
            }

            let epoch = decoder.decode_block_set(block_set)?;
            println!(
                "TOW {} WNc {} antenna {}: {} satellites, {} measurements",
                epoch.tow_ms(),
                epoch.wnc(),
                epoch.antenna_id,
                epoch.num_satellites(),
                epoch.num_measurements()
            );

            for satellite in epoch.satellites.iter().take(4) {
                let signal_summary = satellite
                    .measurements
                    .iter()
                    .map(|meas| match meas.cn0_dbhz() {
                        Some(cn0) => format!("{}:{cn0:.2}dB-Hz", meas.signal_type),
                        None => meas.signal_type.to_string(),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                println!("  {}  {}", satellite.sat_id, signal_summary);
            }
        }
    }

    bundles.clear();
    Ok(())
}

pub fn num_measurements(&self) -> usize

Examples found in repository

examples/decode_meas3.rs (line 73)

fn flush_bundles(
    bundles: &mut HashMap<u8, Meas3BlockSet>,
    decoder: &mut Meas3Decoder,
) -> Result<(), Box<dyn Error>> {
    let mut antenna_ids: Vec<u8> = bundles.keys().copied().collect();
    antenna_ids.sort_unstable();

    for antenna_id in antenna_ids {
        if let Some(block_set) = bundles.get(&antenna_id) {
            if block_set.ranges.is_none() {
                continue;
            }

            let epoch = decoder.decode_block_set(block_set)?;
            println!(
                "TOW {} WNc {} antenna {}: {} satellites, {} measurements",
                epoch.tow_ms(),
                epoch.wnc(),
                epoch.antenna_id,
                epoch.num_satellites(),
                epoch.num_measurements()
            );

            for satellite in epoch.satellites.iter().take(4) {
                let signal_summary = satellite
                    .measurements
                    .iter()
                    .map(|meas| match meas.cn0_dbhz() {
                        Some(cn0) => format!("{}:{cn0:.2}dB-Hz", meas.signal_type),
                        None => meas.signal_type.to_string(),
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                println!("  {}  {}", satellite.sat_id, signal_summary);
            }
        }
    }

    bundles.clear();
    Ok(())
}

Trait Implementations

impl Clone for Meas3DecodedEpoch

fn clone(&self) -> Meas3DecodedEpoch

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Meas3DecodedEpoch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.