display: First part of fetching values from the base station.

common/rust-protocol/src/lib.rs

@@ -84,6 +84,25 @@ impl Packet {
             }
         }
     }
+
+    pub fn get_type(&self) -> PacketType {
+        match self {
+            Self::GetSalt => PacketType::GetSalt,
+            Self::Salt(_) => PacketType::Salt,
+            Self::Report(_) => PacketType::Report,
+            Self::GetValues(_) => PacketType::GetValues,
+            Self::Values(_) => PacketType::Values,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PacketType {
+    GetSalt,
+    Salt,
+    Report,
+    GetValues,
+    Values,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

display/firmware/src/information.rs

@@ -1,5 +1,7 @@
 //! Sensor information or information fetched from the internet.
 
+use super::sensors::BME280Data;
+
 pub struct Information {
     pub time: u32,
     pub valid: bool,
@@ -9,6 +11,8 @@ pub struct Information {
     pub bathroom: Option<TemperatureHumidity>,
 
     pub pressure: Option<u32>,
+
+    pub local: Option<BME280Data>,
 }
 
 #[derive(Copy, Clone)]

display/firmware/src/main.rs

@@ -21,6 +21,7 @@ use mkl25z4_hal::time::{CopyableMonoTimer, NonCopyableMonoTimer, U32Ext};
 use mkl25z4_hal::timer::Timer;
 use mkl25z4_hal::timer::TimerInterrupt;
 use panic_semihosting as _;
+use protocol::{Location, ValueType};
 
 use display::{Display, DisplayState};
 use information::{Information, TemperatureHumidity};
@@ -84,6 +85,7 @@ const APP: () = {
                 outside: None,
                 bathroom: None,
                 pressure: None,
+                local: None,
             },
             display_state: DisplayState::new(),
             display,
@@ -127,16 +129,29 @@ const APP: () = {
         // 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.
+        let mut livingroom = [None; 2];
+        radio.request_values(
+            Location::Livingroom,
+            &[ValueType::Temperature, ValueType::Humidity],
+            &mut livingroom,
+        );
+        let mut balcony = [None; 2];
+        radio.request_values(
+            Location::Balcony,
+            &[ValueType::Temperature, ValueType::Humidity],
+            &mut balcony,
+        );
         // TODO
+
         ctx.resources.info.lock(|info| {
             info.inside = Some(TemperatureHumidity {
                 temperature: values.temperature,
                 humidity: values.humidity,
             });
             info.pressure = Some(values.pressure);
+            info.local = Some(values);
         });
 
         // If the update failed, simply increment the time and place a hint that

display/firmware/src/radio.rs

@@ -1,11 +1,12 @@
 use core::convert::TryInto;
 
 use embedded_hal::blocking::delay::DelayMs;
+use embedded_hal::digital::v2::InputPin;
 use embedded_hal::digital::v2::OutputPin;
-use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, StandbyMode, NRF24L01};
-use mkl25z4_hal::time::CopyableMonoTimer;
+use embedded_nrf24l01::{Configuration, CrcMode, DataRate, StandbyMode, NRF24L01};
+use mkl25z4_hal::time::{CopyableMonoTimer, Instant, MilliSeconds, MonoTimer, U32Ext};
 use mkl25z4_hal::NoError;
-use protocol::{Packet, Report, Value};
+use protocol::{GetValues, Location, Packet, PacketType, Report, Value, ValueType};
 
 use super::pins::{RadioCe, RadioCs, RadioIrq, RadioPins, RadioPwr, RadioSpi};
 use super::sensors::BME280Data;
@@ -80,6 +81,62 @@ 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 {
+        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);
+        self.send_packet(Packet::Report(report));
+
+        true
+    }
+
+    pub fn request_values(
+        &mut self,
+        location: Location,
+        value_types: &[ValueType],
+        values: &mut [Option<i64>],
+    ) -> bool {
+        // We always clear the value array so that the caller can ignore the return value.
+        for i in 0..values.len() {
+            values[i] = None;
+        }
+
+        // Request the values.
+        let mut get_values = GetValues {
+            count: value_types.len() as u8,
+            location,
+            types_: [ValueType::Time; 8],
+        };
+        get_values.types_[0..value_types.len()].copy_from_slice(value_types);
+        self.send_packet(Packet::GetValues(get_values));
+
+        // Receive the response.
+        let response = match self.receive_packet(PacketType::Values, 100.ms()) {
+            None => return false,
+            Some(Packet::Values(values)) => values,
+            _ => return false,
+        };
+
+        for i in 0..response.count {
+            let (type_, value) = match response.values[i as usize].split() {
+                Some(value) => value,
+                None => return false,
+            };
+
+            for j in 0..values.len() {
+                if value_types[j] == type_ {
+                    values[j] = Some(value);
+                }
+            }
+        }
+
+        true
+    }
+
+    fn send_packet(&mut self, packet: Packet) -> bool {
         if self.radio.salt.is_none() {
             if !self.fetch_salt() {
                 return false;
@@ -89,14 +146,6 @@ impl<'a> EnabledRadio<'a> {
         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.
@@ -106,47 +155,52 @@ impl<'a> EnabledRadio<'a> {
     }
 
     fn fetch_salt(&mut self) -> bool {
-        // Request a device ID.
+        self.send_packet_raw(Packet::GetSalt);
+
+        // Wait for the initial salt.
+        match self.receive_packet(PacketType::Salt, 100.ms()) {
+            None => false,
+            Some(Packet::Salt(salt)) => {
+                self.radio.salt = Some((salt & 0x7fffffffffffff00) | DEVICE_ID as u64);
+                true
+            }
+            _ => false,
+        }
+    }
+
+    fn send_packet_raw(&mut self, packet: Packet) -> bool {
         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);
+        packet.encode_and_encrypt(
+            &KEY,
+            self.radio.salt.unwrap_or(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
+        self.nrf24 = Some(tx.standby().unwrap());
+        true
     }
 
-    fn receive_packet(
+    fn receive_packet<T: Into<MilliSeconds>>(
         &mut self,
-        rx: &mut RxMode<NRF24L01<NoError, RadioCe, RadioCs, RadioSpi>>,
+        type_: PacketType,
+        timeout: T,
     ) -> Option<Packet> {
-        // TODO: Timeout.
-        loop {
+        // TODO: Perhaps the radio should stay longer in RX mode?
+        let mut rx = self.nrf24.take().unwrap().rx().unwrap();
+        let timeout = Timeout::new(&self.radio.time, timeout);
+        while !timeout.expired() {
+            // Reduce bus activity as it can negatively affect the radio.
+            // TODO: Wait for proper interrupt to reduce power consumption?
+            if self.radio.irq.is_high().unwrap() {
+                continue;
+            }
+
             if let Some(_pipe) = rx.can_read().unwrap() {
                 // Receive a packet.
-                // TODO: Check pipe?
                 let payload = rx.read().unwrap();
                 if payload.len() != 32 {
                     continue;
@@ -157,10 +211,15 @@ impl<'a> EnabledRadio<'a> {
                     Ok(p) => p,
                     Err(_) => continue,
                 };
+                if packet.get_type() != type_ {
+                    continue;
+                }
 
                 return Some(packet);
             }
         }
+        self.nrf24 = Some(rx.standby());
+        None
     }
 }
 
@@ -173,3 +232,27 @@ impl<'a> Drop for EnabledRadio<'a> {
         self.radio.nrf24 = Some(nrf24);
     }
 }
+
+struct Timeout<'a, Timer> {
+    timer: &'a Timer,
+    start: Instant,
+    timeout: u32,
+}
+
+impl<'a, Timer> Timeout<'a, Timer>
+where
+    Timer: MonoTimer,
+{
+    fn new<T: Into<MilliSeconds>>(timer: &'a Timer, timeout: T) -> Self {
+        let ticks = (timer.frequency().0 as u64 * timeout.into().0 as u64 / 1000) as u32;
+        Self {
+            timer,
+            start: timer.now(),
+            timeout: ticks,
+        }
+    }
+
+    fn expired(&self) -> bool {
+        self.timer.now().elapsed(self.start) > self.timeout
+    }
+}