Cargo.lock

@@ -284,6 +284,14 @@ name = "rustc-demangle"
 version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "sensor-plot"
+version = "0.1.0"
+dependencies = [
+ "card10-l0dable 0.1.1",
+ "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "shlex"
 version = "0.1.1"

Cargo.toml

@@ -3,6 +3,7 @@ members = [
   "l0dable",
   "example",
   "rkanoid",
+  "sensor-plot",
 ]
 default-members = [
   "example",

sensor-plot/.cargo/config

+[target.thumbv7em-none-eabi]
+rustflags = [
+  "-C", "linker=arm-none-eabi-gcc",
+  "-C", "link-args=-Tl0dable.ld -n -pie -fPIC",
+  "-C", "relocation-model=pic",
+]
+
+[build]
+target = "thumbv7em-none-eabi" # Cortex-M4F and Cortex-M7F (with FPU)
+

sensor-plot/Cargo.toml

+[package]
+edition = "2018"
+name = "sensor-plot"
+version = "0.1.0"
+authors = ["Raphael Nestler <rnestler@coredump.ch>"]
+
+[dependencies]
+card10-l0dable = { path = "../l0dable" }
+
+[build-dependencies]
+cc = "1.0"

sensor-plot/src/main.rs

+#![no_std]
+#![no_main]
+
+use card10_l0dable::*;
+use core::f32;
+use core::fmt::Write;
+
+struct PlotBuffer {
+    buffer: [i32; Display::W as usize],
+    index: u16,
+}
+
+impl PlotBuffer {
+    pub fn new() -> Self {
+        PlotBuffer {
+            buffer: [0; Display::W as usize],
+            index: 0,
+        }
+    }
+
+    pub fn get_max(&self) -> i32 {
+        *self.buffer.iter().max().unwrap()
+    }
+
+    pub fn get_min(&self) -> i32 {
+        *self.buffer.iter().min().unwrap()
+    }
+
+    pub fn add_sample(&mut self, sample: i32) {
+        self.buffer[self.index as usize] = sample;
+        self.index += 1;
+        if self.index >= Display::W {
+            self.index = 0;
+        }
+    }
+
+    pub fn clear(&mut self) {
+        *self = PlotBuffer::new();
+    }
+
+    pub fn plot(&self, display: &Display) {
+        let min = self.get_min() as f32;
+        let max = self.get_max() as f32;
+        let delta = max - min;
+        let multiplier = if delta > 0.0 {
+            (Display::H - 1) as f32 / delta
+        } else {
+            1.0
+        };
+
+        for i in 0..Display::W {
+            let index = (self.index + i) % Display::W;
+            display.pixel(
+                i,
+                ((Display::H - 1) as f32
+                    - ((self.buffer[index as usize] as f32 - min) * multiplier))
+                    as u16,
+                Color::white(),
+            );
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Sensor {
+    Temperature,
+    Humidity,
+    Pressure,
+    GasResistance,
+}
+
+impl Sensor {
+    pub fn new() -> Self {
+        Sensor::Temperature
+    }
+
+    pub fn right(self) -> Self {
+        match self {
+            Self::Temperature => Self::Humidity,
+            Self::Humidity => Self::Pressure,
+            Self::Pressure => Self::GasResistance,
+            Self::GasResistance => Self::Temperature,
+        }
+    }
+
+    pub fn left(self) -> Self {
+        match self {
+            Self::Temperature => Self::GasResistance,
+            Self::Humidity => Self::Temperature,
+            Self::Pressure => Self::Humidity,
+            Self::GasResistance => Self::Pressure,
+        }
+    }
+}
+
+main!(main);
+fn main() {
+    writeln!(UART, "Hello from Rust\r").unwrap();
+
+    let mut plot_buffer_t = PlotBuffer::new();
+    let mut plot_buffer_rh = PlotBuffer::new();
+    let mut plot_buffer_p = PlotBuffer::new();
+    let mut plot_buffer_r = PlotBuffer::new();
+
+    let environment_sensors = BME680::start();
+    let display = Display::open();
+    let mut sensor = Sensor::new();
+    let mut old_b = Buttons::read();
+
+    loop {
+        let b = Buttons::read();
+
+        if b.left_bottom() && !old_b.left_bottom() {
+            sensor = sensor.left();
+        }
+        if b.right_bottom() && !old_b.right_bottom() {
+            sensor = sensor.right();
+        }
+        old_b = b;
+
+        let mut str_buffer = [0u8; 32];
+
+        environment_sensors.read().map(|v| {
+            plot_buffer_t.add_sample((v.temperature * 1000.0) as i32);
+            plot_buffer_rh.add_sample((v.humidity * 1000.0) as i32);
+            plot_buffer_p.add_sample((v.pressure * 1000.0) as i32);
+            plot_buffer_r.add_sample((v.gas_resistance * 1000.0) as i32);
+            match sensor {
+                Sensor::Temperature => {
+                    write!(FmtBuffer::new(&mut str_buffer), "T: {}\0", v.temperature).unwrap();
+                }
+                Sensor::Humidity => {
+                    write!(FmtBuffer::new(&mut str_buffer), "RH: {}\0", v.humidity).unwrap();
+                }
+                Sensor::Pressure => {
+                    write!(FmtBuffer::new(&mut str_buffer), "P: {}\0", v.pressure).unwrap();
+                }
+                Sensor::GasResistance => {
+                    write!(FmtBuffer::new(&mut str_buffer), "R: {}\0", v.gas_resistance).unwrap();
+                }
+            };
+        });
+
+        display.clear(Color::black());
+        display.print(0, 0, &str_buffer, Color::white(), Color::black());
+        match sensor {
+            Sensor::Temperature => plot_buffer_t.plot(&display),
+            Sensor::Humidity => plot_buffer_rh.plot(&display),
+            Sensor::Pressure => plot_buffer_p.plot(&display),
+            Sensor::GasResistance => plot_buffer_r.plot(&display),
+        }
+        display.update();
+    }
+}