Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cats/ham-cats
  • sam/ham-cats
  • Quantum_P/ham-cats
  • Reed/ham-cats
4 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 2022 additions and 663 deletions
src/whisker.rs deleted 100644 → 0
View file @ 3b626f1d
use core::str::FromStr;
use arrayvec::{ArrayString, ArrayVec};
use half::f16;
pub enum Whisker {
Identification(Identification),
Timestamp(Timestamp),
Gps(Gps),
Comment(Comment),
Route(Route),
Destination(Destination),
}
#[derive(Debug, PartialEq, Eq)]
pub struct Identification {
pub callsign: ArrayString<254>,
pub ssid: u8,
}
impl Identification {
pub fn new(call: &str, ssid: u8) -> Option<Self> {
let callsign = ArrayString::from(call).ok()?;
Some(Self { callsign, ssid })
}
/// Returns none if there is not enough space in the buffer
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
// safe to unwrap because we know the length is <= 254
let len: u8 = self.callsign.as_bytes().len().try_into().unwrap();
*buf.get_mut(0)? = len + 1;
let mut len = 1;
for (i, b) in self.callsign.as_bytes().iter().enumerate() {
*buf.get_mut(i + 1)? = *b;
len += 1
}
*buf.get_mut(len)? = self.ssid;
len += 1;
Some(&buf[0..len])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len = (*data.first()?).into();
let callsign = core::str::from_utf8(data.get(1..len)?).ok()?;
let callsign = ArrayString::from(callsign).ok()?;
let ssid = *data.get(len)?;
Some(Self { callsign, ssid })
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Timestamp(u64);
impl Timestamp {
/// Returns none if the given unix timestamp doesn't fit in 5 bytes
pub fn new(unix_time: u64) -> Option<Self> {
// must fit in 5 bytes
if unix_time > (1 << (5 * 8)) - 1 {
return None;
}
Some(Self(unix_time))
}
pub fn unix_time(&self) -> u64 {
self.0
}
/// Returns none if there is not enough space in the buffer
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
if buf.len() < 6 {
return None;
}
buf[0] = 5;
buf[1..6].copy_from_slice(&self.0.to_le_bytes()[0..5]);
Some(&buf[0..6])
}
pub fn decode(data: &[u8]) -> Option<Self> {
if data.len() < 6 {
return None;
}
if data[0] != 5 {
return None;
}
let mut extended_data = [0; 8];
extended_data[0..5].copy_from_slice(&data[1..6]);
Some(Self(u64::from_le_bytes(extended_data)))
}
}
#[derive(Debug, PartialEq)]
pub struct Gps {
latitude: i32,
longitude: i32,
pub altitude: f16,
pub max_error: u8,
heading: u8,
pub speed: f16,
}
impl Gps {
/// Constructs a new GPS whisker.
///
/// latitude: degrees
/// longitude: degrees
/// altitude: meters
/// max_error: maximum error distance from specified lat/lon/alt, meters
/// heading: direction relative to north, degrees
/// speed: meters per second
pub fn new(
latitude: f64,
longitude: f64,
altitude: f16,
max_error: u8,
heading: f64,
speed: f16,
) -> Self {
let latitude = latitude.clamp(-89.999, 89.999);
let latitude = (latitude * ((1u32 << 31) as f64) / 90.0) as i32;
let longitude = longitude.clamp(-179.999, 179.999);
let longitude = (longitude * ((1u32 << 31) as f64) / 180.0) as i32;
let heading = heading.clamp(0.0, 359.999);
let heading = (heading * 128.0 / 360.0) as u8;
Self {
latitude,
longitude,
altitude,
max_error,
heading,
speed,
}
}
pub fn latitude(&self) -> f64 {
(self.latitude as f64) / (1u32 << 31) as f64 * 90.0
}
pub fn longitude(&self) -> f64 {
(self.longitude as f64) / (1u32 << 31) as f64 * 180.0
}
pub fn heading(&self) -> f64 {
self.heading as f64 / 128.0 * 360.0
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let buf = buf.get_mut(0..15)?;
buf[0] = 14;
buf[1..5].copy_from_slice(&self.latitude.to_le_bytes());
buf[5..9].copy_from_slice(&self.longitude.to_le_bytes());
buf[9..11].copy_from_slice(&self.altitude.to_le_bytes());
buf[11] = self.max_error;
buf[12] = self.heading;
buf[13..15].copy_from_slice(&self.speed.to_le_bytes());
Some(buf)
}
pub fn decode(data: &[u8]) -> Option<Self> {
let data = data.get(0..15)?;
if data[0] != 14 {
return None;
}
let latitude = i32::from_le_bytes(data[1..5].try_into().unwrap());
let longitude = i32::from_le_bytes(data[5..9].try_into().unwrap());
let altitude = f16::from_le_bytes(data[9..11].try_into().unwrap());
let max_error = data[11];
let heading = data[12];
let speed = f16::from_le_bytes(data[13..15].try_into().unwrap());
Some(Self {
latitude,
longitude,
altitude,
max_error,
heading,
speed,
})
}
}
pub struct Comment(ArrayVec<u8, 255>);
impl Comment {
pub fn new(data: &[u8]) -> Option<Self> {
let mut av = ArrayVec::new();
av.try_extend_from_slice(data).ok()?;
Some(Self(av))
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let len = self.0.len();
// length must be <= 255, so this is safe
*buf.get_mut(0)? = len.try_into().unwrap();
buf.get_mut(1..(len + 1))?.copy_from_slice(&self.0);
Some(&buf[0..(len + 1)])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len: usize = (*data.first()?).into();
let content = data.get(1..(len + 1))?;
Self::new(content)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Route {
pub max_hops: u8,
path: ArrayVec<u8, 254>,
has_future: bool,
}
impl Route {
pub fn new(max_hops: u8) -> Self {
let path = ArrayVec::new();
Self {
max_hops,
path,
has_future: false,
}
}
/// Returns `None` if there isn't enough space for the callsign
/// Returns `None` if attempting to pushed is_used=true after an existing is_used=false
/// is_future=false when this callsign has digipeated
/// is_future=true when this callsign is expected to be part of the route, but isn't yet
/// see the specs for more information
pub fn push_callsign(&mut self, callsign: &str, ssid: u8, is_future: bool) -> Option<()> {
let len = callsign.as_bytes().len() + 2;
let free_space = self.path.capacity() - self.path.len();
if len > free_space {
return None;
}
self.has_future = self.has_future || is_future;
if self.has_future && !is_future {
return None;
}
// safe to unwrap since we already did a length check
self.path
.try_extend_from_slice(callsign.as_bytes())
.unwrap();
self.path.push(if is_future { 0xFD } else { 0xFF });
self.path.push(ssid);
Some(())
}
/// Returns `None` if there isn't enough space
pub fn push_internet(&mut self) -> Option<()> {
let free_space = self.path.capacity() - self.path.len();
if free_space < 1 {
return None;
}
self.path.push(0xFE);
Some(())
}
pub fn iter(&'_ self) -> RouteIter<'_> {
RouteIter::new(self)
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let packet_len = self.path.len() + 1;
let buf = buf.get_mut(0..(packet_len + 1))?;
buf[0] = packet_len.try_into().unwrap();
buf[1] = self.max_hops;
buf[2..(packet_len + 1)].copy_from_slice(&self.path);
Some(buf)
}
// TODO reject packets that have a 0xFF anywhere after an FD
pub fn decode(data: &[u8]) -> Option<Self> {
let len: usize = (*data.first()?).into();
let data = data.get(1..(len + 1))?;
let max_hops = data[0];
let mut path = ArrayVec::new();
path.try_extend_from_slice(&data[1..]).unwrap();
let has_future = data[1..].iter().any(|x| *x == 0xFD);
Some(Self {
max_hops,
path,
has_future,
})
}
}
#[derive(Debug, Eq, PartialEq)]
pub enum RouteNode<'a> {
Internet,
Identity(&'a str, u8, bool),
}
#[derive(Debug)]
pub struct RouteIter<'a> {
route: &'a Route,
i: usize,
}
impl<'a> RouteIter<'a> {
fn new(route: &'a Route) -> Self {
Self { route, i: 0 }
}
}
impl<'a> Iterator for RouteIter<'a> {
type Item = RouteNode<'a>;
fn next(&mut self) -> Option<Self::Item> {
if self.i == self.route.path.len() {
return None;
}
let i_start = self.i;
self.i += 1;
if self.route.path[i_start] == 0xFE {
return Some(RouteNode::Internet);
}
while self.route.path[self.i] != 0xFD && self.route.path[self.i] != 0xFF {
self.i += 1;
}
let callsign = core::str::from_utf8(&self.route.path[i_start..self.i]).unwrap();
let is_future = self.route.path[self.i] == 0xFD;
self.i += 1;
let ssid = self.route.path[self.i];
self.i += 1;
Some(RouteNode::Identity(callsign, ssid, is_future))
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Destination {
ack: u8,
callsign: ArrayString<253>,
ssid: u8,
}
impl Destination {
/// Returns none if the ack number is > 127
/// Returns none if the dest callsign is too long
/// Returns none is is_ack is true and ack_num is 0
pub fn new(is_ack: bool, ack_num: u8, dest_callsign: &str, dest_ssid: u8) -> Option<Self> {
if ack_num > 127 {
return None;
}
if is_ack && ack_num == 0 {
return None;
}
let ack = if is_ack { (1 << 7) | ack_num } else { ack_num };
let callsign = ArrayString::from_str(dest_callsign).ok()?;
let ssid = dest_ssid;
Some(Self {
ack,
callsign,
ssid,
})
}
pub fn is_ack(&self) -> bool {
self.ack & (1 << 7) > 0
}
pub fn ack_num(&self) -> u8 {
self.ack
}
pub fn callsign(&self) -> &str {
self.callsign.as_str()
}
pub fn ssid(&self) -> u8 {
self.ssid
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let n = self.callsign.len() + 2;
*buf.get_mut(0)? = n.try_into().unwrap();
*buf.get_mut(1)? = self.ack;
buf.get_mut(2..n)?.copy_from_slice(self.callsign.as_bytes());
*buf.get_mut(n)? = self.ssid;
Some(&buf[0..(n + 1)])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let n = data.first()?;
let call_length: usize = n.checked_sub(2)?.into();
let ack = *data.get(1)?;
if ack == 0b10000000 {
// is_ack is true and # is 0
return None;
}
let callsign = core::str::from_utf8(data.get(2..(call_length + 2))?).ok()?;
let callsign = ArrayString::from_str(callsign).ok()?;
let ssid = *data.get(call_length + 2)?;
Some(Self {
ack,
callsign,
ssid,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ident_e2e() {
let call = "VE9ABCDEFGZZ4839-???";
let ssid = 17;
let ident = Identification::new(call, ssid).unwrap();
let mut buf = [0; 256];
let encoded = ident.encode(&mut buf).unwrap();
let decoded = Identification::decode(encoded).unwrap();
assert_eq!(ident, decoded);
assert_eq!(call, &decoded.callsign);
assert_eq!(ssid, decoded.ssid);
}
#[test]
fn new_timestamp() {
let t = 34894;
assert_eq!(t, Timestamp::new(t).unwrap().unix_time());
let t = 1 << (5 * 8);
assert_eq!(None, Timestamp::new(t));
}
#[test]
fn timestamp_e2e() {
let t = 34894;
let timestamp = Timestamp::new(t).unwrap();
let mut buf = [0; 256];
let encoded = timestamp.encode(&mut buf).unwrap();
let decoded = Timestamp::decode(encoded).unwrap();
assert_eq!(timestamp, decoded);
assert_eq!(t, timestamp.unix_time());
}
#[test]
fn new_gps() {
let gps = Gps::new(
90.0,
-180.0,
f16::from_f32(45.02),
24,
123.45,
f16::from_f32(12.3),
);
assert_eq!(89.99899999704212, gps.latitude());
assert_eq!(-179.9989999551326, gps.longitude());
assert_eq!(120.9375, gps.heading());
}
#[test]
fn gps_max_heading() {
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
360.0,
f16::from_f32(12.3),
);
assert_eq!(357.1875, gps.heading());
}
#[test]
fn gps_e2e() {
let gps = Gps::new(
90.0,
-180.0,
f16::from_f32(45.02),
24,
123.45,
f16::from_f32(12.3),
);
let mut buf = [0; 256];
let encoded = gps.encode(&mut buf).unwrap();
let decoded = Gps::decode(encoded).unwrap();
assert_eq!(gps, decoded);
}
#[test]
fn comment_e2e() {
let data = b"Hello world! This is an example comment";
let comment = Comment::new(data).unwrap();
let mut buf = [0; 256];
let encoded = comment.encode(&mut buf).unwrap();
let decoded = Comment::decode(encoded).unwrap();
let decoded2 = Comment::decode(&buf).unwrap();
assert_eq!(data[..], decoded.0[..]);
assert_eq!(data[..], decoded2.0[..]);
}
#[test]
fn route_push_and_iter() {
let mut route = Route::new(34);
route.push_callsign("VE2XYZ", 23, false).unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_callsign("VE9AAAAA", 94, true).unwrap();
assert!(route.push_callsign("VE9AAAAA", 94, false).is_none());
// too long
assert!(route
.push_callsign(
"lsdfjslkdfjlksdjflksfjsdklfjsdklfjsdklfjsdklfjsklfsef;jklsdfjkl;sdf;klsdf;klsjdfJSDJFSKL:DFJDSL:KFskldfj;slkdfjsdkl;fjdskl;fjsdfl;kjsdfl;ksdjfkl;ssdfl;kjsdfl;ksdjf;sdklsd;lfkjsdlfk;jsdl;fkjsd;klfjsd;fljsf;oidfjgwper0tujdfgndfjkl;gjnergjol;kehfgo;dijge;oghdfkl;gjdfkl;gjdeior;lgjedr;ioghjdorighndeklo;grjiop[",
20,
true,
).is_none());
route
.push_callsign("This is the last callsign", 0, true)
.unwrap();
route.push_internet().unwrap();
let mut iter = route.iter();
assert_eq!(
RouteNode::Identity("VE2XYZ", 23, false),
iter.next().unwrap()
);
assert_eq!(RouteNode::Internet, iter.next().unwrap());
assert_eq!(RouteNode::Internet, iter.next().unwrap());
assert_eq!(RouteNode::Internet, iter.next().unwrap());
assert_eq!(
RouteNode::Identity("VE9AAAAA", 94, true),
iter.next().unwrap()
);
assert_eq!(
RouteNode::Identity("This is the last callsign", 0, true),
iter.next().unwrap()
);
assert_eq!(RouteNode::Internet, iter.next().unwrap());
assert_eq!(None, iter.next());
assert_eq!(34, route.max_hops);
}
#[test]
fn route_e2e() {
let mut route = Route::new(34);
route.push_callsign("VE2XYZ", 23, false).unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_callsign("VE9AAAAA", 94, true).unwrap();
route
.push_callsign("This is the last callsign", 0, true)
.unwrap();
route.push_internet().unwrap();
let mut buf = [0; 256];
let encoded = route.encode(&mut buf).unwrap();
let decoded = Route::decode(encoded).unwrap();
assert_eq!(route, decoded);
}
// verify examples in the standard doc
#[test]
fn route_doc_examples() {
let mut ex1 = Route::new(4);
ex1.push_callsign("VE1ABC", 0, false);
ex1.push_callsign("VE2DEF", 234, false);
ex1.push_callsign("VE3XYZ", 14, false);
let mut buf = [0; 256];
let encoded = ex1.encode(&mut buf).unwrap();
assert_eq!(
&[
0x19, 0x04, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0x56, 0x45, 0x32, 0x44,
0x45, 0x46, 0xFF, 0xEA, 0x56, 0x45, 0x33, 0x58, 0x59, 0x5A, 0xFF, 0x0E
],
&encoded
);
let mut ex2 = Route::new(3);
ex2.push_callsign("VE1ABC", 0, false);
ex2.push_internet();
ex2.push_callsign("VE2DEF", 234, false);
ex2.push_internet();
ex2.push_callsign("VE3XYZ", 14, false);
let encoded = ex2.encode(&mut buf).unwrap();
assert_eq!(
&[
0x1B, 0x03, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0xFE, 0x56, 0x45, 0x32,
0x44, 0x45, 0x46, 0xFF, 0xEA, 0xFE, 0x56, 0x45, 0x33, 0x58, 0x59, 0x5A, 0xFF, 0x0E
],
&encoded
);
let mut ex3 = Route::new(0);
ex3.push_callsign("VE1ABC", 0, false);
ex3.push_internet();
ex3.push_internet();
let encoded = ex3.encode(&mut buf).unwrap();
assert_eq!(
&[0x0B, 0x00, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0xFE, 0xFE],
&encoded
);
}
#[test]
fn dest_e2e() {
assert_eq!(None, Destination::new(true, 0, "dest", 36));
assert_eq!(None, Destination::new(false, 128, "abc", 0));
assert!(Destination::new(false, 0, "anc", 8).is_some());
let dest = Destination::new(true, 64, "mrow", 31).unwrap();
let mut buf = [0; 256];
let encoded = dest.encode(&mut buf).unwrap();
let decoded = Destination::decode(encoded).unwrap();
assert_eq!(dest, decoded);
}
}
src/whisker/arbitrary.rs 0 → 100644
View file @ 9a18248f
use arrayvec::ArrayVec;
#[derive(Debug, Clone)]
pub struct Arbitrary(pub ArrayVec<u8, 255>);
impl Arbitrary {
pub fn new(data: &[u8]) -> Option<Self> {
let mut av = ArrayVec::new();
av.try_extend_from_slice(data).ok()?;
Some(Self(av))
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let len = self.0.len();
// length must be <= 255, so this is safe
*buf.get_mut(0)? = len.try_into().unwrap();
buf.get_mut(1..(len + 1))?.copy_from_slice(&self.0);
Some(&buf[0..(len + 1)])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len: usize = (*data.first()?).into();
let content = data.get(1..(len + 1))?;
Self::new(content)
}
}
src/whisker/comment.rs 0 → 100644
View file @ 9a18248f
use arrayvec::ArrayVec;
#[derive(Debug)]
pub struct Comment(ArrayVec<u8, 255>);
impl Comment {
pub fn new(data: &[u8]) -> Option<Self> {
let mut av = ArrayVec::new();
av.try_extend_from_slice(data).ok()?;
Some(Self(av))
}
pub fn internal_data(&self) -> &ArrayVec<u8, 255> {
&self.0
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let len = self.0.len();
// length must be <= 255, so this is safe
*buf.get_mut(0)? = len.try_into().unwrap();
buf.get_mut(1..(len + 1))?.copy_from_slice(&self.0);
Some(&buf[0..(len + 1)])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len: usize = (*data.first()?).into();
let content = data.get(1..(len + 1))?;
Self::new(content)
}
}
src/whisker/destination.rs 0 → 100644
View file @ 9a18248f
use core::str::FromStr;
use arrayvec::ArrayString;
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Destination {
ack: u8,
callsign: ArrayString<253>,
ssid: u8,
}
impl Destination {
/// Returns none if the ack number is > 127
/// Returns none if the dest callsign is too long
/// Returns none is is_ack is true and ack_num is 0
pub fn new(is_ack: bool, ack_num: u8, dest_callsign: &str, dest_ssid: u8) -> Option<Self> {
if ack_num > 127 {
return None;
}
if is_ack && ack_num == 0 {
return None;
}
let ack = if is_ack { (1 << 7) | ack_num } else { ack_num };
let callsign = ArrayString::from_str(dest_callsign).ok()?;
let ssid = dest_ssid;
Some(Self {
ack,
callsign,
ssid,
})
}
pub fn is_ack(&self) -> bool {
self.ack & (1 << 7) > 0
}
pub fn ack_num(&self) -> u8 {
self.ack & !(1 << 7)
}
pub fn callsign(&self) -> &str {
self.callsign.as_str()
}
pub fn ssid(&self) -> u8 {
self.ssid
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let n = self.callsign.len() + 2;
*buf.get_mut(0)? = n.try_into().unwrap();
*buf.get_mut(1)? = self.ack;
buf.get_mut(2..n)?.copy_from_slice(self.callsign.as_bytes());
*buf.get_mut(n)? = self.ssid;
Some(&buf[0..(n + 1)])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let n = data.first()?;
let call_length: usize = n.checked_sub(2)?.into();
let ack = *data.get(1)?;
if ack == 0b10000000 {
// is_ack is true and # is 0
return None;
}
let callsign = core::str::from_utf8(data.get(2..(call_length + 2))?).ok()?;
let callsign = ArrayString::from_str(callsign).ok()?;
let ssid = *data.get(call_length + 2)?;
Some(Self {
ack,
callsign,
ssid,
})
}
}
src/whisker/gps.rs 0 → 100644
View file @ 9a18248f
use core::fmt::{Debug, Display};
use half::f16;
#[derive(PartialEq, Clone)]
pub struct Gps {
latitude: i32,
longitude: i32,
pub altitude: f16,
pub max_error: u8,
heading: u8,
pub speed: f16,
}
impl Gps {
/// Constructs a new GPS whisker.
///
/// latitude: degrees
/// longitude: degrees
/// altitude: meters
/// max_error: maximum error distance from specified lat/lon/alt, meters
/// heading: direction relative to north, degrees
/// speed: meters per second
pub fn new(
latitude: f64,
longitude: f64,
altitude: f16,
max_error: u8,
heading: f64,
speed: f16,
) -> Self {
let latitude = latitude.clamp(-89.999, 89.999);
let latitude = (latitude * ((1u32 << 31) as f64) / 90.0) as i32;
let longitude = longitude.clamp(-179.999, 179.999);
let longitude = (longitude * ((1u32 << 31) as f64) / 180.0) as i32;
let heading = if heading >= 0.0 {
heading % 360.0
} else {
// slightly hacky no-std floor
let factor = (-heading / 360.0) as u32 as f64;
360.0 * (1.0 + factor) + heading
};
let heading = round(heading * 128.0 / 180.0) as u8;
Self {
latitude,
longitude,
altitude,
max_error,
heading,
speed,
}
}
pub fn latitude(&self) -> f64 {
(self.latitude as f64) / (1u32 << 31) as f64 * 90.0
}
pub fn longitude(&self) -> f64 {
(self.longitude as f64) / (1u32 << 31) as f64 * 180.0
}
pub fn heading(&self) -> f64 {
self.heading as f64 / 128.0 * 180.0
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let buf = buf.get_mut(0..15)?;
buf[0] = 14;
buf[1..5].copy_from_slice(&self.latitude.to_le_bytes());
buf[5..9].copy_from_slice(&self.longitude.to_le_bytes());
buf[9..11].copy_from_slice(&self.altitude.to_le_bytes());
buf[11] = self.max_error;
buf[12] = self.heading;
buf[13..15].copy_from_slice(&self.speed.to_le_bytes());
Some(buf)
}
pub fn decode(data: &[u8]) -> Option<Self> {
let data = data.get(0..15)?;
if data[0] != 14 {
return None;
}
let latitude = i32::from_le_bytes(data[1..5].try_into().unwrap());
let longitude = i32::from_le_bytes(data[5..9].try_into().unwrap());
let altitude = f16::from_le_bytes(data[9..11].try_into().unwrap());
let max_error = data[11];
let heading = data[12];
let speed = f16::from_le_bytes(data[13..15].try_into().unwrap());
Some(Self {
latitude,
longitude,
altitude,
max_error,
heading,
speed,
})
}
}
impl Debug for Gps {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Gps")
.field("latitude", &DebugUnits(self.latitude(), "°"))
.field("longitude", &DebugUnits(self.longitude(), "°"))
.field("altitude", &DebugUnits(self.altitude, " m"))
.field("max_error", &DebugUnits(self.max_error, " m"))
.field("heading", &DebugUnits(self.heading(), "°"))
.field("speed", &DebugUnits(self.speed, " m/s"))
.finish()
}
}
struct DebugUnits<'a, T>(T, &'a str);
impl<T: Display> Debug for DebugUnits<'_, T> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}{}", self.0, self.1)
}
}
// no-std and it's not worth bringing in a library for this
fn round(v: f64) -> u32 {
let floor = v as u32;
let delta = v - floor as f64;
if delta <= 0.5 {
floor
} else {
floor + 1
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn heading_is_correct() {
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 359.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 255);
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 0.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 0);
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, -20.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 242);
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 719.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 255);
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 180.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 128);
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 540.0, f16::from_f32(0.0));
assert_eq!(gps.heading, 128);
}
#[test]
fn debug_printing() {
let gps = Gps::new(0.0, 0.0, f16::from_f32(0.0), 0, 359.0, f16::from_f32(0.0));
let x = format!("{gps:?}");
assert_eq!(x,"Gps { latitude: 0°, longitude: 0°, altitude: 0 m, max_error: 0 m, heading: 358.59375°, speed: 0 m/s }")
}
}
src/whisker/identification.rs 0 → 100644
View file @ 9a18248f
use arrayvec::ArrayString;
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Identification {
pub callsign: ArrayString<252>,
pub ssid: u8,
pub icon: u16,
}
impl Identification {
pub fn new(call: &str, ssid: u8, icon: u16) -> Option<Self> {
let callsign = ArrayString::from(call).ok()?;
Some(Self {
icon,
callsign,
ssid,
})
}
/// Returns none if there is not enough space in the buffer
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
// safe to unwrap because we know the length is <= 252
let len: u8 = self.callsign.as_bytes().len().try_into().unwrap();
*buf.get_mut(0)? = len + 3;
buf.get_mut(1..3)?.copy_from_slice(&self.icon.to_le_bytes());
let mut len = 3;
for (i, b) in self.callsign.as_bytes().iter().enumerate() {
*buf.get_mut(i + 3)? = *b;
len += 1
}
*buf.get_mut(len)? = self.ssid;
len += 1;
Some(&buf[0..len])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len = (*data.first()?).into();
let icon = u16::from_le_bytes([*data.get(1)?, *data.get(2)?]);
let callsign = core::str::from_utf8(data.get(3..len)?).ok()?;
let callsign = ArrayString::from(callsign).ok()?;
let ssid = *data.get(len)?;
Some(Self {
icon,
callsign,
ssid,
})
}
}
src/whisker/mod.rs 0 → 100644
View file @ 9a18248f
mod arbitrary;
mod comment;
mod destination;
mod gps;
mod identification;
mod node_info;
mod route;
mod timestamp;
mod unknown;
use crate::error::DecodeError;
pub use self::{
arbitrary::Arbitrary,
comment::Comment,
destination::Destination,
gps::Gps,
identification::Identification,
node_info::{NodeInfo, NodeInfoBuilder},
route::{PastHop, Route, RouteHop, RouteIter},
timestamp::Timestamp,
unknown::Unknown,
};
pub(crate) const IDENTIFICATION_TYPE: u8 = 0x00;
pub(crate) const TIMESTAMP_TYPE: u8 = 0x01;
pub(crate) const GPS_TYPE: u8 = 0x02;
pub(crate) const COMMENT_TYPE: u8 = 0x03;
pub(crate) const ROUTE_TYPE: u8 = 0x04;
pub(crate) const DESTINATION_TYPE: u8 = 0x05;
pub(crate) const ARBITRARY_TYPE: u8 = 0x06;
pub(crate) const NODE_INFO_TYPE: u8 = 0x09;
#[derive(Debug)]
pub enum Whisker {
Identification(Identification),
Timestamp(Timestamp),
Gps(Gps),
Comment(Comment),
Route(Route),
Destination(Destination),
Arbitrary(Arbitrary),
NodeInfo(NodeInfo),
Unknown(Unknown),
}
pub struct WhiskerIter<'a> {
data: &'a [u8],
i: usize,
// for detecting duplicates
has_ident: bool,
has_timestamp: bool,
has_gps: bool,
has_route: bool,
}
impl<'a> WhiskerIter<'a> {
pub fn new(data: &'a [u8]) -> Self {
Self {
data,
i: 0,
has_ident: false,
has_timestamp: false,
has_gps: false,
has_route: false,
}
}
fn decode(&mut self) -> Result<Whisker, DecodeError> {
let position = self.i;
let t = *self
.data
.get(self.i)
.ok_or(DecodeError::UnexpectedEndOfInput)?;
let len = usize::from(
*self
.data
.get(self.i + 1)
.ok_or(DecodeError::UnexpectedEndOfInput)?,
);
let data = self
.data
.get((self.i + 1)..(self.i + 2 + len))
.ok_or(DecodeError::UnexpectedEndOfInput)?;
self.i += len + 2;
let out = match t {
IDENTIFICATION_TYPE => {
if self.has_ident {
return Err(DecodeError::DuplicateWhisker { position });
}
self.has_ident = true;
Whisker::Identification(
Identification::decode(data)
.ok_or(DecodeError::MalformedWhisker { position })?,
)
}
TIMESTAMP_TYPE => {
if self.has_timestamp {
return Err(DecodeError::DuplicateWhisker { position });
}
self.has_timestamp = true;
Whisker::Timestamp(
Timestamp::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
)
}
GPS_TYPE => {
if self.has_gps {
return Err(DecodeError::DuplicateWhisker { position });
}
self.has_gps = true;
Whisker::Gps(Gps::decode(data).ok_or(DecodeError::MalformedWhisker { position })?)
}
COMMENT_TYPE => Whisker::Comment(
Comment::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
),
ROUTE_TYPE => {
if self.has_route {
return Err(DecodeError::DuplicateWhisker { position });
}
self.has_route = true;
Whisker::Route(
Route::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
)
}
DESTINATION_TYPE => Whisker::Destination(
Destination::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
),
ARBITRARY_TYPE => Whisker::Arbitrary(
Arbitrary::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
),
NODE_INFO_TYPE => Whisker::NodeInfo(
NodeInfo::decode(data).ok_or(DecodeError::MalformedWhisker { position })?,
),
// safe to unwrap because we know len has to be 255 or less, since it's a u8
whisker_type => {
Whisker::Unknown(Unknown::new(whisker_type, data[1..].try_into().unwrap()))
}
};
Ok(out)
}
}
impl Iterator for WhiskerIter<'_> {
type Item = Result<Whisker, DecodeError>;
fn next(&mut self) -> Option<Self::Item> {
if self.i == self.data.len() {
return None;
}
Some(self.decode())
}
}
pub struct ValidatedWhiskerIter<'a> {
iter: WhiskerIter<'a>,
}
impl<'a> ValidatedWhiskerIter<'a> {
pub(crate) fn new(data: &'a [u8]) -> Self {
Self {
iter: WhiskerIter::new(data),
}
}
}
impl Iterator for ValidatedWhiskerIter<'_> {
type Item = Whisker;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|w| w.unwrap())
}
}
#[cfg(test)]
mod tests {
use half::f16;
use crate::{
identity::Identity,
whisker::route::{PastHop, RouteHop},
};
use super::*;
#[test]
fn ident_e2e() {
let icon = 2738;
let call = "VE9ABCDEFGZZ4839-???";
let ssid = 17;
let ident = Identification::new(call, ssid, icon).unwrap();
let mut buf = [0; 256];
let encoded = ident.encode(&mut buf).unwrap();
let decoded = Identification::decode(encoded).unwrap();
assert_eq!(ident, decoded);
assert_eq!(call, &decoded.callsign);
assert_eq!(ssid, decoded.ssid);
}
#[test]
fn new_timestamp() {
let t = 34894;
assert_eq!(t, Timestamp::new(t).unwrap().unix_time());
let t = 1 << (5 * 8);
assert_eq!(None, Timestamp::new(t));
}
#[test]
fn timestamp_e2e() {
let t = 34894;
let timestamp = Timestamp::new(t).unwrap();
let mut buf = [0; 256];
let encoded = timestamp.encode(&mut buf).unwrap();
let decoded = Timestamp::decode(encoded).unwrap();
assert_eq!(timestamp, decoded);
assert_eq!(t, timestamp.unix_time());
}
#[test]
fn new_gps() {
let gps = Gps::new(
90.0,
-180.0,
f16::from_f32(45.02),
24,
123.45,
f16::from_f32(12.3),
);
assert_eq!(89.99899999704212, gps.latitude());
assert_eq!(-179.9989999551326, gps.longitude());
assert_eq!(123.75, gps.heading());
}
#[test]
fn gps_max_heading() {
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
359.0,
f16::from_f32(12.3),
);
assert_eq!(358.59375, gps.heading());
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
957.47,
f16::from_f32(12.3),
);
assert_eq!(957.65625 - 360.0 * 2.0, gps.heading());
}
#[test]
fn gps_min_heading() {
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
0.0,
f16::from_f32(12.3),
);
assert_eq!(0.0, gps.heading());
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
-22.0,
f16::from_f32(12.3),
);
assert_eq!(337.5, gps.heading());
let gps = Gps::new(
4.0,
23.45,
f16::from_f32(45.02),
24,
-1206.0,
f16::from_f32(12.3),
);
assert_eq!(233.4375, gps.heading());
}
#[test]
fn gps_e2e() {
let gps = Gps::new(
90.0,
-180.0,
f16::from_f32(45.02),
24,
123.45,
f16::from_f32(12.3),
);
let mut buf = [0; 256];
let encoded = gps.encode(&mut buf).unwrap();
let decoded = Gps::decode(encoded).unwrap();
assert_eq!(gps, decoded);
}
#[test]
fn comment_e2e() {
let data = b"Hello world! This is an example comment";
let comment = Comment::new(data).unwrap();
let mut buf = [0; 256];
let encoded = comment.encode(&mut buf).unwrap();
let decoded = Comment::decode(encoded).unwrap();
let decoded2 = Comment::decode(&buf).unwrap();
assert_eq!(data[..], decoded.internal_data()[..]);
assert_eq!(data[..], decoded2.internal_data()[..]);
}
#[test]
fn route_push_and_iter() {
let mut route = Route::new(34);
route
.push_past(PastHop::new(Identity::new("VE2XYZ", 23), None))
.unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_future(Identity::new("VE9AAAAA", 94)).unwrap();
// past after future - not allowed
assert!(route
.push_past(PastHop::new(Identity::new("VE9AAAAA", 94), None))
.is_none());
// too long
assert!(route
.push_future(Identity::new(
"lsdfjslkdfjlksdjflksfjsdklfjsdklfjsdklfjsdklfjsklfsef;jklsdfjkl;sdf;klsdf;klsjdfJSDJFSKL:DFJDSL:KFskldfj;slkdfjsdkl;fjdskl;fjsdfl;kjsdfl;ksdjfkl;ssdfl;kjsdfl;ksdjf;sdklsd;lfkjsdlfk;jsdl;fkjsd;klfjsd;fljsf;oidfjgwper0tujdfgndfjkl;gjnergjol;kehfgo;dijge;oghdfkl;gjdfkl;gjdeior;lgjedr;ioghjdorighndeklo;grjiop[",
20,
)).is_none());
route
.push_future(Identity::new("This is the last callsign", 0))
.unwrap();
route.push_internet().unwrap();
let mut iter = route.iter();
assert_eq!(
RouteHop::Past(PastHop::new(Identity::new("VE2XYZ", 23), None)),
iter.next().unwrap()
);
assert_eq!(RouteHop::Internet, iter.next().unwrap());
assert_eq!(RouteHop::Internet, iter.next().unwrap());
assert_eq!(RouteHop::Internet, iter.next().unwrap());
assert_eq!(
RouteHop::Future(Identity::new("VE9AAAAA", 94)),
iter.next().unwrap()
);
assert_eq!(
RouteHop::Future(Identity::new("This is the last callsign", 0)),
iter.next().unwrap()
);
assert_eq!(RouteHop::Internet, iter.next().unwrap());
assert_eq!(None, iter.next());
assert_eq!(34, route.max_hops);
}
#[test]
fn route_e2e() {
let mut route = Route::new(34);
route
.push_past(PastHop::new(Identity::new("VE2XYZ", 23), Some(0.0)))
.unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_internet().unwrap();
route.push_future(Identity::new("VE9AAAAA", 94)).unwrap();
route
.push_future(Identity::new("This is the last callsign", 0))
.unwrap();
route.push_internet().unwrap();
let mut buf = [0; 256];
let encoded = route.encode(&mut buf).unwrap();
let decoded = Route::decode(encoded).unwrap();
assert_eq!(route, decoded);
}
// verify examples in the standard doc
#[test]
fn route_doc_examples() {
let mut ex1 = Route::new(4);
ex1.push_past(PastHop::new(Identity::new("VE1ABC", 0), Some(-96.0)))
.unwrap();
ex1.push_past(PastHop::new(Identity::new("VE2DEF", 234), Some(-13.0)))
.unwrap();
ex1.push_past(PastHop::new(Identity::new("VE3XYZ", 14), Some(-106.0)))
.unwrap();
let mut buf = [0; 256];
let encoded = ex1.encode(&mut buf).unwrap();
assert_eq!(
&[
0x1C, 0x04, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0x60, 0x56, 0x45, 0x32,
0x44, 0x45, 0x46, 0xFF, 0xEA, 0xDC, 0x56, 0x45, 0x33, 0x58, 0x59, 0x5A, 0xFF, 0x0E,
0x51
],
&encoded
);
let mut ex1_5 = Route::new(4);
ex1_5
.push_past(PastHop::new(Identity::new("VE1ABC", 0), Some(-96.0)))
.unwrap();
ex1_5.push_future(Identity::new("VE2DEF", 234)).unwrap();
ex1_5.push_future(Identity::new("VE3XYZ", 14)).unwrap();
let mut buf = [0; 256];
let encoded = ex1_5.encode(&mut buf).unwrap();
assert_eq!(
&[
0x1A, 0x04, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0x60, 0x56, 0x45, 0x32,
0x44, 0x45, 0x46, 0xFD, 0xEA, 0x56, 0x45, 0x33, 0x58, 0x59, 0x5A, 0xFD, 0x0E,
],
&encoded
);
let mut ex2 = Route::new(3);
ex2.push_past(PastHop::new(Identity::new("VE1ABC", 0), None))
.unwrap();
ex2.push_internet();
ex2.push_past(PastHop::new(Identity::new("VE2DEF", 234), Some(-86.5)))
.unwrap();
ex2.push_internet();
ex2.push_past(PastHop::new(Identity::new("VE3XYZ", 14), Some(-65.0)))
.unwrap();
let encoded = ex2.encode(&mut buf).unwrap();
assert_eq!(
&[
0x1E, 0x03, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0x00, 0xFE, 0x56, 0x45,
0x32, 0x44, 0x45, 0x46, 0xFF, 0xEA, 0x6E, 0xFE, 0x56, 0x45, 0x33, 0x58, 0x59, 0x5A,
0xFF, 0x0E, 0x8E
],
&encoded
);
let mut ex3 = Route::new(0);
ex3.push_past(PastHop::new(Identity::new("VE1ABC", 0), Some(-42.5)))
.unwrap();
ex3.push_internet();
ex3.push_internet();
let encoded = ex3.encode(&mut buf).unwrap();
assert_eq!(
&[0x0C, 0x00, 0x56, 0x45, 0x31, 0x41, 0x42, 0x43, 0xFF, 0x00, 0xB0, 0xFE, 0xFE],
&encoded
);
}
#[test]
fn dest_e2e() {
assert_eq!(None, Destination::new(true, 0, "dest", 36));
assert_eq!(None, Destination::new(false, 128, "abc", 0));
assert!(Destination::new(false, 0, "anc", 8).is_some());
let dest = Destination::new(true, 64, "mrow", 31).unwrap();
let mut buf = [0; 256];
let encoded = dest.encode(&mut buf).unwrap();
let decoded = Destination::decode(encoded).unwrap();
assert_eq!(dest, decoded);
}
#[test]
fn dest_ack() {
let dest = Destination::new(true, 84, "abc", 17).unwrap();
assert_eq!(84, dest.ack_num());
assert!(dest.is_ack());
assert_eq!("abc", dest.callsign());
assert_eq!(17, dest.ssid());
}
#[test]
fn arbitrary_e2e() {
let data = b"Hello world! This is an example comment";
let arbitrary = Arbitrary::new(data).unwrap();
let mut buf = [0; 256];
let encoded = arbitrary.encode(&mut buf).unwrap();
let decoded = Arbitrary::decode(encoded).unwrap();
let decoded2 = Arbitrary::decode(&buf).unwrap();
assert_eq!(data[..], decoded.0[..]);
assert_eq!(data[..], decoded2.0[..]);
}
}
src/whisker/node_info.rs 0 → 100644
View file @ 9a18248f
#[derive(Copy, Clone, Debug)]
pub struct NodeInfo {
hardware_id: Option<u16>,
software_id: Option<u8>,
uptime: Option<u32>,
antenna_height: Option<u8>,
antenna_gain: Option<u8>,
tx_power: Option<u8>,
voltage: Option<u8>,
xcvr_temperature: Option<i8>,
battery_charge: Option<u8>,
altitude: Option<f32>,
balloon: bool,
ambient_temperature: Option<i8>,
ambient_humidity: Option<u8>,
ambient_pressure: Option<u16>,
}
impl NodeInfo {
pub fn builder() -> NodeInfoBuilder {
NodeInfoBuilder::default()
}
pub fn hardware_id(&self) -> Option<u16> {
self.hardware_id
}
pub fn software_id(&self) -> Option<u8> {
self.software_id
}
/// Seconds
pub fn uptime(&self) -> Option<u32> {
self.uptime
}
/// Meters
pub fn antenna_height(&self) -> Option<u8> {
self.antenna_height
}
/// dBi
pub fn antenna_gain(&self) -> Option<f64> {
self.antenna_gain.map(|g| g as f64 / 4.0)
}
/// dBm
pub fn tx_power(&self) -> Option<f64> {
self.tx_power.map(|p| p as f64 / 4.0)
}
/// Volts
pub fn voltage(&self) -> Option<f64> {
self.voltage.map(|v| v as f64 / 10.0)
}
/// Degrees C
pub fn xcvr_temperature(&self) -> Option<i8> {
self.xcvr_temperature
}
/// Percent
pub fn battery_charge(&self) -> Option<f64> {
self.battery_charge.map(|b| b as f64 / 2.55)
}
/// Higher precision altitude than what's available in the GPS whisker. Takes precedent if set. Useful for high altitude balloons.
/// Meters
pub fn altitude(&self) -> Option<f32> {
self.altitude
}
/// If true, this whisker was emitted by a high altitude balloon payload
pub fn is_balloon(&self) -> bool {
self.balloon
}
/// Degrees C
pub fn ambient_temperature(&self) -> Option<i8> {
self.ambient_temperature
}
/// Relative humidity, percent
pub fn ambient_humidity(&self) -> Option<f64> {
self.ambient_humidity.map(|x| x as f64 / 2.55)
}
/// Decapascal (daPa)
pub fn ambient_pressure(&self) -> Option<u16> {
self.ambient_pressure
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let mut bitmask: u32 = 0;
let mut i = 4;
// TODO these could be macros
if let Some(x) = self.hardware_id {
bitmask |= 1;
buf.get_mut(i..(i + 2))?.copy_from_slice(&x.to_le_bytes());
i += 2;
}
if let Some(x) = self.software_id {
bitmask |= 2;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.uptime {
bitmask |= 4;
buf.get_mut(i..(i + 4))?.copy_from_slice(&x.to_le_bytes());
i += 4;
}
if let Some(x) = self.antenna_height {
bitmask |= 8;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.antenna_gain {
bitmask |= 16;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.tx_power {
bitmask |= 32;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.voltage {
bitmask |= 64;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.xcvr_temperature {
bitmask |= 128;
*buf.get_mut(i)? = x.to_le_bytes()[0];
i += 1;
}
if let Some(x) = self.battery_charge {
bitmask |= 256;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.altitude {
bitmask |= 512;
buf.get_mut(i..(i + 4))?.copy_from_slice(&x.to_le_bytes());
i += 4;
}
if self.balloon {
bitmask |= 1024;
}
if let Some(x) = self.ambient_temperature {
bitmask |= 2048;
*buf.get_mut(i)? = x.to_le_bytes()[0];
i += 1;
}
if let Some(x) = self.ambient_humidity {
bitmask |= 4096;
*buf.get_mut(i)? = x;
i += 1;
}
if let Some(x) = self.ambient_pressure {
bitmask |= 8192;
buf.get_mut(i..(i + 2))?.copy_from_slice(&x.to_le_bytes());
i += 2;
}
buf[0] = (i - 1).try_into().ok()?;
buf[1..4].copy_from_slice(&bitmask.to_be_bytes()[1..]);
Some(&buf[..i])
}
pub fn decode(data: &[u8]) -> Option<Self> {
let bitmask = u32::from_be_bytes([0, *data.get(1)?, *data.get(2)?, *data.get(3)?]);
let mut builder = NodeInfoBuilder::default();
let mut i = 4;
if bitmask & 1 > 0 {
builder.hardware_id = Some(u16::from_le_bytes([*data.get(i)?, *data.get(i + 1)?]));
i += 2;
}
if bitmask & 2 > 0 {
builder.software_id = Some(*data.get(i)?);
i += 1;
}
if bitmask & 4 > 0 {
builder.uptime = Some(u32::from_le_bytes([
*data.get(i)?,
*data.get(i + 1)?,
*data.get(i + 2)?,
*data.get(i + 3)?,
]));
i += 4;
}
if bitmask & 8 > 0 {
builder.antenna_height = Some(*data.get(i)?);
i += 1;
}
if bitmask & 16 > 0 {
builder.antenna_gain = Some(*data.get(i)?);
i += 1;
}
if bitmask & 32 > 0 {
builder.tx_power = Some(*data.get(i)?);
i += 1;
}
if bitmask & 64 > 0 {
builder.voltage = Some(*data.get(i)?);
i += 1;
}
if bitmask & 128 > 0 {
builder.xcvr_temperature = Some(i8::from_le_bytes([*data.get(i)?]));
i += 1;
}
if bitmask & 256 > 0 {
builder.battery_charge = Some(*data.get(i)?);
i += 1;
}
if bitmask & 512 > 0 {
builder.altitude = Some(f32::from_le_bytes(
data.get(i..(i + 4))?.try_into().unwrap(),
));
i += 4;
}
builder.balloon = bitmask & 1024 > 0;
if bitmask & 2048 > 0 {
builder.ambient_temperature = Some(i8::from_le_bytes([*data.get(i)?]));
i += 1;
}
if bitmask & 4096 > 0 {
builder.ambient_humidity = Some(*data.get(i)?);
i += 1;
}
if bitmask & 8192 > 0 {
builder.ambient_pressure = Some(u16::from_le_bytes(
data.get(i..(i + 2))?.try_into().unwrap(),
));
i += 2;
}
// prevent unused variable warning
let _ = i;
Some(builder.build())
}
}
#[derive(Default, Copy, Clone)]
pub struct NodeInfoBuilder {
hardware_id: Option<u16>,
software_id: Option<u8>,
uptime: Option<u32>,
antenna_height: Option<u8>,
antenna_gain: Option<u8>,
tx_power: Option<u8>,
voltage: Option<u8>,
xcvr_temperature: Option<i8>,
battery_charge: Option<u8>,
altitude: Option<f32>,
balloon: bool,
ambient_temperature: Option<i8>,
ambient_humidity: Option<u8>,
ambient_pressure: Option<u16>,
}
impl NodeInfoBuilder {
pub fn build(self) -> NodeInfo {
let NodeInfoBuilder {
hardware_id,
software_id,
uptime,
antenna_height,
antenna_gain,
tx_power,
voltage,
xcvr_temperature,
battery_charge,
altitude,
balloon,
ambient_temperature,
ambient_humidity,
ambient_pressure,
} = self;
NodeInfo {
hardware_id,
software_id,
uptime,
antenna_height,
antenna_gain,
tx_power,
voltage,
xcvr_temperature,
battery_charge,
altitude,
balloon,
ambient_temperature,
ambient_humidity,
ambient_pressure,
}
}
pub fn hardware_id(mut self, val: u16) -> Self {
self.hardware_id = Some(val);
self
}
pub fn software_id(mut self, val: u8) -> Self {
self.software_id = Some(val);
self
}
/// Seconds
pub fn uptime(mut self, val: u32) -> Self {
self.uptime = Some(val);
self
}
/// Meters
pub fn antenna_height(mut self, val: u8) -> Self {
self.antenna_height = Some(val);
self
}
/// dBi
pub fn antenna_gain(mut self, val: f64) -> Self {
self.antenna_gain = Some((val * 4.0).min(255.0) as u8);
self
}
/// dBm
pub fn tx_power(mut self, val: f64) -> Self {
self.tx_power = Some((val * 4.0).min(255.0) as u8);
self
}
/// Volts
pub fn voltage(mut self, val: f64) -> Self {
self.voltage = Some((val * 10.0).min(255.0) as u8);
self
}
/// Degrees C
pub fn xcvr_temperature(mut self, val: i8) -> Self {
self.xcvr_temperature = Some(val);
self
}
/// Percent
pub fn battery_charge(mut self, val: f64) -> Self {
self.battery_charge = Some((val * 2.55).min(255.0) as u8);
self
}
/// Higher precision altitude than what's available in the GPS whisker. Takes precedent if set. Useful for high altitude balloons.
/// Meters
pub fn altitude(mut self, val: f32) -> Self {
self.altitude = Some(val);
self
}
/// If true, this whisker was emitted by a high altitude balloon payload
/// Please only set this on actual balloon payloads. Otherwise it can cause issues for downstream users!
pub fn set_balloon(mut self) -> Self {
self.balloon = true;
self
}
/// Degrees C
pub fn ambient_temperature(mut self, val: i8) -> Self {
self.ambient_temperature = Some(val);
self
}
/// Relative humidity, percent
pub fn ambient_humidity(mut self, val: f64) -> Self {
self.ambient_humidity = Some((val * 2.55).min(255.0) as u8);
self
}
/// Decapascal (daPa)
pub fn ambient_pressure(mut self, val: u16) -> Self {
self.ambient_pressure = Some(val);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
// verify examples in the standard doc
#[test]
fn node_info_doc_examples() {
let node_info = NodeInfoBuilder::default()
.hardware_id(7408)
.uptime(98)
.tx_power(30.0)
.voltage(12.8)
.build();
let mut buf = [0; 255];
let encoded = node_info.encode(&mut buf).unwrap();
assert_eq!(
[0x0B, 0x00, 0x00, 0x65, 0xF0, 0x1C, 0x62, 0x00, 0x00, 0x00, 0x78, 0x80],
encoded
);
}
}
src/whisker/route.rs 0 → 100644
View file @ 9a18248f
use arrayvec::ArrayVec;
use crate::{error::AppendNodeError, identity::Identity};
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Route {
pub max_hops: u8,
path: ArrayVec<u8, 254>,
has_future: bool,
}
impl Route {
pub fn new(max_hops: u8) -> Self {
let path = ArrayVec::new();
Self {
max_hops,
path,
has_future: false,
}
}
/// Returns `None` if there isn't enough space for the callsign
/// Returns `None` if attempting to push past after future hop
/// See the specs for more information
#[must_use]
pub fn push_hop(&mut self, hop: RouteHop) -> Option<()> {
match hop {
RouteHop::Internet => self.push_internet(),
RouteHop::Past(past_hop) => self.push_past(past_hop),
RouteHop::Future(ident) => self.push_future(ident),
}
}
/// Returns `None` if there isn't enough space for the callsign
/// Returns `None` if attempting to push after future hop
/// See the specs for more information
#[must_use]
pub fn push_past(&mut self, past_hop: PastHop) -> Option<()> {
let ident = past_hop.identity();
let len = ident.callsign().as_bytes().len() + 3;
let free_space = self.path.capacity() - self.path.len();
if len > free_space {
return None;
}
if self.has_future {
return None;
}
// safe to unwrap since we already did a length check
self.path
.try_extend_from_slice(ident.callsign().as_bytes())
.unwrap();
self.path.push(0xFF);
self.path.push(ident.ssid());
self.path.push(past_hop.rssi);
Some(())
}
/// Returns `None` if there isn't enough space for the callsign
#[must_use]
pub fn push_future(&mut self, ident: Identity) -> Option<()> {
let len = ident.callsign().as_bytes().len() + 2;
let free_space = self.path.capacity() - self.path.len();
if len > free_space {
return None;
}
self.has_future = true;
// safe to unwrap since we already did a length check
self.path
.try_extend_from_slice(ident.callsign().as_bytes())
.unwrap();
self.path.push(0xFD);
self.path.push(ident.ssid());
Some(())
}
/// Returns `None` if there isn't enough space
pub fn push_internet(&mut self) -> Option<()> {
let free_space = self.path.capacity() - self.path.len();
if free_space < 1 {
return None;
}
self.path.push(0xFE);
Some(())
}
/// Append a callsign/ssid pair to the route, intelligently.
/// I.e. replace future node if possible
/// Returns an Err if the route is out of space, or appending the node doesn't make logical sense
/// (there's a future node that doesn't match)
/// This only appends past hops.
pub fn append_hop(&mut self, new_hop: PastHop) -> Result<(), AppendNodeError> {
let mut new_route = Route::new(self.max_hops);
let mut already_inserted = false;
for rn in self.iter() {
match rn {
RouteHop::Internet => new_route
.push_internet()
.ok_or(AppendNodeError::RouteOverflow)?,
RouteHop::Past(prev_past_hop) => {
let us = prev_past_hop.identity() == new_hop.identity();
if us {
return Err(AppendNodeError::DuplicateNode);
} else {
new_route
.push_past(prev_past_hop)
.ok_or(AppendNodeError::RouteOverflow)?;
}
}
RouteHop::Future(prev_ident) => {
let us = prev_ident == new_hop.identity();
if us {
if already_inserted {
return Err(AppendNodeError::DuplicateNode);
} else {
new_route
.push_past(new_hop)
.ok_or(AppendNodeError::RouteOverflow)?;
already_inserted = true;
}
} else if already_inserted {
new_route
.push_future(prev_ident)
.ok_or(AppendNodeError::RouteOverflow)?;
} else {
return Err(AppendNodeError::SetFuture);
}
}
}
}
if !already_inserted {
new_route
.push_past(new_hop)
.ok_or(AppendNodeError::RouteOverflow)?;
}
if new_route.iter().count() > usize::from(new_route.max_hops) {
return Err(AppendNodeError::HopsOverflow);
}
*self = new_route;
Ok(())
}
pub fn iter(&'_ self) -> RouteIter<'_> {
RouteIter::new(self)
}
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
let packet_len = self.path.len() + 1;
let buf = buf.get_mut(0..(packet_len + 1))?;
buf[0] = packet_len.try_into().unwrap();
buf[1] = self.max_hops;
buf[2..(packet_len + 1)].copy_from_slice(&self.path);
Some(buf)
}
pub fn decode(data: &[u8]) -> Option<Self> {
let len: usize = (*data.first()?).into();
let data = data.get(1..(len + 1))?;
let max_hops = *data.first()?;
let mut path = ArrayVec::new();
path.try_extend_from_slice(&data[1..]).unwrap();
let has_future = data[1..].iter().any(|x| *x == 0xFD);
let s = Self {
max_hops,
path,
has_future,
};
if UntrustedRouteIter::new(&s).any(|v| v.is_err()) {
return None;
}
Some(s)
}
}
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum RouteHop<'a> {
Internet,
Past(PastHop<'a>),
Future(Identity<'a>),
}
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub struct PastHop<'a> {
identity: Identity<'a>,
rssi: u8,
}
impl<'a> PastHop<'a> {
pub fn new(identity: Identity<'a>, rssi: Option<f64>) -> Self {
let rssi = match rssi {
Some(rssi) => (rssi * 1.5 + 240.0).max(1.0) as u8,
None => 0,
};
Self { identity, rssi }
}
pub fn identity(&self) -> Identity {
self.identity
}
pub fn rssi(&self) -> Option<f64> {
if self.rssi == 0 {
None
} else {
Some(((self.rssi as f64) - 240.0) / 1.5)
}
}
}
#[derive(Debug, Clone)]
struct UntrustedRouteIter<'a> {
route: &'a Route,
i: usize,
seen_future: bool,
dead: bool,
}
impl<'a> UntrustedRouteIter<'a> {
fn new(route: &'a Route) -> Self {
Self {
route,
i: 0,
seen_future: false,
dead: false,
}
}
// Returns Err(()) if invalid
fn maybe_next(&mut self) -> Result<RouteHop<'a>, ()> {
let i_start = self.i;
self.i += 1;
if *self.route.path.get(i_start).ok_or(())? == 0xFE {
return Ok(RouteHop::Internet);
}
while *self.route.path.get(self.i).ok_or(())? != 0xFD && self.route.path[self.i] != 0xFF {
self.i += 1;
}
let callsign = core::str::from_utf8(self.route.path.get(i_start..self.i).ok_or(())?)
.map_err(|_| ())?;
let is_future = *self.route.path.get(self.i).ok_or(())? == 0xFD;
if self.seen_future && !is_future {
// past after future - not allowed
return Err(());
}
self.seen_future |= is_future;
let ssid = *self.route.path.get(self.i + 1).ok_or(())?;
self.i += 2;
if is_future {
Ok(RouteHop::Future(Identity::new(callsign, ssid)))
} else {
let rssi = *self.route.path.get(self.i).ok_or(())?;
self.i += 1;
Ok(RouteHop::Past(PastHop {
identity: Identity::new(callsign, ssid),
rssi,
}))
}
}
}
impl<'a> Iterator for UntrustedRouteIter<'a> {
type Item = Result<RouteHop<'a>, ()>;
fn next(&mut self) -> Option<Self::Item> {
if self.dead {
return None;
}
if self.i == self.route.path.len() {
return None;
}
let r = self.maybe_next();
if r.is_err() {
self.dead = true;
}
Some(r)
}
}
#[derive(Clone)]
pub struct RouteIter<'a> {
iter: UntrustedRouteIter<'a>,
}
impl<'a> RouteIter<'a> {
fn new(route: &'a Route) -> Self {
Self {
iter: UntrustedRouteIter::new(route),
}
}
}
impl<'a> Iterator for RouteIter<'a> {
type Item = RouteHop<'a>;
fn next(&mut self) -> Option<Self::Item> {
Some(self.iter.next()?.unwrap())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn route_rssi() {
let x = -66.0;
let r = PastHop::new(Identity::new("C0", 23), Some(x));
assert_eq!(x, r.rssi().unwrap());
let x = 10.0;
let r = PastHop::new(Identity::new("C0", 23), Some(x));
assert_eq!(x, r.rssi().unwrap());
let x = -158.0;
let r = PastHop::new(Identity::new("C0", 23), Some(x));
assert_eq!(x, r.rssi().unwrap());
let r = PastHop::new(Identity::new("C0", 23), None);
assert_eq!(None, r.rssi());
}
#[test]
fn append_fails_when_existing_future() {
let mut r = Route::new(5);
r.push_past(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
r.push_past(PastHop::new(Identity::new("C2", 0), None))
.unwrap();
r.push_future(Identity::new("C3", 0)).unwrap();
assert_eq!(
AppendNodeError::SetFuture,
r.append_hop(PastHop::new(Identity::new("C3", 1), None))
.unwrap_err()
);
assert_eq!(
AppendNodeError::SetFuture,
r.append_hop(PastHop::new(Identity::new("C4", 0), None))
.unwrap_err()
);
}
#[test]
fn append_fails_when_would_exceed_max_hops() {
let mut r = Route::new(3);
r.append_hop(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
r.append_hop(PastHop::new(Identity::new("C2", 0), None))
.unwrap();
r.append_hop(PastHop::new(Identity::new("C2", 1), None))
.unwrap();
assert_eq!(
AppendNodeError::HopsOverflow,
r.append_hop(PastHop::new(Identity::new("C4", 0), None))
.unwrap_err()
);
}
#[test]
fn append_fails_when_already_in_route() {
let mut r = Route::new(3);
r.append_hop(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
assert_eq!(
AppendNodeError::DuplicateNode,
r.append_hop(PastHop::new(Identity::new("C1", 0), None))
.unwrap_err()
);
}
#[test]
fn append_overwrites_future() {
let mut r = Route::new(5);
r.push_past(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
r.push_past(PastHop::new(Identity::new("C2", 0), None))
.unwrap();
r.push_future(Identity::new("C3", 0)).unwrap();
r.push_future(Identity::new("C4", 0)).unwrap();
r.append_hop(PastHop::new(Identity::new("C3", 0), None))
.unwrap();
let mut iter = r.iter();
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C1", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C2", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C3", 0), None))),
iter.next()
);
assert_eq!(Some(RouteHop::Future(Identity::new("C4", 0))), iter.next());
assert_eq!(None, iter.next());
}
#[test]
fn append_overwrites_future_even_when_at_hop_limit() {
let mut r = Route::new(4);
r.push_past(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
r.push_past(PastHop::new(Identity::new("C2", 0), None))
.unwrap();
r.push_future(Identity::new("C3", 0)).unwrap();
r.push_future(Identity::new("C4", 0)).unwrap();
r.append_hop(PastHop::new(Identity::new("C3", 0), None))
.unwrap();
let mut iter = r.iter();
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C1", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C2", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C3", 0), None))),
iter.next()
);
assert_eq!(Some(RouteHop::Future(Identity::new("C4", 0,))), iter.next());
assert_eq!(None, iter.next());
}
#[test]
fn append_appends_when_no_future() {
let mut r = Route::new(5);
r.push_past(PastHop::new(Identity::new("C1", 0), None))
.unwrap();
r.push_past(PastHop::new(Identity::new("C2", 0), None))
.unwrap();
r.push_past(PastHop::new(Identity::new("C3", 0), None))
.unwrap();
r.append_hop(PastHop::new(Identity::new("C4", 0), None))
.unwrap();
let mut iter = r.iter();
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C1", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C2", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C3", 0), None))),
iter.next()
);
assert_eq!(
Some(RouteHop::Past(PastHop::new(Identity::new("C4", 0), None))),
iter.next()
);
assert_eq!(None, iter.next());
}
}
src/whisker/timestamp.rs 0 → 100644
View file @ 9a18248f
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Timestamp(u64);
impl Timestamp {
/// Returns none if the given unix timestamp doesn't fit in 5 bytes
pub fn new(unix_time: u64) -> Option<Self> {
// must fit in 5 bytes
if unix_time > (1 << (5 * 8)) - 1 {
return None;
}
Some(Self(unix_time))
}
pub fn unix_time(&self) -> u64 {
self.0
}
/// Returns none if there is not enough space in the buffer
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
if buf.len() < 6 {
return None;
}
buf[0] = 5;
buf[1..6].copy_from_slice(&self.0.to_le_bytes()[0..5]);
Some(&buf[0..6])
}
pub fn decode(data: &[u8]) -> Option<Self> {
if data.len() < 6 {
return None;
}
if data[0] != 5 {
return None;
}
let mut extended_data = [0; 8];
extended_data[0..5].copy_from_slice(&data[1..6]);
Some(Self(u64::from_le_bytes(extended_data)))
}
}
src/whisker/unknown.rs 0 → 100644
View file @ 9a18248f
use arrayvec::ArrayVec;
#[derive(Debug)]
pub struct Unknown {
whisker_type: u8,
data: ArrayVec<u8, 255>,
}
impl Unknown {
pub(crate) fn new(whisker_type: u8, data: ArrayVec<u8, 255>) -> Self {
Self { whisker_type, data }
}
pub fn whisker_type(&self) -> u8 {
self.whisker_type
}
pub fn data(&self) -> &[u8] {
&self.data
}
}
src/whitener.rs 0 → 100644
View file @ 9a18248f
const START_STATE: u16 = 0xE9CF;
pub(crate) fn whiten(data: &mut [u8]) {
let mut state = START_STATE;
for d in data.iter_mut() {
let b;
(b, state) = lfsr_byte(state);
*d ^= b;
}
}
// (byte, state)
fn lfsr_byte(mut state: u16) -> (u8, u16) {
let mut out = 0;
for i in (0..8).rev() {
out |= u8::try_from(state & 1).unwrap() << i;
state = lfsr(state);
}
(out, state)
}
// https://en.wikipedia.org/wiki/Linear-feedback_shift_register#Galois_LFSRs
fn lfsr(mut state: u16) -> u16 {
let lsb = state & 1;
state >>= 1;
if lsb > 0 {
state ^= 0xB400; // apply toggle mask
}
state
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn basic() {
let mut data = [0; 64];
data[0..57]
.clone_from_slice(&b"Hello world! The quick brown fox jumped over the lazy dog"[..]);
let orig = data;
whiten(&mut data);
assert_ne!(orig, data);
whiten(&mut data);
assert_eq!(orig, data);
}
#[test]
fn test_lfsr() {
let start = 0xACE1;
let end_expected = 0xE270;
let state = lfsr(start);
assert_eq!(end_expected, state);
}
#[test]
fn test_lfsr_byte() {
let start = 0xE9CF;
let (out, state) = lfsr_byte(start);
assert_eq!(0xF3, out);
assert_eq!(0xE3B1, state);
}
#[test]
fn test_doc_example() {
let start = 0xE9CF;
let expected_out = [
0xF3, 0x8D, 0xD0, 0x6E, 0x1F, 0x65, 0x75, 0x75, 0xA5, 0xBA, 0xA9, 0xD0, 0x7A, 0x1D,
0x1, 0x21,
];
let mut actual_out = [0; 16];
let mut state = start;
for a in &mut actual_out {
let (out, ns) = lfsr_byte(state);
state = ns;
*a = out;
}
assert_eq!(expected_out, actual_out);
}
#[test]
fn test_doc_example_through_whitener() {
let expected_out = [
0xF3, 0x8D, 0xD0, 0x6E, 0x1F, 0x65, 0x75, 0x75, 0xA5, 0xBA, 0xA9, 0xD0, 0x7A, 0x1D,
0x1, 0x21,
];
let mut actual_out = [0; 16];
whiten(&mut actual_out);
assert_eq!(expected_out, actual_out);
}
}