base-station: Use rust-protocol library for packet handling.

base-station/software/Cargo.lock

 name = "base-station"
 version = "0.1.0"
 dependencies = [
- "crc16",
  "embedded-hal",
  "embedded-nrf24l01",
  "env_logger",
  "linux-embedded-hal",
  "log",
  "mqtt-protocol",
+ "protocol",
  "thiserror",
- "xxtea-nostd",
 ]
 
 [[package]]
  "unicode-xid",
 ]
 
+[[package]]
+name = "protocol"
+version = "0.1.0"
+dependencies = [
+ "crc16",
+ "xxtea-nostd",
+]
+
 [[package]]
 name = "quick-error"
 version = "1.2.3"

base-station/software/Cargo.toml

 env_logger = "0.7"
 log = "0.4"
 thiserror = "1.0"
-crc16 = "0.4.0"
-xxtea-nostd = "0.1.0"
+protocol = { path = "../../common/rust-protocol" }

base-station/software/src/radio.rs

 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 protocol::{Location, Packet, Value};
 
 use crate::spi::EmbeddedHalSpidev;
 use crate::Error;
 use crate::{SensorData, SensorUpdate};
 
+const DISPLAY_ID: u8 = 0x20;
+const DISPLAY_KEY: [u8; 16] = include!("../../../common/display_key.txt");
+const WEATHER_STATION_0_ID: u8 = 0x30;
+const WEATHER_STATION_0_KEY: [u8; 16] = include!("../../../common/weather_station_0_key.txt");
+
 pub fn start(updates: mpsc::Sender<SensorUpdate>) {
     // TODO: Channels for sensor readings.
     thread::spawn(move || {
     nrf24.set_rf(DataRate::R2Mbps, 3)?;
     nrf24.set_crc(Some(CrcMode::OneByte))?;
     nrf24.set_auto_retransmit(250, 3)?;
-    nrf24.set_pipes_rx_enable(&[false, true, false, false, false, false])?; // TODO enable pipe 0 once the base station receives messages
+    nrf24.set_pipes_rx_enable(&[true, false, false, false, false, false])?; // TODO enable pipe 0 once the base station receives messages
     nrf24
-        .set_rx_addr(1, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
+        .set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
         .unwrap();
     nrf24.flush_rx().unwrap();
     nrf24.flush_tx().unwrap();
                 continue;
             }
 
-            let mut payload = payload.as_ref().to_vec();
-
-            let sensor_id = payload[0];
-
-            // Decrypt the package
-            let key = [
-                0x9e, 0x37, 0x79, 0xb9, 0x9b, 0x97, 0x73, 0xe9, 0xb9, 0x79, 0x37, 0x9e, 0x6b, 0x69,
-                0x51, 0x56,
-            ]; //TODO: define somewhere else
-            decrypt_cbc(&key, &mut payload);
-            info!("decrypted: {:x?}", payload);
-
-            // Calculate the CRC
-            let crc_calculation_buffer = payload[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[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 packet_identifier = payload[8];
-            let packet_payload = &payload[9..30];
-            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;
-
-            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");
-                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(),
-                        );
-                        buffer_position += 2;
-                    } else if value_type == 2 {
-                        pressure = u32::from_le_bytes(
-                            packet_payload[buffer_position..buffer_position + 4]
-                                .try_into()
-                                .unwrap(),
-                        );
-                        buffer_position += 4;
-                    } else if value_type == 3 {
-                        humidity = u16::from_le_bytes(
-                            packet_payload[buffer_position..buffer_position + 2]
-                                .try_into()
-                                .unwrap(),
-                        );
-                        buffer_position += 2;
-                    } else {
-                        info!("unknown value type");
-                    }
-
-                    i += 1;
+            // Get the key of the device.
+            let device_id = payload[0];
+            let key = match device_id {
+                DISPLAY_ID => &DISPLAY_KEY,
+                WEATHER_STATION_0_ID => &WEATHER_STATION_0_KEY,
+                _ => {
+                    info!("packet from unknown device {:02x}", device_id);
+                    continue;
                 }
-            } else {
-                info!("unknown packet type");
-                continue;
-            }
+            };
+
+            // Decode the packet.
+            let mut payload: [u8; 32] = payload.as_ref().try_into().unwrap();
+            let packet = match Packet::decrypt_and_parse(key, &mut payload) {
+                None => {
+                    info!("invalid packet from device {:02x}", device_id);
+                    continue;
+                }
+                Some(p) => p,
+            };
+            // TODO: For all packets except for salt requests, check whether the
+            // salt was incremented to prevent replay attacks.
+            // TODO: Also check whether the device bit in the salt is 0.
 
-            /* Check the values for validity */
-            if pressure < 50000 || pressure > 150000 {
-                info!("pressure outside of range: {}", pressure);
-                continue;
-            }
+            info!("packet from {}: {:?}", device_id, packet);
 
-            if temperature < -50 * 10 || temperature > 100 * 10 {
-                info!("temperature outside of range: {}", temperature);
-                continue;
-            }
-
-            if humidity > 10000 {
-                info!("humidity outside of range: {}", humidity);
-                continue;
+            match packet {
+                Packet::GetSalt => {
+                    // TODO
+                }
+                Packet::Salt(_) => {
+                    error!("received Salt packet from device.");
+                }
+                Packet::Report(payload) => {
+                    let location = get_location(device_id);
+                    let count = payload.count;
+                    for i in 0..count {
+                        match payload.values[i as usize] {
+                            Value::Invalid => {}
+                            Value::Time(_) => {
+                                error!("device tried to report a time");
+                            }
+                            Value::Temperature(temperature) => {
+                                let temperature = temperature as f32 / 10.0;
+                                info!("{:?} temperature: {} °C", location, temperature);
+                            }
+                            Value::Pressure(pressure) => {
+                                let pressure = pressure as f32 / 100.0;
+                                info!("{:?} pressure: {} HPa", location, pressure);
+                            }
+                            Value::Humidity(humidity) => {
+                                let humidity = humidity as f32 / 100.0;
+                                info!("{:?} humidity: {}%", location, humidity);
+                            }
+                        }
+                    }
+                    // TODO: Send values via MQTT
+                    /*
+                    updates
+                        .send(SensorUpdate {
+                            location: 0,
+                            data: vec![
+                                SensorData::Temperature(temperature),
+                                SensorData::Pressure(pressure),
+                                SensorData::Humidity(humidity),
+                            ],
+                        })
+                        .unwrap();
+                    */
+                }
+                Packet::GetValues(_payload) => {
+                    error!("GetValues not yet implemented.");
+                    // TODO
+                }
+                Packet::Values(_payload) => {
+                    error!("received Values packet from device.");
+                }
             }
 
-            let pressure = pressure as f32 / 100.0;
-            let temperature = temperature as f32 / 10.0;
-            let humidity = humidity as f32 / 100.0;
-            info!("pressure: {} HPa", pressure);
-            info!("temperature: {} °C", temperature);
-            info!("humidity: {}%", humidity);
-
-            /*
-            updates
-                .send(SensorUpdate {
-                    location: 0,
-                    data: vec![
-                        SensorData::Temperature(temperature),
-                        SensorData::Pressure(pressure),
-                        SensorData::Humidity(humidity),
-                    ],
-                })
-                .unwrap();
-            */
             let end = Instant::now();
             let elapsed = end.duration_since(start);
             info!("Debug: {:?}", elapsed);
     }
 }
 
-fn decrypt_cbc(key: &[u8], data: &mut [u8]) {
-    let mut blocks = data.rchunks_mut(8).peekable();
-    loop {
-        let block = blocks.next().unwrap();
-        let prev_block = match blocks.peek() {
-            Some(b) => b,
-            None => break,
-        };
-        decrypt(&key, block);
-
-        for i in 0..8 {
-            block[i] ^= prev_block[i];
-        }
+fn get_location(device_id: u8) -> Location {
+    match device_id {
+        DISPLAY_ID => Location::Bedroom,
+        WEATHER_STATION_0_ID => Location::Livingroom,
+        _ => Location::Livingroom,
     }
 }