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};

/// ALA — System Faults and Alarms.
///
/// Wire: `time,system,subsystem,instance,alarm_type,condition,ack_state,message`
#[derive(Debug, Clone, PartialEq)]
pub struct Ala {
    /// UTC time of alarm (hhmmss).
    pub time: Option<String>,
    /// System identifier.
    pub system: Option<String>,
    /// Subsystem identifier.
    pub subsystem: Option<String>,
    /// Instance identifier.
    pub instance: Option<String>,
    /// Alarm type code.
    pub alarm_type: Option<String>,
    /// Alarm condition (N=normal, A=alarm, W=warning).
    pub condition: Option<char>,
    /// Acknowledgement state (A=acknowledged, V=not acknowledged).
    pub ack_state: Option<char>,
    /// Alarm message text.
    pub message: Option<String>,
}

impl Ala {
    /// 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 time = r.string();
        let system = r.string();
        let subsystem = r.string();
        let instance = r.string();
        let alarm_type = r.string();
        let condition = r.char();
        let ack_state = r.char();
        let message = r.string();
        Some(Self {
            time,
            system,
            subsystem,
            instance,
            alarm_type,
            condition,
            ack_state,
            message,
        })
    }
}

impl NmeaEncodable for Ala {
    const SENTENCE_TYPE: &str = "ALA";

    fn encode(&self) -> Vec<String> {
        let mut w = FieldWriter::new();
        w.string(self.time.as_deref());
        w.string(self.system.as_deref());
        w.string(self.subsystem.as_deref());
        w.string(self.instance.as_deref());
        w.string(self.alarm_type.as_deref());
        w.char(self.condition);
        w.char(self.ack_state);
        w.string(self.message.as_deref());
        w.finish()
    }
}

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

    #[test]
    fn ala_empty() {
        let s = Ala {
            time: None,
            system: None,
            subsystem: None,
            instance: None,
            alarm_type: None,
            condition: None,
            ack_state: None,
            message: None,
        }
        .to_sentence("FR");
        let f = parse_frame(s.trim()).expect("valid");
        let a = Ala::parse(&f.fields).expect("parse");
        assert!(a.time.is_none());
        assert!(a.system.is_none());
        assert!(a.condition.is_none());
        assert!(a.message.is_none());
    }

    #[test]
    fn ala_encode_roundtrip() {
        let original = Ala {
            time: Some("143955".to_string()),
            system: Some("FR".to_string()),
            subsystem: Some("OT".to_string()),
            instance: Some("00".to_string()),
            alarm_type: Some("901".to_string()),
            condition: Some('N'),
            ack_state: Some('V'),
            message: Some("Test alarm".to_string()),
        };
        let sentence = original.to_sentence("FR");
        let frame = parse_frame(sentence.trim()).expect("re-parse");
        let parsed = Ala::parse(&frame.fields).expect("parse");
        assert_eq!(original, parsed);
    }

    #[test]
    fn ala_frala_gonmea() {
        let f = parse_frame("$FRALA,143955,FR,OT,00,901,N,V,Syst Fault : AutroSafe comm. OK*4F")
            .expect("valid ALA");
        let a = Ala::parse(&f.fields).expect("parse ALA");
        assert_eq!(a.time, Some("143955".to_string()));
        assert_eq!(a.system, Some("FR".to_string()));
        assert_eq!(a.subsystem, Some("OT".to_string()));
        assert_eq!(a.instance, Some("00".to_string()));
        assert_eq!(a.alarm_type, Some("901".to_string()));
        assert_eq!(a.condition, Some('N'));
        assert_eq!(a.ack_state, Some('V'));
        assert_eq!(
            a.message,
            Some("Syst Fault : AutroSafe comm. OK".to_string())
        );
    }
}