use super::{
push_ack, write_preamble, Error as PktError, Identifier, MacAddress, SerializablePacket,
};
use serde::{Deserialize, Serialize};
use std::io::{Cursor, Write};
#[derive(Debug, Clone)]
pub struct Packet {
pub random_token: u16,
pub gateway_mac: MacAddress,
pub data: Data,
}
impl Packet {
pub fn from_rxpk(rxpk: RxPk) -> Packet {
let rxpk = vec![rxpk];
Packet {
random_token: 0,
gateway_mac: MacAddress { bytes: [0; 8] },
data: Data {
rxpk: Some(rxpk),
stat: None,
},
}
}
pub fn random() -> Packet {
let rxpk = vec![RxPk::V1(RxPkV1 {
chan: 0,
codr: "4/5".to_string(),
data: "AA=".to_string(),
datr: "SF8BW500".to_string(),
freq: 902.800_000,
lsnr: -15.0,
modu: "Foo".to_string(),
rfch: 0,
rssi: -80,
size: 12,
stat: 12,
tmst: 12,
})];
Packet {
random_token: rand::random(),
gateway_mac: MacAddress { bytes: [0; 8] },
data: Data {
rxpk: Some(rxpk),
stat: None,
},
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Data {
#[serde(skip_serializing_if = "Option::is_none")]
pub rxpk: Option<Vec<RxPk>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub stat: Option<Stat>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RxPkV1 {
pub chan: u64,
pub codr: String,
pub data: String,
pub datr: String,
pub freq: f64,
pub lsnr: f32,
pub modu: String,
pub rfch: u64,
pub rssi: i32,
pub size: u64,
pub stat: u64,
pub tmst: u64,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RxPkV2 {
pub aesk: usize,
pub brd: usize,
pub codr: String,
pub data: String,
pub datr: String,
pub freq: f64,
pub jver: usize,
pub modu: String,
pub rsig: Vec<RSig>,
pub size: u64,
pub stat: u64,
pub tmst: u64,
pub delayed: Option<bool>,
pub tmms: Option<u64>,
pub time: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RSig {
pub ant: usize,
pub chan: u64,
pub rssic: i32,
pub rssis: Option<i32>,
pub lsnr: f32,
pub etime: Option<String>,
pub foff: Option<i64>,
pub ftstat: Option<u8>,
pub ftver: Option<usize>,
pub ftdelta: Option<isize>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum RxPk {
V1(RxPkV1),
V2(RxPkV2),
}
macro_rules! get_field {
($self:expr, $field:ident) => {
match $self {
RxPk::V1(pk) => &pk.$field,
RxPk::V2(pk) => &pk.$field,
}
};
}
impl RxPk {
pub fn get_snr(&self) -> f32 {
match self {
RxPk::V1(pk) => pk.lsnr,
RxPk::V2(pk) => pk.rsig[0].lsnr,
}
}
pub fn get_rssi(&self) -> i32 {
match self {
RxPk::V1(pk) => pk.rssi,
RxPk::V2(pk) => {
pk.rsig[0].rssic
}
}
}
pub fn get_frequency(&self) -> &f64 {
get_field!(self, freq)
}
pub fn get_data(&self) -> String {
get_field!(self, data).clone()
}
pub fn get_timestamp(&self) -> &u64 {
get_field!(self, tmst)
}
pub fn get_datarate(&self) -> String {
get_field!(self, datr).clone()
}
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Stat {
time: String,
#[serde(skip_serializing_if = "Option::is_none")]
lati: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
long: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
alti: Option<u64>,
rxnb: u64,
rxok: u64,
rxfw: u64,
ackr: f64,
dwnb: u64,
txnb: u64,
}
impl SerializablePacket for Packet {
fn serialize(&self, buffer: &mut [u8]) -> std::result::Result<u64, PktError> {
let mut w = Cursor::new(buffer);
write_preamble(&mut w, self.random_token)?;
w.write_all(&[Identifier::PushData as u8])?;
w.write_all(&self.gateway_mac.bytes())?;
w.write_all(&serde_json::to_string(&self.data)?.as_bytes())?;
Ok(w.position())
}
}
impl From<Packet> for super::Packet {
fn from(packet: Packet) -> super::Packet {
super::Packet::Up(super::Up::PushData(packet))
}
}
impl Packet {
pub fn into_ack(self) -> push_ack::Packet {
push_ack::Packet {
random_token: self.random_token,
}
}
}