Introduce "app-core" crate

Author: werediver

escale_fw_rs/Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
   "app",
+  "lib/app-core",
   "lib/stuff"
 ]
 

escale_fw_rs/README.md

@@ -1,25 +1,40 @@
 # eScale firmware in Rust
 
+## Project structure
+
+- [app](./app/)
+  - The main crate
+- [lib/](./lib/)
+  - [app-core](./lib/app-core/)
+    - Application logic, hardware independent
+  - [stuff](./lib/stuff/)
+    - Auxiliary code, potentially reusable outside the app
+    - Yes, the name can be improved
+
 ## UI structure
 
 - Dashboard (weigh & time)
   - Taring
-  - Calibrating
+  - Calibration
+  - (Maybe) Diagnostic info
 
 ## General architecture and execution model
 
 - Run _tasks_ in the order defined by a scheduler
 - A task may need to initialize, can be ran, can terminate when done, can schedule other tasks
 - Services
   - A task as a service can be discovered, can provide service-specific interface
+
     OR
   - A task can register (as) a service
   - A service can be resolved by other tasks
     (i.e. the service registry is separate from the task registry)
+
     OR
   - A message queue accessible to tasks instead?
     - (Weird, but) a service can be published via a message in the queue that is
       - never removed (a "pinned" message)
+
         OR
       - regularly re-posted
 
@@ -39,6 +54,7 @@
 
 - Display API
   - A display interface is injected into a task as a dependency
+
     OR
   - A display interface is published as a "pinned" message in the message queue
     - The display service doesn't have to be a task

escale_fw_rs/app/Cargo.toml

@@ -27,4 +27,5 @@ rp-pico = "0.4.1"
 ssd1306 = "0.7.0"
 nau7802 = { git = "https://github.com/werediver/nau7802-rs.git", branch = "next" }
 
+app-core = { path = "../lib/app-core" }
 stuff = { path = "../lib/stuff" }

escale_fw_rs/app/src/common.rs

@@ -1,13 +1,13 @@
-use core::cell::RefCell;
-
 use alloc::{format, rc::Rc, string::String};
-use stuff::mq::MessageProcessingStatus;
+use core::cell::RefCell;
 
-use crate::{
-    common::{Duration, Instant},
-    input_scanner::InputEvent,
+use app_core::{
+    common::{AppContext, AppMessage, Duration, InputEvent, Instant},
+    terminal::Terminal,
+};
+use stuff::{
+    mq::MessageProcessingStatus,
     run_loop::{Task, TaskStatus},
-    AppContext, AppMessage, Terminal,
 };
 
 pub struct Dashboard {

escale_fw_rs/app/src/dashboard.rs

@@ -3,10 +3,8 @@
 #![feature(alloc_error_handler)]
 #![feature(trait_alias)]
 
-mod common;
 mod dashboard;
-mod input_scanner;
-mod run_loop;
+mod ssd1306_terminal;
 mod uptime;
 mod uptime_delay;
 
@@ -16,15 +14,9 @@ use alloc::rc::Rc;
 use alloc_cortex_m::CortexMHeap;
 use core::{alloc::Layout, cell::RefCell};
 use cortex_m_rt::entry;
-use dashboard::Dashboard;
 use embedded_hal::digital::v2::InputPin;
 use embedded_time::rate::Extensions;
 use panic_probe as _;
-use stuff::{
-    mq::{MessageProcessingStatus, MessageQueue},
-    scale::Scale,
-};
-use uptime::Uptime;
 
 use rp_pico as bsp;
 
@@ -38,12 +30,23 @@ use bsp::hal::{
 
 use nau7802::{Gain, Ldo, Nau7802, SamplesPerSecond};
 use ssd1306::{
-    mode::{TerminalDisplaySize, TerminalMode},
-    prelude::{WriteOnlyDataCommand, *},
-    I2CDisplayInterface, Ssd1306,
+    mode::DisplayConfig, rotation::DisplayRotation, size::DisplaySize128x64, I2CDisplayInterface,
+    Ssd1306,
 };
 
-use crate::{input_scanner::*, run_loop::*};
+use app_core::{
+    common::{AppContext, AppMessage},
+    input_scanner::InputScanner,
+    scale::Scale,
+    terminal::Terminal,
+};
+use dashboard::Dashboard;
+use ssd1306_terminal::Ssd1306Terminal;
+use stuff::{
+    mq::MessageProcessingStatus,
+    run_loop::{Schedule, Task},
+};
+use uptime::Uptime;
 
 #[alloc_error_handler]
 fn oom(_: Layout) -> ! {
@@ -103,12 +106,12 @@ fn _main() -> ! {
     );
 
     let interface = I2CDisplayInterface::new(i2c);
-    let shared_terminal = Rc::new(RefCell::new(
-        Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0).into_terminal_mode(),
-    ));
+    let mut ssd1306 =
+        Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0).into_terminal_mode();
+    ssd1306.init().unwrap();
+    let shared_terminal = Rc::new(RefCell::new(Ssd1306Terminal::new(ssd1306)));
     {
         let mut terminal = shared_terminal.borrow_mut();
-        terminal.init().unwrap();
         terminal.clear().unwrap();
     }
 
@@ -170,23 +173,6 @@ fn _main() -> ! {
     }
 }
 
-#[derive(Default)]
-struct AppContext {
-    mq: MessageQueue<AppMessage>,
-    state: AppState,
-}
-
-enum AppMessage {
-    InputEvent(InputEvent),
-    Tare,
-    Calibrate,
-}
-
-#[derive(Default)]
-struct AppState {
-    weight: f32,
-}
-
 enum AppTask {
     InputScanner(InputScanner),
     Dashboard(Dashboard),
@@ -200,22 +186,3 @@ impl<'a> AsMut<dyn Task<AppContext> + 'a> for AppTask {
         }
     }
 }
-
-pub trait Terminal: core::fmt::Write {
-    fn clear(&mut self) -> core::fmt::Result;
-    fn set_position(&mut self, column: u8, row: u8) -> core::fmt::Result;
-}
-
-impl<DI, SIZE> Terminal for Ssd1306<DI, SIZE, TerminalMode>
-where
-    DI: WriteOnlyDataCommand,
-    SIZE: TerminalDisplaySize,
-{
-    fn clear(&mut self) -> core::fmt::Result {
-        self.clear().map_err(|_| core::fmt::Error)
-    }
-
-    fn set_position(&mut self, column: u8, row: u8) -> core::fmt::Result {
-        self.set_position(column, row).map_err(|_| core::fmt::Error)
-    }
-}

escale_fw_rs/app/src/main.rs

@@ -0,0 +1,51 @@
+use ssd1306::{
+    mode::{TerminalDisplaySize, TerminalMode},
+    prelude::WriteOnlyDataCommand,
+    Ssd1306,
+};
+
+use app_core::terminal::Terminal;
+
+pub struct Ssd1306Terminal<DI, SIZE>
+where
+    DI: WriteOnlyDataCommand,
+    SIZE: TerminalDisplaySize,
+{
+    ssd1306: Ssd1306<DI, SIZE, TerminalMode>,
+}
+
+impl<DI, SIZE> Ssd1306Terminal<DI, SIZE>
+where
+    DI: WriteOnlyDataCommand,
+    SIZE: TerminalDisplaySize,
+{
+    pub fn new(ssd1306: Ssd1306<DI, SIZE, TerminalMode>) -> Self {
+        Self { ssd1306 }
+    }
+}
+
+impl<DI, SIZE> core::fmt::Write for Ssd1306Terminal<DI, SIZE>
+where
+    DI: WriteOnlyDataCommand,
+    SIZE: TerminalDisplaySize,
+{
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        self.ssd1306.write_str(s)
+    }
+}
+
+impl<DI, SIZE> Terminal for Ssd1306Terminal<DI, SIZE>
+where
+    DI: WriteOnlyDataCommand,
+    SIZE: TerminalDisplaySize,
+{
+    fn clear(&mut self) -> core::fmt::Result {
+        self.ssd1306.clear().map_err(|_| core::fmt::Error)
+    }
+
+    fn set_position(&mut self, column: u8, row: u8) -> core::fmt::Result {
+        self.ssd1306
+            .set_position(column, row)
+            .map_err(|_| core::fmt::Error)
+    }
+}

escale_fw_rs/app/src/ssd1306_terminal.rs

@@ -1,7 +1,8 @@
-use crate::common::Instant;
 use cortex_m::peripheral::{syst::SystClkSource, SYST};
 use cortex_m_rt::exception;
 
+use app_core::common::Instant;
+
 pub struct Uptime {
     _syst: SYST,
 }

escale_fw_rs/app/src/uptime.rs

@@ -0,0 +1,9 @@
+[package]
+name = "app-core"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+stuff = { path = "../stuff" }
+num-traits = { version = "0.2.15", default-features = false }
+fugit = "0.3.6"

escale_fw_rs/lib/app-core/Cargo.toml

@@ -0,0 +1,26 @@
+use stuff::mq::MessageQueue;
+
+pub type Instant = fugit::Instant<u64, 1, 1_000_000>;
+pub type Duration = fugit::Duration<u64, 1, 1_000_000>;
+
+#[derive(Default)]
+pub struct AppContext {
+    pub mq: MessageQueue<AppMessage>,
+    pub state: AppState,
+}
+
+pub enum AppMessage {
+    InputEvent(InputEvent),
+    Tare,
+    Calibrate,
+}
+
+pub enum InputEvent {
+    ButtonADown,
+    ButtonBDown,
+}
+
+#[derive(Default)]
+pub struct AppState {
+    pub weight: f32,
+}

escale_fw_rs/lib/app-core/src/common.rs

@@ -1,11 +1,8 @@
-use crate::{run_loop::*, AppContext, AppMessage};
-
 use alloc::boxed::Box;
 
-pub enum InputEvent {
-    ButtonADown,
-    ButtonBDown,
-}
+use stuff::run_loop::{Task, TaskStatus};
+
+use crate::common::{AppContext, AppMessage, InputEvent};
 
 pub struct InputScanner {
     button_a: Button,

escale_fw_rs/app/src/input_scanner.rs escale_fw_rs/lib/app-core/src/input_scanner.rs

@@ -0,0 +1,10 @@
+#![cfg_attr(not(test), no_std)]
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+extern crate alloc;
+
+pub mod common;
+pub mod input_scanner;
+pub mod scale;
+pub mod terminal;

escale_fw_rs/lib/app-core/src/lib.rs

@@ -1,14 +1,20 @@
 use num_traits::{float::FloatCore, PrimInt};
+use stuff::{ring::Ring, signal::mean};
 
-use crate::{ring::Ring, signal::mean};
-
-pub struct Scale<T: PrimInt, U: FloatCore, const N: usize> {
+pub struct Scale<T: PrimInt, U: FloatCore, const N: usize>
+where
+    // Require N ≥ 1
+    [(); N - 1]:,
+{
     ring: Ring<T, N>,
     tare: U,
     unit: U,
 }
 
-impl<T: PrimInt + Default, U: FloatCore, const N: usize> Default for Scale<T, U, N> {
+impl<T: PrimInt + Default, U: FloatCore, const N: usize> Default for Scale<T, U, N>
+where
+    [(); N - 1]:,
+{
     fn default() -> Self {
         Self {
             ring: Default::default(),
@@ -18,7 +24,10 @@ impl<T: PrimInt + Default, U: FloatCore, const N: usize> Default for Scale<T, U,
     }
 }
 
-impl<T: PrimInt, U: FloatCore, const N: usize> Scale<T, U, N> {
+impl<T: PrimInt, U: FloatCore, const N: usize> Scale<T, U, N>
+where
+    [(); N - 1]:,
+{
     pub fn push(&mut self, value: T) {
         self.ring.push(value);
     }

escale_fw_rs/lib/stuff/src/scale.rs escale_fw_rs/lib/app-core/src/scale.rs

@@ -0,0 +1,4 @@
+pub trait Terminal: core::fmt::Write {
+    fn clear(&mut self) -> core::fmt::Result;
+    fn set_position(&mut self, column: u8, row: u8) -> core::fmt::Result;
+}

escale_fw_rs/lib/app-core/src/terminal.rs

@@ -1,6 +1,10 @@
 #![cfg_attr(not(test), no_std)]
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+extern crate alloc;
 
 pub mod mq;
 pub mod ring;
-pub mod scale;
+pub mod run_loop;
 pub mod signal;

escale_fw_rs/lib/stuff/src/lib.rs

@@ -1,5 +1,3 @@
-extern crate alloc;
-
 use alloc::vec::Vec;
 
 pub struct MessageQueue<M> {