ublox 0.10.0

A crate to communicate with u-blox GPS devices using the UBX protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[allow(unused_imports, reason = "It is only unused in some feature sets")]
use crate::FieldIter;
#[cfg(feature = "serde")]
use {super::SerializeUbxPacketFields, crate::serde::ser::SerializeMap};

use crate::{error::ParserError, UbxPacketMeta};
use ublox_derive::ubx_packet_recv;

#[ubx_packet_recv]
#[ubx(class = 0x02, id = 0x13, max_payload_len = 72)]
struct RxmSfrbx {
    /// GNSS identifier
    gnss_id: u8,

    /// Satellite identifier
    sv_id: u8,

    /// Reserved
    reserved1: u8,

    /// Only used for GLonass: this is the frequency slot +7
    freq_id: u8,

    /// Number of data words
    num_words: u8,

    /// Reserved
    reserved2: u8,

    /// Message version
    version: u8,

    /// Reserved
    reserved3: u8,

    /// Data words
    #[ubx(
        map_type = DwrdIter,
        from = DwrdIter::new,
        is_valid = DwrdIter::is_valid,
        may_fail,
    )]
    dwrd: [u8; 0],
}

#[derive(Debug, Clone)]
pub struct DwrdIter<'a>(core::slice::ChunksExact<'a, u8>);

impl<'a> DwrdIter<'a> {
    fn new(bytes: &'a [u8]) -> Self {
        DwrdIter(bytes.chunks_exact(4))
    }

    fn is_valid(bytes: &[u8]) -> bool {
        bytes.len().is_multiple_of(4)
    }
}

impl core::iter::Iterator for DwrdIter<'_> {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.0
            .next()
            .map(|bytes| u32::from_le_bytes(bytes.try_into().unwrap()))
    }
}

#[cfg(feature = "sfrbx-gps")]
use gnss_protos::{GpsDataByte, GpsQzssDecoder, GpsQzssFrame};

#[derive(Debug, Clone)]
pub enum RxmSfrbxInterpreted {
    /// [GpsQzssFrame]
    #[cfg(feature = "sfrbx-gps")]
    GpsQzss(GpsQzssFrame),
}

impl RxmSfrbxRef<'_> {
    /// Try to interpret the RXM-SFRBX inner frame (when supported/known).
    pub fn interpret(&self) -> Option<RxmSfrbxInterpreted> {
        // interpretation is GNSS dependent
        match self.gnss_id() {
            0 | 5 => {
                #[cfg(feature = "sfrbx-gps")]
                {
                    let decoded = self.gps_qzss_decoding()?;
                    Some(RxmSfrbxInterpreted::GpsQzss(decoded))
                }
                #[cfg(not(feature = "sfrbx-gps"))]
                {
                    None
                }
            },
            _ => {
                // either not supported or not applicable
                None
            },
        }
    }

    #[cfg(feature = "sfrbx-gps")]
    /// [GpsQzssFrame] interpretation attempt, from parsed UBX-SFRBX data.
    fn gps_qzss_decoding(&self) -> Option<GpsQzssFrame> {
        let mut decoder = GpsQzssDecoder::default().without_parity_verification();

        for byte in self.dwrd() {
            let bytes = byte.to_be_bytes();

            let gps_bytes = [
                GpsDataByte::MsbPadded(bytes[0]),
                GpsDataByte::Byte(bytes[1]),
                GpsDataByte::Byte(bytes[2]),
                GpsDataByte::Byte(bytes[3]),
            ];

            for gps_byte in gps_bytes {
                if let Some(decoded) = decoder.parse(gps_byte) {
                    return Some(decoded);
                }
            }
        }

        None
    }
}