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

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

/// OSD — Own Ship Data.
///
/// Wire: `heading,heading_status,vessel_course,course_ref,vessel_speed,speed_ref,vessel_set,vessel_drift,speed_units`
#[derive(Debug, Clone, PartialEq)]
pub struct Osd {
    /// Heading in degrees.
    pub heading: Option<f32>,
    /// Heading status ('A' = valid).
    pub heading_status: Option<char>,
    /// Vessel course in degrees referenced to North.
    pub vessel_course: Option<f32>,
    /// Course reference ('T' = true, 'M' = magnetic, 'W' = water, 'R' = relative).
    pub course_ref: Option<char>,
    /// Vessel speed.
    pub vessel_speed: Option<f32>,
    /// Speed reference ('B' = bottom, 'W' = water, 'R' = relative).
    pub speed_ref: Option<char>,
    /// Vessel set (current direction) in degrees true.
    pub vessel_set: Option<f32>,
    /// Vessel drift (current speed).
    pub vessel_drift: Option<f32>,
    /// Speed units ('N' = knots, 'S' = statute miles/hour, 'K' = km/h).
    pub speed_units: Option<char>,
}

impl Osd {
    /// 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 heading = r.f32();
        let heading_status = r.char();
        let vessel_course = r.f32();
        let course_ref = r.char();
        let vessel_speed = r.f32();
        let speed_ref = r.char();
        let vessel_set = r.f32();
        let vessel_drift = r.f32();
        let speed_units = r.char();
        Some(Self {
            heading,
            heading_status,
            vessel_course,
            course_ref,
            vessel_speed,
            speed_ref,
            vessel_set,
            vessel_drift,
            speed_units,
        })
    }
}

impl NmeaEncodable for Osd {
    const SENTENCE_TYPE: &str = "OSD";

    fn encode(&self) -> Vec<String> {
        let mut w = FieldWriter::new();
        w.f32(self.heading);
        w.char(self.heading_status);
        w.f32(self.vessel_course);
        w.char(self.course_ref);
        w.f32(self.vessel_speed);
        w.char(self.speed_ref);
        w.f32(self.vessel_set);
        w.f32(self.vessel_drift);
        w.char(self.speed_units);
        w.finish()
    }
}

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

    #[test]
    fn osd_empty() {
        let s = Osd {
            heading: None,
            heading_status: None,
            vessel_course: None,
            course_ref: None,
            vessel_speed: None,
            speed_ref: None,
            vessel_set: None,
            vessel_drift: None,
            speed_units: None,
        }
        .to_sentence("RA");
        let f = parse_frame(s.trim()).expect("valid");
        let o = Osd::parse(&f.fields).expect("parse");
        assert!(o.heading.is_none());
        assert!(o.speed_units.is_none());
    }

    #[test]
    fn osd_encode_roundtrip() {
        let original = Osd {
            heading: Some(179.0),
            heading_status: Some('A'),
            vessel_course: Some(179.0),
            course_ref: Some('M'),
            vessel_speed: Some(0.0),
            speed_ref: Some('M'),
            vessel_set: None,
            vessel_drift: None,
            speed_units: Some('N'),
        };
        let sentence = original.to_sentence("RA");
        let frame = parse_frame(sentence.trim()).expect("re-parse");
        let parsed = Osd::parse(&frame.fields).expect("parse");
        assert_eq!(original, parsed);
    }

    #[test]
    fn osd_raosd_gonmea() {
        let frame = parse_frame("$RAOSD,179.0,A,179.0,M,00.0,M,,,N*76").expect("valid");
        let o = Osd::parse(&frame.fields).expect("parse");
        assert!((o.heading.expect("heading") - 179.0).abs() < 0.1);
        assert_eq!(o.heading_status, Some('A'));
        assert_eq!(o.course_ref, Some('M'));
        assert!(o.vessel_set.is_none());
        assert_eq!(o.speed_units, Some('N'));
    }
}