Update packet handling protocol

The packets are not yet encrypted

base-station/software/Cargo.lock

@@ -24,6 +24,7 @@ dependencies = [
 name = "base-station"
 version = "0.1.0"
 dependencies = [
+ "crc16",
  "embedded-hal",
  "embedded-nrf24l01",
  "env_logger",
@@ -31,6 +32,7 @@ dependencies = [
  "log",
  "mqtt-protocol",
  "thiserror",
+ "xxtea-nostd",
 ]
 
 [[package]]
@@ -72,6 +74,12 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 
+[[package]]
+name = "crc16"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "338089f42c427b86394a5ee60ff321da23a5c89c9d89514c829687b26359fcff"
+
 [[package]]
 name = "embedded-hal"
 version = "0.2.3"
@@ -424,3 +432,9 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "xxtea-nostd"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dadadfbf2be7aa1d3b83607115d95f37a9e1d2b91b1978b718df545ad434b9b"

base-station/software/Cargo.toml

@@ -14,3 +14,5 @@ mqtt-protocol = "0.8"
 env_logger = "0.7"
 log = "0.4"
 thiserror = "1.0"
+crc16 = "0.4.0"
+xxtea-nostd = "0.1.0"

base-station/software/src/radio.rs

@@ -4,11 +4,13 @@ use std::thread;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
+use crc16::{State, KERMIT};
 use embedded_nrf24l01::{Configuration, CrcMode, DataRate, NRF24L01};
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
 use linux_embedded_hal::sysfs_gpio::Direction;
 use linux_embedded_hal::Pin;
 use log::{error, info};
+use xxtea_nostd::{decrypt, encrypt};
 
 use crate::spi::EmbeddedHalSpidev;
 use crate::Error;
@@ -93,44 +95,130 @@ fn radio_thread(updates: &mpsc::Sender<SensorUpdate>) -> Result<(), Error> {
         if let Some(pipe) = nrf24.can_read().unwrap() {
             let payload = nrf24.read().unwrap();
             info!(
-                "packet received on pipe {}: {:?}, {}",
+                "packet received on pipe {}: {:x?}, {}",
                 pipe,
                 payload.as_ref(),
                 payload.len()
             );
-            if payload.len() != 13 {
+            if payload.len() != 32 {
                 continue;
             }
 
             let sensor_id = payload.as_ref()[0];
+            let remainder_of_salt = payload.as_ref()[1..7].to_vec();
+
+            // Calculate the CRC
+            let crc_calculation_buffer = payload.as_ref()[8..30].to_vec();
+            let calculated_crc = State::<KERMIT>::calculate(&crc_calculation_buffer);
+            info!("calculated crc: 0x{:x}", calculated_crc);
+            let crc = u16::from_le_bytes(payload.as_ref()[30..32].try_into().unwrap());
+
+            if crc != calculated_crc {
+                info!("malformed packet received: crc mismatch!");
+                info!(
+                    "Calculated crc: 0x{:x}, received crc: 0x{:x}",
+                    calculated_crc, crc
+                );
+                continue;
+            }
 
-            let pressure = u32::from_le_bytes(payload.as_ref()[1..5].try_into().unwrap());
+            let packet_identifier = payload.as_ref()[8];
+            let packet_payload = &payload.as_ref()[9..29];
+            info!("sensor id: 0x{:x}", sensor_id);
+            info!("crc: 0x{:x}", crc);
+
+            let packet_type = packet_identifier & 0x1F;
+            let element_count = (packet_identifier & 0xE0) >> 5;
+            info!("packet_type: 0x{:x}", packet_type);
+            info!("element_count: 0x{:x}", element_count);
+
+            let mut temperature = 0;
+            let mut pressure = 0;
+            let mut humidity = 0;
+
+            if packet_type == 1 {
+                let mut i = 0;
+                let mut buffer_position = 0;
+                info!("report packet received");
+                info!("packet_payload: {:x?}", packet_payload.as_ref());
+                while i < element_count {
+                    let value_type = packet_payload[buffer_position];
+
+                    buffer_position += 1; // Set the position to the value
+
+                    if value_type == 0 {
+                        info!("time value not yet supported");
+                        buffer_position += 8;
+                    } else if value_type == 1 {
+                        temperature = i16::from_le_bytes(
+                            packet_payload[buffer_position..buffer_position + 2]
+                                .try_into()
+                                .unwrap(),
+                        );
+                        info!(
+                            "temp: {:x?}, {:x}",
+                            packet_payload[buffer_position..buffer_position + 2].to_vec(),
+                            temperature
+                        );
+                        buffer_position += 2;
+                    } else if value_type == 2 {
+                        pressure = u32::from_le_bytes(
+                            packet_payload[buffer_position..buffer_position + 4]
+                                .try_into()
+                                .unwrap(),
+                        );
+                        info!(
+                            "pressure: {:x?}, {:x}",
+                            packet_payload[buffer_position..buffer_position + 4].to_vec(),
+                            pressure
+                        );
+                        buffer_position += 4;
+                    } else if value_type == 3 {
+                        humidity = u16::from_le_bytes(
+                            packet_payload[buffer_position..buffer_position + 2]
+                                .try_into()
+                                .unwrap(),
+                        );
+                        info!(
+                            "humidity: {:x?}, {:x}",
+                            packet_payload[buffer_position..buffer_position + 2].to_vec(),
+                            humidity
+                        );
+                        buffer_position += 2;
+                    } else {
+                        info!("unknown value type");
+                    }
+
+                    i += 1;
+                }
+            } else {
+                info!("unknown packet type");
+                continue;
+            }
 
+            /* Check the values for validity */
             if pressure < 50000 || pressure > 150000 {
                 info!("pressure outside of range: {}", pressure);
                 continue;
             }
 
-            let temperature = i32::from_le_bytes(payload.as_ref()[5..9].try_into().unwrap());
-
-            if temperature < -50 * 100 || temperature > 100 * 100 {
+            if temperature < -50 * 10 || temperature > 100 * 10 {
                 info!("temperature outside of range: {}", temperature);
                 continue;
             }
 
-            let humidity = u32::from_le_bytes(payload.as_ref()[9..13].try_into().unwrap());
-            if humidity > 100 * 1024 {
+            if humidity > 1000 {
                 info!("humidity outside of range: {}", humidity);
                 continue;
             }
 
             let pressure = pressure as f32 / 100.0;
-            let temperature = temperature as f32 / 100.0;
-            let humidity = humidity as f32 / 1024.0;
-            info!("sensor id: 0x{:x}", sensor_id);
-            info!("pressure: {}", pressure);
-            info!("temperature: {}", temperature);
-            info!("humidity: {}", humidity);
+            let temperature = temperature as f32 / 10.0;
+            let humidity = humidity as f32 / 102.4;
+            info!("pressure: {} HPa", pressure);
+            info!("temperature: {} °C", temperature);
+            info!("humidity: {}%", humidity);
+
             /*
             updates
                 .send(SensorUpdate {