Add range checks for the received values and fix formatting

base-station/software/rustfmt.toml

-edition = 2018
+edition = "2018"

base-station/software/src/main.rs

 use std::env;
 use std::io;
+use std::sync::mpsc;
 use std::thread::sleep;
 use std::time::Duration;
-use std::sync::mpsc;
 
-use log::error;
 use ::mqtt::control::variable_header::ConnectReturnCode;
+use log::error;
 
 use crate::mqtt::MQTT;
 
             _ => {
                 error!("Unknown location in sensor update.");
                 continue;
-            },
+            }
         };
         for value in update.data.iter() {
             match value {
                 SensorData::Temperature(value) => {
-                    m.publish(&format!("gottschlag/{}/temperature", location), &format!("{}", value))?;
-                },
+                    m.publish(
+                        &format!("gottschlag/{}/temperature", location),
+                        &format!("{}", value),
+                    )?;
+                }
                 SensorData::Humidity(value) => {
-                    m.publish(&format!("gottschlag/{}/humidity", location), &format!("{}", value))?;
-                },
+                    m.publish(
+                        &format!("gottschlag/{}/humidity", location),
+                        &format!("{}", value),
+                    )?;
+                }
                 SensorData::Pressure(value) => {
-                    m.publish(&format!("gottschlag/{}/pressure", location), &format!("{}", value))?;
+                    m.publish(
+                        &format!("gottschlag/{}/pressure", location),
+                        &format!("{}", value),
+                    )?;
                 }
             }
         }
     Pressure(f32),
 }
 
-
-
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("I/O error")]
     #[error("connection refused, return code {0:?}")]
     ConnectionRefused(ConnectReturnCode),
     #[error("radio error: {0:?}")]
-    Radio(embedded_nrf24l01::Error<std::io::Error>)
+    Radio(embedded_nrf24l01::Error<std::io::Error>),
 }
 
 impl From<embedded_nrf24l01::Error<std::io::Error>> for Error {

base-station/software/src/mqtt.rs

 use std::net::TcpStream;
 use std::thread;
 
-use log::{info, error};
+use log::{error, info};
 use mqtt::control::variable_header::ConnectReturnCode;
 use mqtt::packet::*;
 use mqtt::{Decodable, Encodable, QualityOfService};
                         // Nothing to do here, the other end closes the connection.
                         break;
                     }
-                    _ => {},
+                    _ => {}
                 }
             }
         });
 
-        Ok(MQTT{
-            stream
-        })
+        Ok(MQTT { stream })
     }
 
     pub fn publish(&mut self, topic: &str, value: &str) -> Result<(), Error> {

base-station/software/src/radio.rs

 use std::convert::TryInto;
+use std::sync::mpsc;
 use std::thread;
 use std::time::{Duration, Instant};
-use std::sync::mpsc;
 
 use embedded_nrf24l01::{Configuration, CrcMode, DataRate, NRF24L01};
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
 
 use crate::spi::EmbeddedHalSpidev;
 use crate::Error;
-use crate::{SensorUpdate, SensorData};
+use crate::{SensorData, SensorUpdate};
 
 pub fn start(updates: mpsc::Sender<SensorUpdate>) {
     // TODO: Channels for sensor readings.
     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])
-        ?;
+    nrf24.set_pipes_rx_enable(&[true, false, false, false, false, false])?;
     nrf24
         .set_rx_addr(0, &[0x56, 0x34, 0x12, 0x00, 0x00])
         .unwrap();
     loop {
         if let Some(pipe) = nrf24.can_read().unwrap() {
             let payload = nrf24.read().unwrap();
-            info!("packet received on pipe {}: {:?}, {}", pipe, payload.as_ref(), payload.len());
+            info!(
+                "packet received on pipe {}: {:?}, {}",
+                pipe,
+                payload.as_ref(),
+                payload.len()
+            );
+            if payload.len() != 12 {
+                continue;
+            }
+
             let pressure = u32::from_le_bytes(payload.as_ref()[0..4].try_into().unwrap());
-            let temperature = u32::from_le_bytes(payload.as_ref()[4..8].try_into().unwrap());
+
+            if pressure < 50000 || pressure > 150000 {
+                info!("pressure outside of range: {}", pressure);
+                continue;
+            }
+
+            let temperature = i32::from_le_bytes(payload.as_ref()[4..8].try_into().unwrap());
+
+            if temperature < -50 * 100 || temperature > 100 * 100 {
+                info!("temperature outside of range: {}", temperature);
+                continue;
+            }
+
             let humidity = u32::from_le_bytes(payload.as_ref()[8..12].try_into().unwrap());
+            if humidity > 100 * 1024 {
+                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!("pressure: {}", pressure);
             info!("temperature: {}", temperature);
             info!("humidity: {}", humidity);
-            updates.send(SensorUpdate{
-                location: 0,
-                data: vec![SensorData::Temperature(temperature), SensorData::Pressure(pressure), SensorData::Humidity(humidity)],
-            }).unwrap();
+            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);