gnss-protos 0.0.1

GNSS protos encoder and decoder
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use super::super::{gps_qzss_bitmask, twos_complement};

const WORD3_CIC_MASK: u32 = 0xffff00;
const WORD3_CIC_SHIFT: u32 = 8; // remaining payload bits
const WORD3_OMEGA0_MASK: u32 = 0x0000ff;
const WORD3_OMEGA0_SHIFT: u32 = 0;

const WORD4_OMEGA0_MASK: u32 = 0xffffff;
const WORD4_OMEGA0_SHIFT: u32 = 0;

const WORD5_CIS_MASK: u32 = 0xffff00;
const WORD5_CIS_SHIFT: u32 = 8;
const WORD5_I0_MASK: u32 = 0x0000ff;
const WORD5_I0_SHIFT: u32 = 0;

const WORD6_I0_MASK: u32 = 0x00ffffff;
const WORD6_I0_SHIFT: u32 = 0;

const WORD7_CRC_MASK: u32 = 0xffff00;
const WORD7_CRC_SHIFT: u32 = 8;
const WORD7_OMEGA_MASK: u32 = 0xff;
const WORD7_OMEGA_SHIFT: u32 = 0;

const WORD8_OMEGA_MASK: u32 = 0xffffff;
const WORD8_OMEGA_SHIFT: u32 = 0;

const WORD9_OMEGADOT_MASK: u32 = 0xffffff;
const WORD9_OMEGADOT_SHIFT: u32 = 0;

const WORD10_IODE_MASK: u32 = 0x3fc000;
const WORD10_IODE_SHIFT: u32 = 14;
const WORD10_IDOT_MASK: u32 = 0x003fff;
const WORD10_IDOT_SHIFT: u32 = 0;

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word3 {
    pub cic: i16,

    /// Omega0 (8) MSB, you will have to associate this to Word #4
    pub omega0_msb: u8,
}

impl GpsUnscaledEph3Word3 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let cic = ((dword & WORD3_CIC_MASK) >> WORD3_CIC_SHIFT) as i16;
        let omega0_msb = ((dword & WORD3_OMEGA0_MASK) >> WORD3_OMEGA0_SHIFT) as u8;
        Self { cic, omega0_msb }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word4 {
    /// Omega0 (24) LSB, you will have to associate this to Word #3
    pub omega0_lsb: u32,
}

impl GpsUnscaledEph3Word4 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let omega0_lsb = ((dword & WORD4_OMEGA0_MASK) >> WORD4_OMEGA0_SHIFT) as u32;
        Self { omega0_lsb }
    }
}
#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word5 {
    pub cis: i16,

    /// I0 (8) MSB, you will have to associate this to Word #6
    pub i0_msb: u8,
}

impl GpsUnscaledEph3Word5 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let cis = ((dword & WORD5_CIS_MASK) >> WORD5_CIS_SHIFT) as i16;
        let i0_msb = ((dword & WORD5_I0_MASK) >> WORD5_I0_SHIFT) as u8;
        Self { cis, i0_msb }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word6 {
    /// I0 (24) LSB, you will have to associate this to Word #5
    pub i0_lsb: u32,
}

impl GpsUnscaledEph3Word6 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let i0_lsb = ((dword & WORD6_I0_MASK) >> WORD6_I0_SHIFT) as u32;
        Self { i0_lsb }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word7 {
    pub crc: i16,

    /// Omega (8) MSB, you will have to associate this to Word #8
    pub omega_msb: u8,
}

impl GpsUnscaledEph3Word7 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let crc = ((dword & WORD7_CRC_MASK) >> WORD7_CRC_SHIFT) as i16;
        let omega_msb = ((dword & WORD7_OMEGA_MASK) >> WORD7_OMEGA_SHIFT) as u8;
        Self { crc, omega_msb }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word8 {
    /// Omega (24) LSB, you will have to associate this to Word #7
    pub omega_lsb: u32,
}

impl GpsUnscaledEph3Word8 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let omega_lsb = ((dword & WORD8_OMEGA_MASK) >> WORD8_OMEGA_SHIFT) as u32;
        Self { omega_lsb }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word9 {
    // 24-bit Omega_dot
    pub omega_dot: i32,
}

impl GpsUnscaledEph3Word9 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword);
        let omega_dot = ((dword & WORD9_OMEGADOT_MASK) >> WORD9_OMEGADOT_SHIFT) as u32;
        let omega_dot = twos_complement(omega_dot, 0xffffff, 0x800000);
        Self { omega_dot }
    }
}

#[derive(Debug, Default, Clone)]
pub struct GpsUnscaledEph3Word10 {
    /// 8-bit IODE
    pub iode: u8,

    /// 14-bit IDOT
    pub idot: i32,
}

impl GpsUnscaledEph3Word10 {
    pub(crate) fn decode(dword: u32) -> Self {
        let dword = gps_qzss_bitmask(dword) >> 2;
        let iode = ((dword & WORD10_IODE_MASK) >> WORD10_IODE_SHIFT) as u8;

        // 14-bit signed 2's
        let idot = ((dword & WORD10_IDOT_MASK) >> WORD10_IDOT_SHIFT) as u32;
        let idot = twos_complement(idot, 0x3fff, 0x2000);

        Self { iode, idot }
    }
}