708 lines
21 KiB
Rust
708 lines
21 KiB
Rust
//! Wire protocol types and fixed-size little-endian serialization.
|
||
//!
|
||
//! Every integer is fixed-width LE. No varints, no zigzag.
|
||
//! See `docs/PROTOCOL.md` for the complete specification.
|
||
|
||
use heapless::Vec;
|
||
|
||
/// Maximum LoRa payload size in bytes.
|
||
pub const MAX_PAYLOAD: usize = 256;
|
||
|
||
/// RadioConfig wire size (fixed).
|
||
pub const RADIO_CONFIG_SIZE: usize = 13;
|
||
|
||
/// Sentinel value for `tx_power_dbm`: use the board's maximum TX power.
|
||
pub const TX_POWER_MAX: i8 = i8::MIN; // -128 on the wire
|
||
|
||
/// Sentinel value for `preamble_len`: use the firmware default (16 symbols).
|
||
pub const PREAMBLE_DEFAULT: u16 = 0;
|
||
|
||
/// LoRa signal bandwidth.
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
#[cfg_attr(not(test), derive(defmt::Format))]
|
||
#[repr(u8)]
|
||
pub enum Bandwidth {
|
||
Khz7 = 0,
|
||
Khz10 = 1,
|
||
Khz15 = 2,
|
||
Khz20 = 3,
|
||
Khz31 = 4,
|
||
Khz41 = 5,
|
||
Khz62 = 6,
|
||
Khz125 = 7,
|
||
Khz250 = 8,
|
||
Khz500 = 9,
|
||
}
|
||
|
||
impl Bandwidth {
|
||
fn from_u8(v: u8) -> Option<Self> {
|
||
match v {
|
||
0 => Some(Self::Khz7),
|
||
1 => Some(Self::Khz10),
|
||
2 => Some(Self::Khz15),
|
||
3 => Some(Self::Khz20),
|
||
4 => Some(Self::Khz31),
|
||
5 => Some(Self::Khz41),
|
||
6 => Some(Self::Khz62),
|
||
7 => Some(Self::Khz125),
|
||
8 => Some(Self::Khz250),
|
||
9 => Some(Self::Khz500),
|
||
_ => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Complete LoRa radio configuration.
|
||
///
|
||
/// Wire layout (13 bytes, all little-endian):
|
||
/// ```text
|
||
/// [freq_hz:4] [bw:1] [sf:1] [cr:1] [sync_word:2] [tx_power_dbm:1] [preamble_len:2] [cad:1]
|
||
/// ```
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
#[cfg_attr(not(test), derive(defmt::Format))]
|
||
pub struct RadioConfig {
|
||
/// Frequency in Hz (150_000_000 - 960_000_000 for SX1262).
|
||
pub freq_hz: u32,
|
||
pub bw: Bandwidth,
|
||
/// Spreading factor (5-12).
|
||
pub sf: u8,
|
||
/// Coding rate denominator (5-8). E.g. 5 = CR 4/5, 8 = CR 4/8.
|
||
pub cr: u8,
|
||
pub sync_word: u16,
|
||
/// Transmit power in dBm. Set to [`TX_POWER_MAX`] (-128) for the
|
||
/// board's maximum.
|
||
pub tx_power_dbm: i8,
|
||
/// Preamble length in symbols. Set to [`PREAMBLE_DEFAULT`] (0) for
|
||
/// the firmware default (16 symbols). Valid range: 6–65535.
|
||
pub preamble_len: u16,
|
||
/// Channel Activity Detection (listen-before-talk) before TX.
|
||
/// 0 = disabled, non-zero = enabled. Default: 1 (enabled).
|
||
pub cad: u8,
|
||
}
|
||
|
||
impl RadioConfig {
|
||
/// Validate fields against hardware limits.
|
||
pub fn validate(&self, power_range: (i8, i8)) -> Result<(), &'static str> {
|
||
if !(150_000_000..=960_000_000).contains(&self.freq_hz) {
|
||
return Err("frequency out of range (150-960 MHz)");
|
||
}
|
||
if !(5..=12).contains(&self.sf) {
|
||
return Err("spreading factor out of range (5-12)");
|
||
}
|
||
if !(5..=8).contains(&self.cr) {
|
||
return Err("coding rate out of range (5-8)");
|
||
}
|
||
if self.tx_power_dbm != TX_POWER_MAX
|
||
&& !(power_range.0..=power_range.1).contains(&self.tx_power_dbm)
|
||
{
|
||
return Err("TX power out of range for this board");
|
||
}
|
||
if self.preamble_len != PREAMBLE_DEFAULT && self.preamble_len < 6 {
|
||
return Err("preamble length too short (min 6)");
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Resolve sentinel values to concrete defaults.
|
||
pub fn resolve(mut self, power_range: (i8, i8)) -> Self {
|
||
if self.tx_power_dbm == TX_POWER_MAX {
|
||
self.tx_power_dbm = power_range.1;
|
||
}
|
||
if self.preamble_len == PREAMBLE_DEFAULT {
|
||
self.preamble_len = 16;
|
||
}
|
||
self
|
||
}
|
||
|
||
/// Whether CAD (listen-before-talk) is enabled.
|
||
pub fn cad_enabled(&self) -> bool {
|
||
self.cad != 0
|
||
}
|
||
|
||
/// Serialize to fixed-size LE bytes. Returns number of bytes written (always 13).
|
||
pub fn write_to(self, buf: &mut [u8]) -> usize {
|
||
buf[0..4].copy_from_slice(&self.freq_hz.to_le_bytes());
|
||
buf[4] = self.bw as u8;
|
||
buf[5] = self.sf;
|
||
buf[6] = self.cr;
|
||
buf[7..9].copy_from_slice(&self.sync_word.to_le_bytes());
|
||
buf[9] = self.tx_power_dbm as u8;
|
||
buf[10..12].copy_from_slice(&self.preamble_len.to_le_bytes());
|
||
buf[12] = self.cad;
|
||
RADIO_CONFIG_SIZE
|
||
}
|
||
|
||
/// Deserialize from fixed-size LE bytes.
|
||
pub fn from_bytes(buf: &[u8]) -> Option<Self> {
|
||
if buf.len() < RADIO_CONFIG_SIZE {
|
||
return None;
|
||
}
|
||
Some(Self {
|
||
freq_hz: u32::from_le_bytes(buf[0..4].try_into().ok()?),
|
||
bw: Bandwidth::from_u8(buf[4])?,
|
||
sf: buf[5],
|
||
cr: buf[6],
|
||
sync_word: u16::from_le_bytes(buf[7..9].try_into().ok()?),
|
||
tx_power_dbm: buf[9] as i8,
|
||
preamble_len: u16::from_le_bytes(buf[10..12].try_into().ok()?),
|
||
cad: buf[12],
|
||
})
|
||
}
|
||
}
|
||
|
||
/// Host → firmware commands.
|
||
#[allow(clippy::large_enum_variant)]
|
||
#[derive(Debug, PartialEq)]
|
||
pub enum Command {
|
||
Ping,
|
||
GetConfig,
|
||
SetConfig(RadioConfig),
|
||
StartRx,
|
||
StopRx,
|
||
Transmit {
|
||
config: Option<RadioConfig>,
|
||
payload: Vec<u8, MAX_PAYLOAD>,
|
||
},
|
||
DisplayOn,
|
||
DisplayOff,
|
||
GetMac,
|
||
}
|
||
|
||
impl Command {
|
||
/// Deserialize from a COBS-decoded frame.
|
||
pub fn from_bytes(buf: &[u8]) -> Option<Self> {
|
||
let tag = *buf.first()?;
|
||
let rest = &buf[1..];
|
||
match tag {
|
||
0 => Some(Self::Ping),
|
||
1 => Some(Self::GetConfig),
|
||
2 => Some(Self::SetConfig(RadioConfig::from_bytes(rest)?)),
|
||
3 => Some(Self::StartRx),
|
||
4 => Some(Self::StopRx),
|
||
5 => {
|
||
// Transmit: has_config:u8 + [RadioConfig if 1] + len:u16 LE + payload
|
||
if rest.is_empty() {
|
||
return None;
|
||
}
|
||
let (config, pos) = if rest[0] == 0 {
|
||
(None, 1)
|
||
} else if rest[0] == 1 && rest.len() > RADIO_CONFIG_SIZE {
|
||
(
|
||
Some(RadioConfig::from_bytes(&rest[1..])?),
|
||
1 + RADIO_CONFIG_SIZE,
|
||
)
|
||
} else {
|
||
return None;
|
||
};
|
||
if rest.len() < pos + 2 {
|
||
return None;
|
||
}
|
||
let len = u16::from_le_bytes(rest[pos..pos + 2].try_into().ok()?) as usize;
|
||
let data_start = pos + 2;
|
||
if rest.len() < data_start + len {
|
||
return None;
|
||
}
|
||
let mut payload = Vec::new();
|
||
let _ = payload.extend_from_slice(&rest[data_start..data_start + len]);
|
||
Some(Self::Transmit { config, payload })
|
||
}
|
||
6 => Some(Self::DisplayOn),
|
||
7 => Some(Self::DisplayOff),
|
||
8 => Some(Self::GetMac),
|
||
_ => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Firmware → host responses.
|
||
#[allow(clippy::large_enum_variant)]
|
||
#[derive(Debug, PartialEq)]
|
||
pub enum Response {
|
||
Pong,
|
||
Config(RadioConfig),
|
||
RxPacket {
|
||
rssi: i16,
|
||
snr: i16,
|
||
payload: Vec<u8, MAX_PAYLOAD>,
|
||
},
|
||
TxDone,
|
||
Ok,
|
||
Error(ErrorCode),
|
||
MacAddress([u8; 6]),
|
||
}
|
||
|
||
impl Response {
|
||
/// Serialize to fixed-size LE bytes. Returns number of bytes written.
|
||
pub fn write_to(self, buf: &mut [u8]) -> usize {
|
||
match self {
|
||
Self::Pong => {
|
||
buf[0] = 0;
|
||
1
|
||
}
|
||
Self::Config(cfg) => {
|
||
buf[0] = 1;
|
||
1 + cfg.write_to(&mut buf[1..])
|
||
}
|
||
Self::RxPacket { rssi, snr, payload } => {
|
||
buf[0] = 2;
|
||
buf[1..3].copy_from_slice(&rssi.to_le_bytes());
|
||
buf[3..5].copy_from_slice(&snr.to_le_bytes());
|
||
buf[5..7].copy_from_slice(&(payload.len() as u16).to_le_bytes());
|
||
buf[7..7 + payload.len()].copy_from_slice(&payload);
|
||
7 + payload.len()
|
||
}
|
||
Self::TxDone => {
|
||
buf[0] = 3;
|
||
1
|
||
}
|
||
Self::Ok => {
|
||
buf[0] = 4;
|
||
1
|
||
}
|
||
Self::Error(code) => {
|
||
buf[0] = 5;
|
||
buf[1] = code as u8;
|
||
2
|
||
}
|
||
Self::MacAddress(mac) => {
|
||
buf[0] = 6;
|
||
buf[1..7].copy_from_slice(&mac);
|
||
7
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Error codes reported to the host.
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
#[cfg_attr(not(test), derive(defmt::Format))]
|
||
#[repr(u8)]
|
||
#[allow(dead_code)] // CrcError reserved per PROTOCOL.md (error code 3)
|
||
pub enum ErrorCode {
|
||
InvalidConfig = 0,
|
||
RadioBusy = 1,
|
||
TxTimeout = 2,
|
||
CrcError = 3,
|
||
NotConfigured = 4,
|
||
NoDisplay = 5,
|
||
}
|
||
|
||
// ── Tests ───────────────────────────────────────────────────────────
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
fn make_config() -> RadioConfig {
|
||
RadioConfig {
|
||
freq_hz: 915_000_000,
|
||
bw: Bandwidth::Khz125,
|
||
sf: 7,
|
||
cr: 5,
|
||
sync_word: 0x3444,
|
||
tx_power_dbm: 22,
|
||
preamble_len: 16,
|
||
cad: 1,
|
||
}
|
||
}
|
||
|
||
// ── RadioConfig roundtrip ───────────────────────────────────────
|
||
|
||
#[test]
|
||
fn radio_config_roundtrip() {
|
||
let cfg = make_config();
|
||
let mut buf = [0u8; RADIO_CONFIG_SIZE];
|
||
let n = cfg.write_to(&mut buf);
|
||
assert_eq!(n, RADIO_CONFIG_SIZE);
|
||
assert_eq!(RadioConfig::from_bytes(&buf), Some(cfg));
|
||
}
|
||
|
||
#[test]
|
||
fn radio_config_roundtrip_all_bandwidths() {
|
||
for bw_val in 0u8..=9 {
|
||
let bw = Bandwidth::from_u8(bw_val).unwrap();
|
||
let cfg = RadioConfig {
|
||
freq_hz: 433_000_000,
|
||
bw,
|
||
sf: 12,
|
||
cr: 8,
|
||
sync_word: 0x1234,
|
||
tx_power_dbm: -9,
|
||
};
|
||
let mut buf = [0u8; RADIO_CONFIG_SIZE];
|
||
cfg.write_to(&mut buf);
|
||
assert_eq!(RadioConfig::from_bytes(&buf), Some(cfg));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn radio_config_roundtrip_negative_power() {
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: TX_POWER_MAX,
|
||
..make_config()
|
||
};
|
||
let mut buf = [0u8; RADIO_CONFIG_SIZE];
|
||
cfg.write_to(&mut buf);
|
||
assert_eq!(RadioConfig::from_bytes(&buf), Some(cfg));
|
||
}
|
||
|
||
#[test]
|
||
fn radio_config_from_short_buffer() {
|
||
let buf = [0u8; RADIO_CONFIG_SIZE - 1];
|
||
assert!(RadioConfig::from_bytes(&buf).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn radio_config_from_empty_buffer() {
|
||
assert!(RadioConfig::from_bytes(&[]).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn radio_config_invalid_bandwidth() {
|
||
let mut buf = [0u8; RADIO_CONFIG_SIZE];
|
||
make_config().write_to(&mut buf);
|
||
buf[4] = 255; // invalid bandwidth
|
||
assert!(RadioConfig::from_bytes(&buf).is_none());
|
||
}
|
||
|
||
// ── RadioConfig::validate ───────────────────────────────────────
|
||
|
||
#[test]
|
||
fn validate_freq_boundaries() {
|
||
let power_range = (-9, 22);
|
||
let base = make_config();
|
||
|
||
let mut cfg = RadioConfig {
|
||
freq_hz: 150_000_000,
|
||
..base
|
||
};
|
||
assert!(cfg.validate(power_range).is_ok());
|
||
|
||
cfg.freq_hz = 960_000_000;
|
||
assert!(cfg.validate(power_range).is_ok());
|
||
|
||
cfg.freq_hz = 149_999_999;
|
||
assert!(cfg.validate(power_range).is_err());
|
||
|
||
cfg.freq_hz = 960_000_001;
|
||
assert!(cfg.validate(power_range).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_sf_boundaries() {
|
||
let power_range = (-9, 22);
|
||
let base = make_config();
|
||
|
||
for sf in 5..=12 {
|
||
assert!(RadioConfig { sf, ..base }.validate(power_range).is_ok());
|
||
}
|
||
assert!(RadioConfig { sf: 4, ..base }.validate(power_range).is_err());
|
||
assert!(RadioConfig { sf: 13, ..base }
|
||
.validate(power_range)
|
||
.is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_cr_boundaries() {
|
||
let power_range = (-9, 22);
|
||
let base = make_config();
|
||
|
||
for cr in 5..=8 {
|
||
assert!(RadioConfig { cr, ..base }.validate(power_range).is_ok());
|
||
}
|
||
assert!(RadioConfig { cr: 4, ..base }.validate(power_range).is_err());
|
||
assert!(RadioConfig { cr: 9, ..base }.validate(power_range).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_tx_power_max_sentinel() {
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: TX_POWER_MAX,
|
||
..make_config()
|
||
};
|
||
assert!(cfg.validate((-9, 22)).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_tx_power_out_of_range() {
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: 23,
|
||
..make_config()
|
||
};
|
||
assert!(cfg.validate((-9, 22)).is_err());
|
||
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: -10,
|
||
..make_config()
|
||
};
|
||
assert!(cfg.validate((-9, 22)).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_preamble_default_sentinel() {
|
||
let cfg = RadioConfig {
|
||
preamble_len: PREAMBLE_DEFAULT,
|
||
..make_config()
|
||
};
|
||
assert!(cfg.validate((-9, 22)).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn validate_preamble_boundaries() {
|
||
let power_range = (-9, 22);
|
||
let base = make_config();
|
||
|
||
assert!(RadioConfig {
|
||
preamble_len: 6,
|
||
..base
|
||
}
|
||
.validate(power_range)
|
||
.is_ok());
|
||
assert!(RadioConfig {
|
||
preamble_len: 5,
|
||
..base
|
||
}
|
||
.validate(power_range)
|
||
.is_err());
|
||
}
|
||
|
||
// ── RadioConfig::resolve ──────────────────────────────────────
|
||
|
||
#[test]
|
||
fn resolve_power_max_sentinel() {
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: TX_POWER_MAX,
|
||
..make_config()
|
||
};
|
||
assert_eq!(cfg.resolve((-9, 22)).tx_power_dbm, 22);
|
||
}
|
||
|
||
#[test]
|
||
fn resolve_power_explicit_unchanged() {
|
||
let cfg = RadioConfig {
|
||
tx_power_dbm: 10,
|
||
..make_config()
|
||
};
|
||
assert_eq!(cfg.resolve((-9, 22)).tx_power_dbm, 10);
|
||
}
|
||
|
||
#[test]
|
||
fn resolve_preamble_default() {
|
||
let cfg = RadioConfig {
|
||
preamble_len: PREAMBLE_DEFAULT,
|
||
..make_config()
|
||
};
|
||
assert_eq!(cfg.resolve((-9, 22)).preamble_len, 16);
|
||
}
|
||
|
||
#[test]
|
||
fn resolve_preamble_explicit_unchanged() {
|
||
let cfg = RadioConfig {
|
||
preamble_len: 32,
|
||
..make_config()
|
||
};
|
||
assert_eq!(cfg.resolve((-9, 22)).preamble_len, 32);
|
||
}
|
||
|
||
// ── Command::from_bytes ─────────────────────────────────────────
|
||
|
||
#[test]
|
||
fn command_ping() {
|
||
assert_eq!(Command::from_bytes(&[0]), Some(Command::Ping));
|
||
}
|
||
|
||
#[test]
|
||
fn command_get_config() {
|
||
assert_eq!(Command::from_bytes(&[1]), Some(Command::GetConfig));
|
||
}
|
||
|
||
#[test]
|
||
fn command_set_config() {
|
||
let cfg = make_config();
|
||
let mut buf = [0u8; 1 + RADIO_CONFIG_SIZE];
|
||
buf[0] = 2;
|
||
cfg.write_to(&mut buf[1..]);
|
||
assert_eq!(Command::from_bytes(&buf), Some(Command::SetConfig(cfg)));
|
||
}
|
||
|
||
#[test]
|
||
fn command_start_stop_rx() {
|
||
assert_eq!(Command::from_bytes(&[3]), Some(Command::StartRx));
|
||
assert_eq!(Command::from_bytes(&[4]), Some(Command::StopRx));
|
||
}
|
||
|
||
#[test]
|
||
fn command_transmit_no_config() {
|
||
let payload = b"hello";
|
||
let mut buf = [0u8; 64];
|
||
buf[0] = 5; // tag
|
||
buf[1] = 0; // has_config = false
|
||
buf[2..4].copy_from_slice(&(payload.len() as u16).to_le_bytes());
|
||
buf[4..9].copy_from_slice(payload);
|
||
|
||
match Command::from_bytes(&buf[..9]).unwrap() {
|
||
Command::Transmit { config, payload: p } => {
|
||
assert!(config.is_none());
|
||
assert_eq!(p.as_slice(), b"hello");
|
||
}
|
||
_ => panic!("expected Transmit"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn command_transmit_with_config() {
|
||
let cfg = make_config();
|
||
let mut buf = [0u8; 64];
|
||
buf[0] = 5; // tag
|
||
buf[1] = 1; // has_config = true
|
||
cfg.write_to(&mut buf[2..]);
|
||
let payload = b"test";
|
||
let pos = 2 + RADIO_CONFIG_SIZE;
|
||
buf[pos..pos + 2].copy_from_slice(&(payload.len() as u16).to_le_bytes());
|
||
buf[pos + 2..pos + 6].copy_from_slice(payload);
|
||
|
||
match Command::from_bytes(&buf[..pos + 6]).unwrap() {
|
||
Command::Transmit { config, payload: p } => {
|
||
assert_eq!(config, Some(cfg));
|
||
assert_eq!(p.as_slice(), b"test");
|
||
}
|
||
_ => panic!("expected Transmit"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn command_transmit_empty_payload() {
|
||
let mut buf = [0u8; 4];
|
||
buf[0] = 5; // tag
|
||
buf[1] = 0; // has_config = false
|
||
buf[2..4].copy_from_slice(&0u16.to_le_bytes());
|
||
|
||
match Command::from_bytes(&buf).unwrap() {
|
||
Command::Transmit { config, payload } => {
|
||
assert!(config.is_none());
|
||
assert!(payload.is_empty());
|
||
}
|
||
_ => panic!("expected Transmit"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn command_transmit_truncated() {
|
||
// Tag only — missing has_config byte
|
||
assert!(Command::from_bytes(&[5]).is_none());
|
||
|
||
// has_config=1 but no config bytes
|
||
assert!(Command::from_bytes(&[5, 1]).is_none());
|
||
|
||
// has_config=0 but no length bytes
|
||
assert!(Command::from_bytes(&[5, 0]).is_none());
|
||
|
||
// has_config=0, length says 5 but only 2 bytes of payload
|
||
let mut buf = [0u8; 6];
|
||
buf[0] = 5;
|
||
buf[1] = 0;
|
||
buf[2..4].copy_from_slice(&5u16.to_le_bytes());
|
||
buf[4] = 0xAA;
|
||
buf[5] = 0xBB;
|
||
assert!(Command::from_bytes(&buf).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn command_display_and_mac() {
|
||
assert_eq!(Command::from_bytes(&[6]), Some(Command::DisplayOn));
|
||
assert_eq!(Command::from_bytes(&[7]), Some(Command::DisplayOff));
|
||
assert_eq!(Command::from_bytes(&[8]), Some(Command::GetMac));
|
||
}
|
||
|
||
#[test]
|
||
fn command_invalid_tag() {
|
||
assert!(Command::from_bytes(&[9]).is_none());
|
||
assert!(Command::from_bytes(&[255]).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn command_empty_buffer() {
|
||
assert!(Command::from_bytes(&[]).is_none());
|
||
}
|
||
|
||
// ── Response::write_to ──────────────────────────────────────────
|
||
|
||
#[test]
|
||
fn response_pong() {
|
||
let mut buf = [0u8; 1];
|
||
assert_eq!(Response::Pong.write_to(&mut buf), 1);
|
||
assert_eq!(buf[0], 0);
|
||
}
|
||
|
||
#[test]
|
||
fn response_config() {
|
||
let cfg = make_config();
|
||
let mut buf = [0u8; 1 + RADIO_CONFIG_SIZE];
|
||
let n = Response::Config(cfg).write_to(&mut buf);
|
||
assert_eq!(n, 1 + RADIO_CONFIG_SIZE);
|
||
assert_eq!(buf[0], 1);
|
||
assert_eq!(RadioConfig::from_bytes(&buf[1..]), Some(cfg));
|
||
}
|
||
|
||
#[test]
|
||
fn response_rx_packet() {
|
||
let mut payload = Vec::new();
|
||
let _ = payload.extend_from_slice(b"data");
|
||
let mut buf = [0u8; 64];
|
||
let n = Response::RxPacket {
|
||
rssi: -80,
|
||
snr: 10,
|
||
payload,
|
||
}
|
||
.write_to(&mut buf);
|
||
assert_eq!(n, 7 + 4); // tag(1) + rssi(2) + snr(2) + len(2) + "data"(4)
|
||
assert_eq!(buf[0], 2);
|
||
assert_eq!(i16::from_le_bytes([buf[1], buf[2]]), -80);
|
||
assert_eq!(i16::from_le_bytes([buf[3], buf[4]]), 10);
|
||
assert_eq!(u16::from_le_bytes([buf[5], buf[6]]), 4);
|
||
assert_eq!(&buf[7..11], b"data");
|
||
}
|
||
|
||
#[test]
|
||
fn response_tx_done() {
|
||
let mut buf = [0u8; 1];
|
||
assert_eq!(Response::TxDone.write_to(&mut buf), 1);
|
||
assert_eq!(buf[0], 3);
|
||
}
|
||
|
||
#[test]
|
||
fn response_ok() {
|
||
let mut buf = [0u8; 1];
|
||
assert_eq!(Response::Ok.write_to(&mut buf), 1);
|
||
assert_eq!(buf[0], 4);
|
||
}
|
||
|
||
#[test]
|
||
fn response_error_codes() {
|
||
let mut buf = [0u8; 2];
|
||
for (code, val) in [
|
||
(ErrorCode::InvalidConfig, 0),
|
||
(ErrorCode::RadioBusy, 1),
|
||
(ErrorCode::TxTimeout, 2),
|
||
(ErrorCode::CrcError, 3),
|
||
(ErrorCode::NotConfigured, 4),
|
||
(ErrorCode::NoDisplay, 5),
|
||
] {
|
||
let n = Response::Error(code).write_to(&mut buf);
|
||
assert_eq!(n, 2);
|
||
assert_eq!(buf[0], 5);
|
||
assert_eq!(buf[1], val);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn response_mac_address() {
|
||
let mac = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF];
|
||
let mut buf = [0u8; 7];
|
||
let n = Response::MacAddress(mac).write_to(&mut buf);
|
||
assert_eq!(n, 7);
|
||
assert_eq!(buf[0], 6);
|
||
assert_eq!(&buf[1..7], &mac);
|
||
}
|
||
}
|