140 lines
3.2 KiB
Rust
140 lines
3.2 KiB
Rust
pub const IMPROV_HEADER: [u8; 6] = [
|
|
'I' as u8,
|
|
'M' as u8,
|
|
'P' as u8,
|
|
'R' as u8,
|
|
'O' as u8,
|
|
'V' as u8,
|
|
];
|
|
|
|
pub const IMPROV_VERSION: u8 = 0x01;
|
|
|
|
#[derive(Clone, PartialEq)]
|
|
#[repr(u8)]
|
|
pub enum PacketType {
|
|
CurrentState = 0x01,
|
|
ErrorState = 0x02,
|
|
RPCCommand = 0x03,
|
|
RPCResult = 0x04,
|
|
}
|
|
|
|
impl TryFrom<&u8> for PacketType {
|
|
type Error= &'static str;
|
|
|
|
fn try_from(b: &u8) -> Result<Self, Self::Error> {
|
|
match b {
|
|
0x01 => Ok(Self::CurrentState),
|
|
0x02 => Ok(Self::ErrorState),
|
|
0x03 => Ok(Self::RPCCommand),
|
|
0x04 => Ok(Self::RPCResult),
|
|
_ => Err("Cannot convert to packet type"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for PacketType {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::CurrentState => write!(f, "Current State"),
|
|
Self::ErrorState => write!(f, "Error State"),
|
|
Self::RPCCommand => write!(f, "RPC Command"),
|
|
Self::RPCResult => write!(f, "RPC Result"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
#[repr(u8)]
|
|
pub enum CurrentState {
|
|
Ready = 0x02,
|
|
Provisioning = 0x03,
|
|
Provisioned = 0x04,
|
|
}
|
|
|
|
|
|
impl TryFrom<&u8> for CurrentState {
|
|
type Error= &'static str;
|
|
|
|
fn try_from(b: &u8) -> Result<Self, Self::Error> {
|
|
match b {
|
|
0x02 => Ok(Self::Ready),
|
|
0x03 => Ok(Self::Provisioning),
|
|
0x04 => Ok(Self::Provisioned),
|
|
_ => Err("Cannot convert to current state"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for CurrentState {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Ready => write!(f, "Ready"),
|
|
Self::Provisioning => write!(f, "Provisioning"),
|
|
Self::Provisioned => write!(f, "Provisioned"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
#[repr(u8)]
|
|
pub enum ErrorState {
|
|
NoError = 0x00,
|
|
InvalidRPCPacket = 0x01,
|
|
UnknownRPCCommand = 0x02,
|
|
UnableToConnect = 0x03,
|
|
UnknownError = 0xFF,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
#[repr(u8)]
|
|
pub enum RPCCommand {
|
|
SendWifiSettings = 0x01,
|
|
RequestCurrentState = 0x02,
|
|
}
|
|
|
|
pub fn calculate_checksum(data: &Vec<u8>) -> u8 {
|
|
// Pass data as full packet, with header, but without checksum byte
|
|
|
|
let mut checksum: u8 = 0x00;
|
|
|
|
for e in data {
|
|
checksum = checksum.wrapping_add(e.clone());
|
|
}
|
|
|
|
return checksum;
|
|
}
|
|
|
|
pub struct ImprovPacket {
|
|
pub version: u8,
|
|
pub r#type: PacketType,
|
|
pub data: Vec<u8>,
|
|
}
|
|
|
|
impl ImprovPacket {
|
|
pub fn try_from_bytes(bytes: &Vec<u8>) -> Result<Self, &str> {
|
|
if bytes.len() < 11 {
|
|
return Err("Packet too small");
|
|
}
|
|
|
|
for i in 0..5 {
|
|
if bytes[i] != IMPROV_HEADER[i] {
|
|
return Err("Improv header not found");
|
|
}
|
|
}
|
|
|
|
let data: Vec<u8> = Vec::new();
|
|
|
|
let length: usize = bytes[8].into();
|
|
|
|
if bytes.len() != length + 10 {
|
|
return Err("Packet with invalid length");
|
|
}
|
|
|
|
return Ok(Self {
|
|
version: bytes[6],
|
|
r#type: PacketType::try_from(&bytes[7])?,
|
|
data: bytes[9..(bytes.len()-1)].to_vec(),
|
|
});
|
|
}
|
|
}
|