base-station: Restructure radio code.

base-station/software/Cargo.lock

@@ -31,6 +31,7 @@ dependencies = [
  "log",
  "mqtt-protocol",
  "protocol",
+ "rand",
  "thiserror",
 ]
 
@@ -111,6 +112,17 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.11"
@@ -224,6 +236,12 @@ dependencies = [
  "void",
 ]
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.10"
@@ -256,6 +274,47 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom",
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "regex"
 version = "1.3.7"
@@ -409,6 +468,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
 
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
 [[package]]
 name = "winapi"
 version = "0.3.8"

base-station/software/Cargo.toml

@@ -15,3 +15,4 @@ env_logger = "0.7"
 log = "0.4"
 thiserror = "1.0"
 protocol = { path = "../../common/rust-protocol" }
+rand = "0.7.3"

base-station/software/src/radio.rs

@@ -4,12 +4,15 @@ use std::thread;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
-use embedded_nrf24l01::{Configuration, CrcMode, DataRate, NRF24L01};
+use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, NRF24L01};
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
 use linux_embedded_hal::sysfs_gpio::Direction;
+use linux_embedded_hal::sysfs_gpio::Error as GpioError;
 use linux_embedded_hal::Pin;
 use log::{error, info};
 use protocol::{Location, Packet, Value};
+use rand::rngs::ThreadRng;
+use rand::Rng;
 
 use crate::spi::EmbeddedHalSpidev;
 use crate::Error;
@@ -37,161 +40,225 @@ pub fn start(updates: mpsc::Sender<SensorUpdate>) {
 }
 
 fn radio_thread(updates: &mpsc::Sender<SensorUpdate>) -> Result<(), Error> {
-    info!("Initializing radio...");
-
-    // The NRF module is connected as follows:
-    // - CE: PA1
-    // - CS: PG8
-    // - IRQ: PG9
-    // - MOSI: PC0
-    // - MISO: PC1
-    // - SCK: PC2
-
-    // Configure SPI.
-    let mut spi = Spidev::open("/dev/spidev0.0").unwrap();
-    let options = SpidevOptions::new()
-        .bits_per_word(8)
-        .max_speed_hz(500_000)
-        .mode(SpiModeFlags::SPI_MODE_0)
-        .build();
-    spi.configure(&options).unwrap();
-    let spi = EmbeddedHalSpidev::from(spi);
-
-    // Configure the GPIOs.
-    let ce_nr = get_pin_number('A', 1);
-    let ce = Pin::new(ce_nr);
-    ce.export().unwrap();
-    ce.set_direction(Direction::Out).unwrap();
-    let cs_nr = get_pin_number('G', 8);
-    let cs = Pin::new(cs_nr);
-    cs.export().unwrap();
-    cs.set_direction(Direction::Out).unwrap();
-    let irq_nr = get_pin_number('G', 9);
-    let irq = Pin::new(irq_nr);
-    irq.export().unwrap();
-    irq.set_direction(Direction::In).unwrap();
-
-    // Initialize the radio module.
-    let mut nrf24 = NRF24L01::new(ce, cs, spi)?;
-    nrf24.set_frequency(0x32)?;
-    nrf24.set_rf(DataRate::R2Mbps, 3)?;
-    nrf24.set_crc(Some(CrcMode::OneByte))?;
-    nrf24.set_auto_retransmit(250, 3)?;
-    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(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
-        .unwrap();
-    nrf24.flush_rx().unwrap();
-    nrf24.flush_tx().unwrap();
-    //nrf24.set_auto_ack(&[true; 6]).unwrap();
-    info!("auto ack: {:?}", nrf24.get_auto_ack().unwrap());
-    nrf24.set_pipes_rx_lengths(&[None; 6]).unwrap();
-
-    info!("width: {}", nrf24.get_address_width().unwrap());
-
-    let mut start = Instant::now();
-
-    // Receive data.
-    let mut nrf24 = nrf24.rx().unwrap();
-    info!("Starting to receive:");
-    loop {
-        sleep(Duration::from_millis(1));
-        if let Some(pipe) = nrf24.can_read().unwrap() {
-            let mut payload = nrf24.read().unwrap();
-            info!(
-                "packet received on pipe {}: {:x?}, {}",
-                pipe,
-                payload.as_ref(),
-                payload.len()
-            );
-            if payload.len() != 32 {
-                continue;
-            }
+    let mut radio = Radio::init(updates)?;
+    radio.run_loop()?;
+    Ok(())
+}
 
-            // 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;
-                }
-            };
+struct Radio<'a> {
+    rx: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
+    updates: &'a mpsc::Sender<SensorUpdate>,
+    rng: ThreadRng,
+}
+
+impl<'a> Radio<'a> {
+    fn init(updates: &'a mpsc::Sender<SensorUpdate>) -> Result<Radio<'a>, Error> {
+        info!("Initializing radio...");
+
+        // The NRF module is connected as follows:
+        // - CE: PA1
+        // - CS: PG8
+        // - IRQ: PG9
+        // - MOSI: PC0
+        // - MISO: PC1
+        // - SCK: PC2
+
+        // Configure SPI.
+        let mut spi = Spidev::open("/dev/spidev0.0").unwrap();
+        let options = SpidevOptions::new()
+            .bits_per_word(8)
+            .max_speed_hz(500_000)
+            .mode(SpiModeFlags::SPI_MODE_0)
+            .build();
+        spi.configure(&options).unwrap();
+        let spi = EmbeddedHalSpidev::from(spi);
+
+        // Configure the GPIOs.
+        let ce_nr = get_pin_number('A', 1);
+        let ce = Pin::new(ce_nr);
+        ce.export().unwrap();
+        ce.set_direction(Direction::Out).unwrap();
+        let cs_nr = get_pin_number('G', 8);
+        let cs = Pin::new(cs_nr);
+        cs.export().unwrap();
+        cs.set_direction(Direction::Out).unwrap();
+        let irq_nr = get_pin_number('G', 9);
+        let irq = Pin::new(irq_nr);
+        irq.export().unwrap();
+        irq.set_direction(Direction::In).unwrap();
+
+        // Initialize the radio module.
+        let mut nrf24 = NRF24L01::new(ce, cs, spi)?;
+        nrf24.set_frequency(0x32)?;
+        nrf24.set_rf(DataRate::R2Mbps, 3)?;
+        nrf24.set_crc(Some(CrcMode::OneByte))?;
+        nrf24.set_auto_retransmit(250, 3)?;
+        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(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
+            .unwrap();
+        nrf24.flush_rx().unwrap();
+        nrf24.flush_tx().unwrap();
+        nrf24.set_auto_ack(&[true; 6]).unwrap();
+        info!("auto ack: {:?}", nrf24.get_auto_ack().unwrap());
+        nrf24.set_pipes_rx_lengths(&[Some(32); 6]).unwrap();
+
+        info!("width: {}", nrf24.get_address_width().unwrap());
 
-            // 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);
+        let rx = nrf24.rx().unwrap();
+
+        Ok(Radio {
+            rx: Some(rx),
+            updates,
+            rng: rand::thread_rng(),
+        })
+    }
+
+    fn run_loop(&mut self) -> Result<(), Error> {
+        let mut start = Instant::now();
+
+        // Receive data.
+        info!("Starting to receive:");
+        loop {
+            sleep(Duration::from_millis(1));
+            let rx = self.rx.as_mut().unwrap();
+            if let Some(pipe) = rx.can_read().unwrap() {
+                let payload = rx.read().unwrap();
+                info!(
+                    "packet received on pipe {}: {:x?}, {}",
+                    pipe,
+                    payload.as_ref(),
+                    payload.len()
+                );
+                if payload.len() != 32 {
                     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.
 
-            info!("packet from {}: {:?}", device_id, packet);
+                let mut payload: [u8; 32] = payload.as_ref().try_into().unwrap();
+                self.handle_packet(&mut payload)?;
 
-            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);
-                            }
+                let end = Instant::now();
+                let elapsed = end.duration_since(start);
+                info!("Debug: {:?}", elapsed);
+                start = end;
+            }
+        }
+    }
+
+    fn handle_packet(&mut self, payload: &mut [u8]) -> Result<(), Error> {
+        // Get the key of the device.
+        let device_id = payload[0];
+        let key = match get_key(device_id) {
+            Some(k) => k,
+            None => {
+                info!("packet from unknown device {:02x}", device_id);
+                return Ok(());
+            }
+        };
+
+        // Decode the packet.
+        let packet = match Packet::decrypt_and_decode(key, payload) {
+            None => {
+                info!("invalid packet from device {:02x}", device_id);
+                return Ok(());
+            }
+            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.
+
+        info!("packet from {}: {:?}", device_id, packet);
+
+        match packet {
+            Packet::GetSalt => {
+                self.send_salt(device_id)?;
+            }
+            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.");
                 }
+                // 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.");
             }
+        }
+        Ok(())
+    }
 
-            let end = Instant::now();
-            let elapsed = end.duration_since(start);
-            info!("Debug: {:?}", elapsed);
-            start = end;
+    fn send_salt(&mut self, device_id: u8) -> Result<(), Error> {
+        let salt = (self.rng.gen::<u64>() & !0xff & !(1 << 63)) | device_id as u64;
+        let packet = Packet::Salt(salt);
+        self.send_packet(device_id, packet)
+    }
+
+    fn send_packet(&mut self, device_id: u8, packet: Packet) -> Result<(), Error> {
+        /*let salt = self.rng.gen::<u64>();
+        let mut tx = self
+            .rx
+            .take()
+            .unwrap()
+            .standby()
+            .tx()
+            .map_err(|(_, e)| Error::Radio(e))?;
+        let mut encoded = [0u8; 32];
+        let key = get_key(device_id);
+        if packet.encode_and_encrypt(key.unwrap(), salt, &mut encoded) {
+            tx.set_tx_addr(&[0xB3, 0xB3, 0xB3, 0xB3, device_id])
+                .unwrap();
+            tx.set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, device_id])
+                .unwrap();
+            tx.send(&encoded).unwrap();
+        // TODO: Check whether the packet arrived.
+        } else {
+            info!("could not encode packet {:?}", packet);
         }
+        self.rx = Some(
+            tx.standby()
+                .map_err(Error::Radio)?
+                .rx()
+                .map_err(|(_, e)| Error::Radio(e))?,
+        );*/
+        Ok(())
     }
 }
 
@@ -203,6 +270,14 @@ fn get_location(device_id: u8) -> Location {
     }
 }
 
+fn get_key(device_id: u8) -> Option<&'static [u8]> {
+    match device_id {
+        DISPLAY_ID => Some(&DISPLAY_KEY),
+        WEATHER_STATION_0_ID => Some(&WEATHER_STATION_0_KEY),
+        _ => None,
+    }
+}
+
 fn get_pin_number(c: char, n: u64) -> u64 {
     (c as u64 - 'A' as u64) * 32 + n
 }

common/rust-protocol/src/lib.rs

@@ -17,7 +17,7 @@ pub enum Packet {
 }
 
 impl Packet {
-    pub fn decrypt_and_parse(key: &[u8], data: &mut [u8]) -> Option<Packet> {
+    pub fn decrypt_and_decode(key: &[u8], data: &mut [u8]) -> Option<Packet> {
         decrypt_cbc(key, data);
         let checksummed = &data[8..];
         let remainder = State::<KERMIT>::calculate(&checksummed);