sbf-tools 0.3.0

Septentrio Binary Format (SBF) parser library
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

//! Differential correction blocks (DiffCorrIn)

use crate::error::{SbfError, SbfResult};
use crate::header::SbfHeader;

use super::block_ids;
use super::SbfBlockParse;

// ============================================================================
// DiffCorrIn Block
// ============================================================================

/// DiffCorrIn block (Block ID 5919)
///
/// Incoming RTCM or CMR differential correction message.
#[derive(Debug, Clone)]
pub struct DiffCorrInBlock {
    tow_ms: u32,
    wnc: u16,
    /// Differential mode
    pub mode: u8,
    /// Correction source
    pub source: u8,
    /// Raw message content (RTCM or CMR bytes)
    pub message_content: Vec<u8>,
}

impl DiffCorrInBlock {
    pub fn tow_seconds(&self) -> f64 {
        self.tow_ms as f64 * 0.001
    }
    pub fn tow_ms(&self) -> u32 {
        self.tow_ms
    }
    pub fn wnc(&self) -> u16 {
        self.wnc
    }
}

impl SbfBlockParse for DiffCorrInBlock {
    const BLOCK_ID: u16 = block_ids::DIFF_CORR_IN;

    fn parse(header: &SbfHeader, data: &[u8]) -> SbfResult<Self> {
        const MIN_LEN: usize = 14;
        if data.len() < MIN_LEN {
            return Err(SbfError::ParseError("DiffCorrIn too short".into()));
        }

        let mode = data[12];
        let source = data[13];
        let message_content = data[14..].to_vec();

        Ok(Self {
            tow_ms: header.tow_ms,
            wnc: header.wnc,
            mode,
            source,
            message_content,
        })
    }
}

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

    #[test]
    fn test_diff_corr_in_parse() {
        let header = SbfHeader {
            crc: 0,
            block_id: block_ids::DIFF_CORR_IN,
            block_rev: 0,
            length: 20,
            tow_ms: 5000,
            wnc: 2100,
        };
        let mut data = vec![0u8; 20];
        data[0..2].copy_from_slice(&0u16.to_le_bytes());
        data[2..4].copy_from_slice(&block_ids::DIFF_CORR_IN.to_le_bytes());
        data[4..6].copy_from_slice(&20u16.to_le_bytes());
        data[6..10].copy_from_slice(&5000u32.to_le_bytes());
        data[10..12].copy_from_slice(&2100u16.to_le_bytes());
        data[12] = 1; // mode
        data[13] = 2; // source
        data[14..18].copy_from_slice(&[0xD3, 0x00, 0x13, 0x40]); // sample RTCM prefix

        let block = DiffCorrInBlock::parse(&header, &data).unwrap();
        assert_eq!(block.tow_ms(), 5000);
        assert_eq!(block.wnc(), 2100);
        assert_eq!(block.tow_seconds(), 5.0);
        assert_eq!(block.mode, 1);
        assert_eq!(block.source, 2);
        assert_eq!(block.message_content.len(), 6);
        assert_eq!(block.message_content[0], 0xD3);
    }

    #[test]
    fn test_diff_corr_in_dnu_empty_message() {
        let header = SbfHeader {
            crc: 0,
            block_id: block_ids::DIFF_CORR_IN,
            block_rev: 0,
            length: 14,
            tow_ms: 0,
            wnc: 0,
        };
        let mut data = vec![0u8; 14];
        data[12] = 0;
        data[13] = 0;

        let block = DiffCorrInBlock::parse(&header, &data).unwrap();
        assert!(block.message_content.is_empty());
    }
}