nmea-kit 0.5.0

Bidirectional NMEA 0183 parser and encoder with AIS decoding
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
127
128
129
130

use crate::nmea::field::{FieldReader, FieldWriter, NmeaEncodable};

/// PGRMT — Garmin Sensor Status Information.
///
/// Wire: `product_info,rom_checksum,receiver_failure,stored_data,rtc_lost,osc_drift,data_collection,sensor_temp,sensor_config`
///
/// Proprietary sentence: `parse_frame` sets `talker = ""`, `sentence_type = "PGRMT"`.
/// Encode with `to_proprietary_sentence()`.
#[derive(Debug, Clone, PartialEq)]
pub struct Pgrmt {
    /// Product/software information string.
    pub product_info: Option<String>,
    /// ROM checksum test ('P' = passed, 'F' = failed).
    pub rom_checksum: Option<char>,
    /// Receiver failure discrete ('P' = passed, 'F' = failed).
    pub receiver_failure: Option<char>,
    /// Stored data lost ('R' = retained, 'L' = lost).
    pub stored_data: Option<char>,
    /// Real-time clock lost ('R' = retained, 'L' = lost).
    pub rtc_lost: Option<char>,
    /// Oscillator drift discrete ('P' = passed, 'F' = failed).
    pub osc_drift: Option<char>,
    /// Data collection discrete ('C' = complete, 'I' = incomplete).
    pub data_collection: Option<char>,
    /// Sensor temperature in degrees C.
    pub sensor_temp: Option<String>,
    /// Sensor configuration ('S' = sensitivity, 'D' = default, 'N' = not available).
    pub sensor_config: Option<char>,
}

impl Pgrmt {
    /// Parse fields from a decoded NMEA frame.
    /// Always returns `Some`; missing or malformed fields become `None`.
    pub fn parse(fields: &[&str]) -> Option<Self> {
        let mut r = FieldReader::new(fields);
        let product_info = r.string();
        let rom_checksum = r.char();
        let receiver_failure = r.char();
        let stored_data = r.char();
        let rtc_lost = r.char();
        let osc_drift = r.char();
        let data_collection = r.char();
        let sensor_temp = r.string();
        let sensor_config = r.char();
        Some(Self {
            product_info,
            rom_checksum,
            receiver_failure,
            stored_data,
            rtc_lost,
            osc_drift,
            data_collection,
            sensor_temp,
            sensor_config,
        })
    }
}

impl NmeaEncodable for Pgrmt {
    const SENTENCE_TYPE: &str = "RMT";
    const PROPRIETARY_ID: &str = "PGRMT";

    fn encode(&self) -> Vec<String> {
        let mut w = FieldWriter::new();
        w.string(self.product_info.as_deref());
        w.char(self.rom_checksum);
        w.char(self.receiver_failure);
        w.char(self.stored_data);
        w.char(self.rtc_lost);
        w.char(self.osc_drift);
        w.char(self.data_collection);
        w.string(self.sensor_temp.as_deref());
        w.char(self.sensor_config);
        w.finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse_frame;

    #[test]
    fn pgrmt_empty() {
        let s = Pgrmt {
            product_info: None,
            rom_checksum: None,
            receiver_failure: None,
            stored_data: None,
            rtc_lost: None,
            osc_drift: None,
            data_collection: None,
            sensor_temp: None,
            sensor_config: None,
        }
        .to_proprietary_sentence();
        let f = parse_frame(s.trim()).expect("valid");
        let p = Pgrmt::parse(&f.fields).expect("parse");
        assert!(p.product_info.is_none());
        assert!(p.sensor_config.is_none());
    }

    #[test]
    fn pgrmt_encode_roundtrip() {
        let original = Pgrmt {
            product_info: Some("GPS24xd-HVS".to_string()),
            rom_checksum: Some('P'),
            receiver_failure: Some('P'),
            stored_data: Some('R'),
            rtc_lost: Some('R'),
            osc_drift: Some('P'),
            data_collection: Some('C'),
            sensor_temp: Some("25".to_string()),
            sensor_config: Some('S'),
        };
        let sentence = original.to_proprietary_sentence();
        let frame = parse_frame(sentence.trim()).expect("re-parse");
        let parsed = Pgrmt::parse(&frame.fields).expect("parse");
        assert_eq!(original, parsed);
    }

    #[test]
    fn pgrmt_pgrmt_gonmea() {
        let frame = parse_frame("$PGRMT,GPS24xd-HVS VER 2.30,,,,,,,,*10").expect("valid");
        let p = Pgrmt::parse(&frame.fields).expect("parse");
        assert_eq!(p.product_info.as_deref(), Some("GPS24xd-HVS VER 2.30"));
        assert!(p.rom_checksum.is_none());
        assert!(p.sensor_config.is_none());
    }
}