display: Add some radio code to fetch a salt and send the first report.

display/firmware/Cargo.toml

@@ -21,9 +21,10 @@ mkl25z4-hal = { git = "https://github.com/mgottschlag/mkl25z4-hal" }
 embedded-hal = "0.2.3"
 nb = "0.1.2"
 bme280 = { git = "https://github.com/mgottschlag/bme280-rs", branch = "destroy" }
-embedded-nrf24l01 = { git = "https://github.com/astro/embedded-nrf24l01" }
+embedded-nrf24l01 = { git = "https://github.com/mgottschlag/embedded-nrf24l01", branch = "wip" }
 epd-waveshare = { git = "https://github.com/mgottschlag/epd-waveshare.git", branch = "streaming" }
 tinygfx = { git = "https://github.com/mgottschlag/tinygfx" }
+protocol = { path = "../../common/rust-protocol" }
 
 [dependencies.void]
 default-features = false

display/firmware/src/main.rs

@@ -4,6 +4,7 @@
 mod display;
 mod information;
 mod pins;
+mod radio;
 mod sensors;
 
 // TODO: Enable warnings again.
@@ -19,6 +20,7 @@ use panic_semihosting as _;
 use display::{Display, DisplayState};
 use information::{Information, TemperatureHumidity};
 use pins::{BME280Pins, DisplayBmeSpi};
+use radio::Radio;
 
 #[rtfm::app(device = mkl25z4_hal::mkl25z4, peripherals = true)]
 const APP: () = {
@@ -28,6 +30,7 @@ const APP: () = {
         display: Display,
         display_bme_spi: Option<DisplayBmeSpi>,
         bme_pins: Option<BME280Pins>,
+        radio: Option<Radio>,
         time: CopyableMonoTimer,
     }
 
@@ -58,6 +61,8 @@ const APP: () = {
 
         let display = Display::init(pins.display, &mut pins.display_bme_spi, time);
 
+        let radio = Radio::init(pins.nrf, time);
+
         // Fetch the first update.
         ctx.spawn.fetch_update().ok();
 
@@ -76,6 +81,7 @@ const APP: () = {
             display,
             display_bme_spi: Some(pins.display_bme_spi),
             bme_pins: Some(pins.bme),
+            radio: Some(radio),
             time,
         }
     }
@@ -94,7 +100,7 @@ const APP: () = {
         // TODO
     }
 
-    #[task(priority = 1, spawn = [update_display], resources = [info, bme_pins, display_bme_spi, &time])]
+    #[task(priority = 1, spawn = [update_display], resources = [info, bme_pins, display_bme_spi, &time, radio])]
     fn fetch_update(mut ctx: fetch_update::Context) {
         // Fetch local updates.
         let time = ctx.resources.time.clone();
@@ -109,6 +115,8 @@ const APP: () = {
 
         // Send local measurements to the base station. This needs to be done before fetching data
         // from the base station as the base station might return the data to us.
+        let mut radio = ctx.resources.radio.as_mut().unwrap().enable();
+        radio.send_sensor_values(values);
         // TODO
 
         // Fetch updates via radio.

display/firmware/src/pins.rs

@@ -38,6 +38,30 @@ pub type DisplayBmeSpi = Spi<
     gpioc::PC5<gpio::Alternate2>,
 >;
 
+pub type RadioIrq = gpiob::PB0<gpio::Input<gpio::PullUp>>;
+pub type RadioCs = gpiob::PB1<gpio::Output<gpio::PushPull>>;
+pub type RadioCe = gpiob::PB2<gpio::Output<gpio::PushPull>>;
+pub type RadioPwr = gpiob::PB3<gpio::Output<gpio::PushPull>>;
+pub type RadioSpi = Spi<
+    SPI1,
+    gpiob::PB16<gpio::Alternate2>,
+    gpiob::PB17<gpio::Alternate2>,
+    gpiod::PD5<gpio::Alternate2>,
+>;
+
+pub struct RadioPins {
+    /// NRF IRQ line (active low).
+    pub irq: RadioIrq,
+    /// NRF chip select (active low).
+    pub cs: RadioCs,
+    /// NRF chip enable.
+    pub ce: RadioCe,
+    /// NRF supply voltage enable (active low).
+    pub pwr: RadioPwr,
+    /// SPI for the NRF module.
+    pub spi: RadioSpi,
+}
+
 pub struct Pins {
     /// 5V supply for the LED (active high).
     pub enable_5v: gpioa::PA1<gpio::Output<gpio::PushPull>>,
@@ -75,21 +99,7 @@ pub struct Pins {
     /// Buzzer (active high).
     pub buzzer: gpioc::PC3<gpio::Output<gpio::PushPull>>,
 
-    /// NRF IRQ line (active low).
-    pub nrf_irq: gpiob::PB0<gpio::Input<gpio::PullUp>>,
-    /// NRF chip select (active low).
-    pub nrf_cs: gpiob::PB1<gpio::Output<gpio::PushPull>>,
-    /// NRF chip enable.
-    pub nrf_ce: gpiob::PB2<gpio::Output<gpio::PushPull>>,
-    /// NRF supply voltage enable (active low).
-    pub nrf_pwr: gpiob::PB3<gpio::Output<gpio::PushPull>>,
-    /// SPI for the NRF module.
-    pub nrf_spi: Spi<
-        SPI1,
-        gpiob::PB16<gpio::Alternate2>,
-        gpiob::PB17<gpio::Alternate2>,
-        gpiod::PD5<gpio::Alternate2>,
-    >,
+    pub nrf: RadioPins,
 
     pub display: DisplayPins,
 
@@ -158,11 +168,13 @@ impl Pins {
             als_en: gpioe.pe20.into_push_pull_output(&mut gpioe.pddr),
             als: gpioe.pe21.into_floating_input(&mut gpioe.pddr),
             buzzer: gpioc.pc3.into_push_pull_output(&mut gpioc.pddr),
-            nrf_irq: gpiob.pb0.into_pull_up_input(&mut gpiob.pddr),
-            nrf_cs: gpiob.pb1.into_push_pull_output(&mut gpiob.pddr),
-            nrf_ce: gpiob.pb2.into_push_pull_output(&mut gpiob.pddr),
-            nrf_pwr: gpiob.pb3.into_push_pull_output(&mut gpiob.pddr),
-            nrf_spi: spi1,
+            nrf: RadioPins {
+                irq: gpiob.pb0.into_pull_up_input(&mut gpiob.pddr),
+                cs: gpiob.pb1.into_push_pull_output(&mut gpiob.pddr),
+                ce: gpiob.pb2.into_push_pull_output(&mut gpiob.pddr),
+                pwr: gpiob.pb3.into_push_pull_output(&mut gpiob.pddr),
+                spi: spi1,
+            },
 
             display: DisplayPins {
                 busy: gpioc.pc4.into_pull_up_input(&mut gpioc.pddr),
@@ -184,8 +196,8 @@ impl Pins {
         pins.enable_5v.set_low().ok();
         pins.als_en.set_low().ok();
         pins.buzzer.set_low().ok();
-        pins.nrf_cs.set_high().ok();
-        pins.nrf_pwr.set_high().ok();
+        pins.nrf.cs.set_high().ok();
+        pins.nrf.pwr.set_high().ok();
         pins.display.cs.set_high().ok();
         pins.display.pwr.set_high().ok();
         pins.bme.pwr.set_high().ok();

display/firmware/src/radio.rs

@@ -0,0 +1,175 @@
+use core::convert::TryInto;
+
+use embedded_hal::blocking::delay::DelayMs;
+use embedded_hal::digital::v2::OutputPin;
+use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, StandbyMode, NRF24L01};
+use mkl25z4_hal::time::CopyableMonoTimer;
+use mkl25z4_hal::NoError;
+use protocol::{Packet, Report, Value};
+
+use super::pins::{RadioCe, RadioCs, RadioIrq, RadioPins, RadioPwr, RadioSpi};
+use super::sensors::BME280Data;
+
+const DEVICE_ID: u8 = 0x20;
+const KEY: [u8; 16] = include!("../../../common/display_key.txt");
+
+pub struct Radio {
+    nrf24: Option<NRF24L01<NoError, RadioCe, RadioCs, RadioSpi>>,
+    pwr: RadioPwr,
+    irq: RadioIrq,
+    salt: Option<u64>,
+    time: CopyableMonoTimer,
+}
+
+impl Radio {
+    pub fn init(mut pins: RadioPins, time: CopyableMonoTimer) -> Radio {
+        pins.pwr.set_low().ok();
+        let nrf24 = NRF24L01::new(pins.ce, pins.cs, pins.spi).unwrap();
+        let nrf24 = nrf24.power_down().unwrap();
+        pins.pwr.set_high().ok();
+        Radio {
+            nrf24: Some(nrf24),
+            pwr: pins.pwr,
+            irq: pins.irq,
+            salt: None,
+            time,
+        }
+    }
+
+    pub fn enable<'a>(&'a mut self) -> EnabledRadio<'a> {
+        // Enable supply voltage.
+        self.pwr.set_low().ok();
+        self.time.delay_ms(10u8);
+
+        // Configure the device.
+        let nrf24 = self.nrf24.take().unwrap();
+        let mut nrf24 = StandbyMode::power_up(nrf24).unwrap();
+        self.time.delay_ms(2u8);
+        nrf24.set_frequency(0x32).unwrap();
+        nrf24.set_rf(DataRate::R2Mbps, 3).unwrap();
+        nrf24.set_crc(Some(CrcMode::OneByte)).unwrap();
+        nrf24.set_auto_retransmit(250, 1).unwrap();
+        nrf24.set_auto_ack(&[true; 6]).unwrap();
+        nrf24
+            .set_pipes_rx_enable(&[true, true, false, false, false, false])
+            .unwrap();
+        nrf24.set_tx_addr(&[0xB3, 0xB3, 0xB3, 0xB3, 0x00]).unwrap();
+        nrf24
+            .set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
+            .unwrap();
+        nrf24
+            .set_rx_addr(1, &[0xB3, 0xB3, 0xB3, 0xB3, 0x20])
+            .unwrap();
+        nrf24.flush_rx().unwrap();
+        nrf24.flush_tx().unwrap();
+        nrf24.set_pipes_rx_lengths(&[Some(32); 6]).unwrap();
+
+        EnabledRadio {
+            radio: self,
+            nrf24: Some(nrf24),
+        }
+    }
+}
+
+pub struct EnabledRadio<'a> {
+    radio: &'a mut Radio,
+    nrf24: Option<StandbyMode<NRF24L01<NoError, RadioCe, RadioCs, RadioSpi>>>,
+}
+
+impl<'a> EnabledRadio<'a> {
+    // TODO: Use generic "SensorValues" instead of BME280Data, which includes ambient light
+    // readings
+    pub fn send_sensor_values(&mut self, values: BME280Data) -> bool {
+        if self.radio.salt.is_none() {
+            if !self.fetch_salt() {
+                return false;
+            }
+        }
+
+        let mut tx = self.nrf24.take().unwrap().tx().unwrap();
+        while !tx.can_send().unwrap() {}
+        let mut payload = [0u8; 32];
+        let mut report = Report {
+            count: 3,
+            values: [Value::Invalid; 8],
+        };
+        report.values[0] = Value::Temperature(values.temperature as i16);
+        report.values[1] = Value::Pressure(values.pressure);
+        report.values[2] = Value::Humidity(values.humidity as u16);
+        let packet = Packet::Report(report);
+        packet.encode_and_encrypt(&KEY, self.radio.salt.unwrap(), &mut payload);
+        tx.send(&payload).unwrap();
+        // TODO: Check whether the packet arrived.
+
+        self.nrf24 = Some(tx.standby().unwrap());
+        true
+    }
+
+    fn fetch_salt(&mut self) -> bool {
+        // Request a device ID.
+        let mut tx = self.nrf24.take().unwrap().tx().unwrap();
+        while !tx.can_send().unwrap() {}
+        let mut payload = [0u8; 32];
+        let packet = Packet::GetSalt;
+        packet.encode_and_encrypt(&KEY, DEVICE_ID as u64, &mut payload);
+        tx.send(&payload).unwrap();
+        // TODO: Check whether the packet arrived.
+
+        // Wait for the initial salt.
+        let mut salt_received = false;
+        let mut rx = tx.standby().unwrap().rx().unwrap();
+        loop {
+            let packet = match self.receive_packet(&mut rx) {
+                None => break,
+                Some(p) => p,
+            };
+
+            match packet {
+                Packet::Salt(salt) => {
+                    self.radio.salt = Some((salt & 0x7fffffffffffff00) | DEVICE_ID as u64);
+                    salt_received = true;
+                    break;
+                }
+                _ => continue,
+            }
+        }
+
+        self.nrf24 = Some(rx.standby());
+        salt_received
+    }
+
+    fn receive_packet(
+        &mut self,
+        rx: &mut RxMode<NRF24L01<NoError, RadioCe, RadioCs, RadioSpi>>,
+    ) -> Option<Packet> {
+        // TODO: Timeout.
+        loop {
+            if let Some(_pipe) = rx.can_read().unwrap() {
+                // Receive a packet.
+                // TODO: Check pipe?
+                let payload = rx.read().unwrap();
+                if payload.len() != 32 {
+                    continue;
+                }
+                let mut payload: [u8; 32] = payload[0..32].try_into().unwrap();
+
+                let packet = match Packet::decrypt_and_decode(&KEY, &mut payload) {
+                    Ok(p) => p,
+                    Err(_) => continue,
+                };
+
+                return Some(packet);
+            }
+        }
+    }
+}
+
+impl<'a> Drop for EnabledRadio<'a> {
+    fn drop(&mut self) {
+        let nrf24 = self.nrf24.take().unwrap();
+        // Disable the chip and remove the supply voltage.
+        let nrf24 = nrf24.power_down().unwrap();
+        self.radio.pwr.set_high().ok();
+        self.radio.nrf24 = Some(nrf24);
+    }
+}

display/firmware/src/sensors.rs

@@ -34,6 +34,7 @@ pub fn bme280(
     )
 }
 
+#[derive(Clone, Copy)]
 pub struct BME280Data {
     pub temperature: i32,
     pub humidity: u32,