Merge branch 'main' into v0.6.0-mqtt

Cargo.toml

@@ -6,7 +6,9 @@ edition = "2021"
 [dependencies]
 anyhow = "1.0.86"
 bincode = "1.3.3"
+bme280 = "0.5.1"
 gpiod = "0.3.0"
+linux-embedded-hal = "0.4.0"
 log = "0.4.22"
 ron = "0.8.1"
 serde = { version = "1.0.204", features = ["derive"] }

conf.ron

@@ -18,10 +18,17 @@ Config(
             spi_mode: SPI_MODE_0,
         ),
         radio_config: RadioConfig(
-            bandwidth: bandwidth_20_8kHz,
+            frequency: 433_000_000,
+            bandwidth: bandwidth_31_25kHz,
             coding_rate: coding_4_8,
             spreading_factor: spreading_factor_4096,
             tx_power: 17,
         ),
     ),
+    bme_config: BME280Config(
+        i2c_bus_path: "/dev/i2c-2",
+        i2c_address: 118,
+        measurement_interval: 10,
+        enabled: false,
+    ),
 )

src/bme280.rs

@@ -0,0 +1,54 @@
+use anyhow::{Context, Result};
+use bme280::i2c::BME280;
+use linux_embedded_hal::{Delay, I2cdev};
+use log::info;
+
+use crate::BME280Config;
+
+pub struct BME280Sensor {
+    bme280: BME280<I2cdev>,
+    delay: Delay,
+}
+
+impl BME280Sensor {
+    pub fn new(config: BME280Config) -> Result<Self> {
+        let i2c_bus = I2cdev::new(&config.i2c_bus_path)
+            .context("Failed to initialize I2C bus in BME280Sensor::new")?;
+
+        let mut delay = Delay {};
+
+        let mut bme280 = BME280::new(i2c_bus, config.i2c_address);
+        bme280
+            .init(&mut delay)
+            .map_err(|e| anyhow::anyhow!("BME280 initialization failed: {:?}", e))?;
+
+        info!("BME280 initialized successfully");
+        Ok(BME280Sensor { bme280, delay })
+    }
+
+    pub fn read_measurements(&mut self) -> Result<(f32, f32, f32)> {
+        let measurements = self
+            .bme280
+            .measure(&mut self.delay)
+            .map_err(|e| anyhow::anyhow!("Failed to read BME280 sensor: {:?}", e))?;
+
+        Ok((
+            measurements.temperature,
+            measurements.pressure / 100.0,
+            measurements.humidity,
+        ))
+    }
+
+    pub fn print(&mut self) -> Result<()> {
+        match self.read_measurements() {
+            Ok((temperature, pressure, humidity)) => {
+                info!("BME280 Sensor Measurements:");
+                info!("Temperature: {:>6.1} °C", temperature);
+                info!("Pressure:    {:>7.1} hPa", pressure);
+                info!("Humidity:    {:>6.1} %", humidity);
+                Ok(())
+            }
+            Err(e) => Err(e),
+        }
+    }
+}

src/config.rs

@@ -1,52 +1,22 @@
 use crate::defines::{Bandwidth, CodingRate, SpreadingFactor};
-use log::{error, info};
+use anyhow::{Context, Result};
+use log::info;
 use serde::{Deserialize, Serialize};
-use std::env;
-use std::{fs, process};
+use std::fs;
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Config {
     pub mqtt_config: MQTTConfig,
     pub lora_config: LoRaConfig,
+    pub bme_config: BME280Config
 }
 
 impl Config {
-    pub fn from_file() -> Config {
-        let config_file = match fs::read_to_string(Config::parse_args()) {
-            Ok(s) => s,
-            Err(e) => {
-                eprintln!("ERROR {:?}", e.to_string());
-                error!("While reading config file: {e}.");
-                process::exit(-1)
-            }
-        };
-
-        match ron::from_str(config_file.as_str()) {
-            Ok(config) => {
-                info!("Succesfully read config file.");
-                config
-            }
-            Err(e) => {
-                eprintln!("ERROR {:?}", e.to_string());
-                error!("While deserializing ron file to config: {e}.");
-                process::exit(-1);
-            }
-        }
-    }
-
-    fn parse_args() -> String {
-        let args: Vec<String> = env::args().collect();
-
-        match args.len() {
-            1 => "./conf.ron".to_string(),
-            2 => args[1].to_string(),
-            _ => {
-                eprintln!("Wrong number of arguments!");
-                println!("Usage: ./rusty_beagle [config file]");
-                error!("Wrong number of arguments.");
-                std::process::exit(-1);
-            }
-        }
+    pub fn from_file(config_path: String) -> Result<Config> {
+        let config_file = fs::read_to_string(config_path).context("Config::from_file")?;
+        let config = ron::from_str(config_file.as_str()).context("Config::from_file")?;
+        info!("Succesfully read config file.");
+        Ok(config)
     }
 }
 
@@ -59,6 +29,14 @@ pub struct MQTTConfig {
     pub topic: String,
 }
 
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct BME280Config {
+    pub i2c_bus_path: String,
+    pub i2c_address: u8,
+    pub measurement_interval: u64,
+    pub enabled: bool,
+}
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct SPIConfig {
     pub spidev_path: String,
@@ -79,6 +57,7 @@ pub struct LoRaConfig {
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct RadioConfig {
+    pub frequency: u64,
     pub bandwidth: Bandwidth,
     pub coding_rate: CodingRate,
     pub spreading_factor: SpreadingFactor,
@@ -174,3 +153,18 @@ impl SpiFlags {
     pub const SPI_MODE_2: SpiFlags = SpiFlags::SPI_CPOL;
     pub const SPI_MODE_3: SpiFlags = SpiFlags::SPI_MODE_0;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn config_correct() {
+        assert!(Config::from_file("./tests/configs/conf.ron".to_string()).is_ok());
+    }
+
+    #[test]
+    fn config_incomplete() {
+        assert!(Config::from_file("./tests/configs/incomplete_conf.ron".to_string()).is_err());
+    }
+}

src/conversions.rs

@@ -1,29 +1,11 @@
-use anyhow::{anyhow, Context, Result};
-
-pub fn vec_to_f32(vec: &[u8], start: usize) -> Result<f32> {
-    let slice = &vec[start..start + 4];
-    let array: [u8; 4] = slice.try_into().context("vec_to_f32")?;
-    Ok(f32::from_le_bytes(array))
-}
-
-pub fn vec_to_f64(vec: &[u8], start: usize) -> Result<f64> {
-    let slice = &vec[start..start + 8];
-    let array: [u8; 8] = slice.try_into().context("vec_to_f64")?;
-    Ok(f64::from_le_bytes(array))
-}
+use anyhow::{Context, Result};
 
 pub fn vec_to_u16(vec: &[u8], start: usize) -> Result<u16> {
     let slice = &vec[start..start + 2];
     let array: [u8; 2] = slice.try_into().context("vec_to_u16")?;
     Ok(u16::from_le_bytes(array))
 }
 
-pub fn vec_to_u32(vec: &[u8], start: usize) -> Result<u32> {
-    let slice = &vec[start..start + 4];
-    let array: [u8; 4] = slice.try_into().context("vec_to_u32")?;
-    Ok(u32::from_le_bytes(array))
-}
-
 pub fn vec_to_u64(vec: &[u8], start: usize) -> Result<u64> {
     let slice = &vec[start..start + 8];
     let array: [u8; 8] = slice.try_into().context("vec_to_u64")?;
@@ -41,9 +23,3 @@ pub fn vec_to_i32(vec: &[u8], start: usize) -> Result<i32> {
     let array: [u8; 4] = slice.try_into().context("vec_to_i32")?;
     Ok(i32::from_le_bytes(array))
 }
-
-pub fn vec_to_i16(vec: &[u8], start: usize) -> Result<i16> {
-    let slice = &vec[start..start + 2];
-    let array: [u8; 2] = slice.try_into().context("vec_to_i16")?;
-    Ok(i16::from_le_bytes(array))
-}