use crate::bits::{BitReader, BitWriter};
use crate::error::BitError;
pub const TYPE: u16 = 1005;
#[allow(
clippy::struct_excessive_bools,
reason = "each bool is an independent single-bit wire flag defined by the RTCM3 spec, not related state"
)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StationArp {
pub reference_station_id: u16,
pub itrf_realization_year: u8,
pub gps_indicator: bool,
pub glonass_indicator: bool,
pub galileo_indicator: bool,
pub reference_station_indicator: bool,
pub ecef_x_raw: i64,
pub single_oscillator_indicator: bool,
pub ecef_y_raw: i64,
pub quarter_cycle_indicator: u8,
pub ecef_z_raw: i64,
}
impl StationArp {
#[must_use]
#[allow(
clippy::cast_precision_loss,
reason = "an i64 holding a 38-bit value converted to f64 loses no precision this raw value ever needs"
)]
pub fn x_meters(&self) -> f64 {
self.ecef_x_raw as f64 * 0.0001
}
#[must_use]
#[allow(clippy::cast_precision_loss, reason = "see x_meters")]
pub fn y_meters(&self) -> f64 {
self.ecef_y_raw as f64 * 0.0001
}
#[must_use]
#[allow(clippy::cast_precision_loss, reason = "see x_meters")]
pub fn z_meters(&self) -> f64 {
self.ecef_z_raw as f64 * 0.0001
}
pub(crate) fn decode(r: &mut BitReader<'_>) -> Result<Self, BitError> {
Ok(Self {
reference_station_id: r.read_u16(12)?,
itrf_realization_year: r.read_u8(6)?,
gps_indicator: r.read_bool()?,
glonass_indicator: r.read_bool()?,
galileo_indicator: r.read_bool()?,
reference_station_indicator: r.read_bool()?,
ecef_x_raw: r.read_i64(38)?,
single_oscillator_indicator: r.read_bool()?,
ecef_y_raw: {
r.skip(1)?; r.read_i64(38)?
},
quarter_cycle_indicator: r.read_u8(2)?,
ecef_z_raw: r.read_i64(38)?,
})
}
pub(crate) fn encode(&self, w: &mut BitWriter<'_>) -> Result<(), BitError> {
w.write_u32(u32::from(self.reference_station_id), 12)?;
w.write_u32(u32::from(self.itrf_realization_year), 6)?;
w.write_bool(self.gps_indicator)?;
w.write_bool(self.glonass_indicator)?;
w.write_bool(self.galileo_indicator)?;
w.write_bool(self.reference_station_indicator)?;
write_i38(w, self.ecef_x_raw)?;
w.write_bool(self.single_oscillator_indicator)?;
w.skip(1)?; write_i38(w, self.ecef_y_raw)?;
w.write_u32(u32::from(self.quarter_cycle_indicator), 2)?;
write_i38(w, self.ecef_z_raw)
}
}
fn write_i38(w: &mut BitWriter<'_>, value: i64) -> Result<(), BitError> {
#[allow(
clippy::cast_sign_loss,
reason = "reinterpreting the two's-complement bit pattern, not a numeric conversion"
)]
let bits = value as u64;
w.write_u64(bits & 0x3F_FFFF_FFFF, 38)
}
#[cfg(test)]
mod tests {
use super::*;
fn hex_decode<const N: usize>(hex: &str) -> [u8; N] {
let mut out = [0u8; N];
for (i, chunk) in hex.as_bytes().chunks(2).enumerate() {
let s = core::str::from_utf8(chunk).unwrap();
out[i] = u8::from_str_radix(s, 16).unwrap();
}
out
}
#[test]
fn decodes_a_real_captured_frame() {
let payload: [u8; 19] = hex_decode("3ed000038a58d9493c872f34109d07d6af4820");
let mut r = BitReader::new(&payload);
let message_type = r.read_u16(12).unwrap();
assert_eq!(message_type, 1005);
let m = StationArp::decode(&mut r).unwrap();
assert_eq!(m.reference_station_id, 0);
assert!(m.gps_indicator);
assert!(m.glonass_indicator);
assert!(m.galileo_indicator);
assert!((m.x_meters() - 4_444_030.802_8).abs() < 1e-3);
assert!((m.y_meters() - 3_085_671.234_9).abs() < 1e-3);
assert!((m.z_meters() - 3_366_658.256).abs() < 1e-3);
}
#[test]
fn round_trips_through_decode() {
let original = StationArp {
reference_station_id: 1234,
itrf_realization_year: 20,
gps_indicator: true,
glonass_indicator: false,
galileo_indicator: true,
reference_station_indicator: false,
ecef_x_raw: -44_440_308_028,
single_oscillator_indicator: true,
ecef_y_raw: 30_856_712_349,
quarter_cycle_indicator: 2,
ecef_z_raw: -33_666_582_560,
};
let mut buf = [0u8; 19];
let mut w = BitWriter::new(&mut buf);
original.encode(&mut w).unwrap();
let mut r = BitReader::new(&buf);
let decoded = StationArp::decode(&mut r).unwrap();
assert_eq!(decoded, original);
}
}