Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 ede1998
|
bd124bf9c2
|
Generated
+81
-59
@@ -53,12 +53,6 @@ version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c583acf993cf4245c4acb0a2cc2ab1f9cc097de73411bb6d3647ff6af2b1013d"
|
||||
|
||||
[[package]]
|
||||
name = "array-init"
|
||||
version = "2.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.1"
|
||||
@@ -102,29 +96,6 @@ dependencies = [
|
||||
"vsimd",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "binary_serde"
|
||||
version = "1.0.25"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c4b2fe974c561ed04fb89673dd221bed36fc4794b71ca6ae96ffe19949045686"
|
||||
dependencies = [
|
||||
"array-init",
|
||||
"binary_serde_macros",
|
||||
"recursive_array",
|
||||
"thiserror-no-std",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "binary_serde_macros"
|
||||
version = "1.0.25"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4790b8dbcfa9d3adf2020ebf5fd36c6bc89a77d434131615ea349bc9620e8831"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitfield"
|
||||
version = "0.17.0"
|
||||
@@ -348,9 +319,9 @@ name = "creaturedex"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"base64 0.23.1",
|
||||
"binary_serde",
|
||||
"ch1115",
|
||||
"critical-section",
|
||||
"display-interface",
|
||||
"display-interface-spi",
|
||||
"embassy-executor",
|
||||
"embassy-futures",
|
||||
@@ -362,20 +333,18 @@ dependencies = [
|
||||
"embedded-hal-async",
|
||||
"embedded-hal-bus",
|
||||
"embedded-io 0.7.1",
|
||||
"embedded-storage",
|
||||
"esp-alloc",
|
||||
"esp-bootloader-esp-idf",
|
||||
"esp-hal",
|
||||
"esp-hal-wifimanager",
|
||||
"esp-println",
|
||||
"esp-rtos",
|
||||
"esp-storage",
|
||||
"i2c-character-display",
|
||||
"ili9341",
|
||||
"log",
|
||||
"num_enum",
|
||||
"pn532",
|
||||
"static_assertions",
|
||||
"ssd1306",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -640,6 +609,17 @@ version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7ba2aab1ef3793e6f7804162debb5ac5edb93b3d650fbcc5aeb72fcd0e6c03a0"
|
||||
|
||||
[[package]]
|
||||
name = "display-interface-i2c"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0d964fa85bbbb5a6ecd06e58699407ac5dc3e3ad72dac0ab7e6b0d00a1cd262d"
|
||||
dependencies = [
|
||||
"display-interface",
|
||||
"embedded-hal 1.0.0",
|
||||
"embedded-hal-async",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "display-interface-spi"
|
||||
version = "0.5.0"
|
||||
@@ -1975,6 +1955,19 @@ version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
|
||||
|
||||
[[package]]
|
||||
name = "maybe-async-cfg"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a1e083394889336bc66a4eaf1011ffbfa74893e910f902a9f271fa624c61e1b2"
|
||||
dependencies = [
|
||||
"proc-macro-error",
|
||||
"proc-macro2",
|
||||
"pulldown-cmark",
|
||||
"quote",
|
||||
"syn 1.0.109",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
@@ -2723,6 +2716,30 @@ dependencies = [
|
||||
"toml_edit",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
|
||||
dependencies = [
|
||||
"proc-macro-error-attr",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 1.0.109",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error-attr"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
@@ -2752,6 +2769,17 @@ dependencies = [
|
||||
"syn 1.0.109",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pulldown-cmark"
|
||||
version = "0.11.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "679341d22c78c6c649893cbd6c3278dcbe9fc4faa62fea3a9296ae2b50c14625"
|
||||
dependencies = [
|
||||
"bitflags 2.13.1",
|
||||
"memchr",
|
||||
"unicase",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
@@ -2829,12 +2857,6 @@ dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "recursive_array"
|
||||
version = "0.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "69bad83913c3b39011ad9d43b7ac0cae139cec5d7e7288fbea5bb4b4e3cc78f6"
|
||||
|
||||
[[package]]
|
||||
name = "redox_syscall"
|
||||
version = "0.5.18"
|
||||
@@ -3172,6 +3194,20 @@ version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a0f368519fc6c85fc1afdb769fb5a51123f6158013e143656e25a3485a0d401c"
|
||||
|
||||
[[package]]
|
||||
name = "ssd1306"
|
||||
version = "0.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3ea6aac2d078bbc71d9b8ac3f657335311f3b6625e9a1a96ccc29f5abfa77c56"
|
||||
dependencies = [
|
||||
"display-interface",
|
||||
"display-interface-i2c",
|
||||
"display-interface-spi",
|
||||
"embedded-graphics-core",
|
||||
"embedded-hal 1.0.0",
|
||||
"maybe-async-cfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "stable_deref_trait"
|
||||
version = "1.2.1"
|
||||
@@ -3312,26 +3348,6 @@ dependencies = [
|
||||
"syn 3.0.3",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror-impl-no-std"
|
||||
version = "2.0.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 1.0.109",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror-no-std"
|
||||
version = "2.0.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea"
|
||||
dependencies = [
|
||||
"thiserror-impl-no-std",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thread_local"
|
||||
version = "1.1.10"
|
||||
@@ -3459,6 +3475,12 @@ version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e87a2ed6b42ec5e28cc3b94c09982969e9227600b2e3dcbc1db927a84c06bd69"
|
||||
|
||||
[[package]]
|
||||
name = "unicase"
|
||||
version = "2.9.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-id-start"
|
||||
version = "1.4.0"
|
||||
|
||||
+13
-21
@@ -1,19 +1,15 @@
|
||||
[package]
|
||||
edition = "2024"
|
||||
name = "creaturedex"
|
||||
edition = "2024"
|
||||
name = "creaturedex"
|
||||
rust-version = "1.88"
|
||||
version = "0.1.0"
|
||||
version = "0.1.0"
|
||||
|
||||
[[bin]]
|
||||
name = "creaturedex"
|
||||
path = "./src/bin/main.rs"
|
||||
|
||||
[dependencies]
|
||||
esp-hal = { version = "~1.1.0", features = [
|
||||
"esp32s3",
|
||||
"log-04",
|
||||
"unstable",
|
||||
] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
|
||||
esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
|
||||
|
||||
esp-rtos = { version = "0.3.0", features = [
|
||||
"embassy",
|
||||
@@ -24,11 +20,12 @@ esp-rtos = { version = "0.3.0", features = [
|
||||
] }
|
||||
|
||||
esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32s3", "log-04"] }
|
||||
log = "0.4.27"
|
||||
log = "0.4.27"
|
||||
|
||||
critical-section = "1.2.0"
|
||||
embedded-io = "0.7.1"
|
||||
embassy-executor = { version = "0.10.0", features = [] }
|
||||
embassy-executor = { version = "0.10.0", features = [
|
||||
] }
|
||||
embassy-time = { version = "0.5.1", default-features = false }
|
||||
embassy-futures = "0.1.2"
|
||||
esp-alloc = "0.10.0"
|
||||
@@ -38,6 +35,7 @@ esp-hal-wifimanager = { git = "https://github.com/InvisibleUSA/esp-hal-wifimanag
|
||||
] }
|
||||
esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
|
||||
display-interface-spi = "0.5.0"
|
||||
display-interface = "*"
|
||||
ili9341 = "0.6.0"
|
||||
embedded-hal = "1.0.0"
|
||||
embedded-hal-bus = "0.3.0"
|
||||
@@ -50,13 +48,7 @@ embassy-sync = "0.8.0"
|
||||
embedded-hal-async = "1.0.0"
|
||||
i2c-character-display = "0.5.1"
|
||||
ch1115 = { version = "0.1.2", features = ["graphics"] }
|
||||
esp-storage = "0.9.0"
|
||||
embedded-storage = "0.3.1"
|
||||
binary_serde = "1.0.25"
|
||||
static_assertions = { version = "1.1.0", default-features = false }
|
||||
|
||||
[build-dependencies]
|
||||
log = "0.4.27"
|
||||
ssd1306 = { version = "0.10.0", features = [] }
|
||||
|
||||
|
||||
[patch.crates-io]
|
||||
@@ -74,10 +66,10 @@ opt-level = 3
|
||||
debug = 0
|
||||
|
||||
[profile.release]
|
||||
codegen-units = 1 # LLVM can perform better optimizations using a single thread
|
||||
debug = 2 # prefer slower builds but better debugging experience
|
||||
lto = 'fat'
|
||||
opt-level = 's'
|
||||
codegen-units = 1 # LLVM can perform better optimizations using a single thread
|
||||
debug = 2 # prefer slower builds but better debugging experience
|
||||
lto = 'fat'
|
||||
opt-level = 's'
|
||||
|
||||
[features]
|
||||
default = []
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
fn main() {
|
||||
generate_filter_snippet();
|
||||
linker_be_nice();
|
||||
// make sure linkall.x is the last linker script (otherwise might cause problems with flip-link)
|
||||
println!("cargo:rustc-link-arg=-Tlinkall.x");
|
||||
@@ -69,165 +68,3 @@ fn linker_be_nice() {
|
||||
std::env::current_exe().unwrap().display()
|
||||
);
|
||||
}
|
||||
|
||||
// Taken over from esp_println because impossible to just extend their existing env logger.
|
||||
// https://github.com/esp-rs/esp-hal/blob/8fa6d7e985e724d6ad998e34307429b0920da370/esp-println/build.rs
|
||||
fn generate_filter_snippet() {
|
||||
use log::LevelFilter;
|
||||
use std::{env, path::Path};
|
||||
|
||||
let out_dir = env::var_os("OUT_DIR").unwrap();
|
||||
let dest_path = Path::new(&out_dir).join("log_filter.rs");
|
||||
|
||||
let filter = env::var("ESP_LOG");
|
||||
let snippet = if let Ok(filter) = filter {
|
||||
let res = parse_spec(&filter);
|
||||
|
||||
if !res.errors.is_empty() {
|
||||
panic!("Error parsing `ESP_LOG`: {:?}", res.errors);
|
||||
} else {
|
||||
let max = res
|
||||
.directives
|
||||
.iter()
|
||||
.map(|v| v.level)
|
||||
.max()
|
||||
.unwrap_or(LevelFilter::Off);
|
||||
let max = match max {
|
||||
LevelFilter::Off => "Off",
|
||||
LevelFilter::Error => "Error",
|
||||
LevelFilter::Warn => "Warn",
|
||||
LevelFilter::Info => "Info",
|
||||
LevelFilter::Debug => "Debug",
|
||||
LevelFilter::Trace => "Trace",
|
||||
};
|
||||
|
||||
let mut snippet = String::new();
|
||||
|
||||
snippet.push_str(&format!(
|
||||
"pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::{max};"
|
||||
));
|
||||
|
||||
snippet
|
||||
.push_str("pub(crate) fn is_enabled(level: log::Level, _target: &str) -> bool {");
|
||||
|
||||
let mut global_level = None;
|
||||
for directive in res.directives {
|
||||
let level = match directive.level {
|
||||
LevelFilter::Off => "Off",
|
||||
LevelFilter::Error => "Error",
|
||||
LevelFilter::Warn => "Warn",
|
||||
LevelFilter::Info => "Info",
|
||||
LevelFilter::Debug => "Debug",
|
||||
LevelFilter::Trace => "Trace",
|
||||
};
|
||||
|
||||
if let Some(name) = directive.name {
|
||||
// If a prefix matches, don't continue to the next directive
|
||||
snippet.push_str(&format!(
|
||||
"if _target.starts_with(\"{name}\") {{ return level <= log::LevelFilter::{level}; }}"
|
||||
));
|
||||
} else {
|
||||
if global_level.is_some() {
|
||||
panic!("Multiple global log levels specified in `ESP_LOG`");
|
||||
}
|
||||
global_level = Some(level);
|
||||
}
|
||||
}
|
||||
|
||||
// Place the fallback rule at the end
|
||||
if let Some(level) = global_level {
|
||||
snippet.push_str(&format!("level <= log::LevelFilter::{level}"));
|
||||
} else {
|
||||
snippet.push_str(" false");
|
||||
}
|
||||
snippet.push('}');
|
||||
snippet
|
||||
}
|
||||
} else {
|
||||
"pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::Off; pub(crate) fn is_enabled(_level: log::Level, _target: &str) -> bool { true }".to_string()
|
||||
};
|
||||
|
||||
std::fs::write(&dest_path, &snippet).unwrap();
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
struct ParseResult {
|
||||
pub(crate) directives: Vec<Directive>,
|
||||
pub(crate) errors: Vec<String>,
|
||||
}
|
||||
|
||||
impl ParseResult {
|
||||
fn add_directive(&mut self, directive: Directive) {
|
||||
self.directives.push(directive);
|
||||
}
|
||||
|
||||
fn add_error(&mut self, message: String) {
|
||||
self.errors.push(message);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Directive {
|
||||
pub(crate) name: Option<String>,
|
||||
pub(crate) level: log::LevelFilter,
|
||||
}
|
||||
|
||||
/// Parse a logging specification string (e.g:
|
||||
/// `crate1,crate2::mod3,crate3::x=error/foo`) and return a vector with log
|
||||
/// directives.
|
||||
fn parse_spec(spec: &str) -> ParseResult {
|
||||
use log::LevelFilter;
|
||||
|
||||
let mut result = ParseResult::default();
|
||||
|
||||
let mut parts = spec.split('/');
|
||||
let mods = parts.next();
|
||||
|
||||
if let Some(m) = mods {
|
||||
for s in m.split(',').map(|ss| ss.trim()) {
|
||||
if s.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let mut parts = s.split('=');
|
||||
let (log_level, name) =
|
||||
match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) {
|
||||
(Some(part0), None, None) => {
|
||||
// if the single argument is a log-level string or number,
|
||||
// treat that as a global fallback
|
||||
match part0.parse() {
|
||||
Ok(num) => (num, None),
|
||||
Err(_) => (LevelFilter::max(), Some(part0)),
|
||||
}
|
||||
}
|
||||
(Some(part0), Some(""), None) => (LevelFilter::max(), Some(part0)),
|
||||
(Some(part0), Some(part1), None) => {
|
||||
if let Ok(num) = part1.parse() {
|
||||
(num, Some(part0))
|
||||
} else {
|
||||
result.add_error(format!("invalid logging spec '{part1}'"));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
result.add_error(format!("invalid logging spec '{s}'"));
|
||||
continue;
|
||||
}
|
||||
};
|
||||
|
||||
result.add_directive(Directive {
|
||||
name: name.map(|s| s.to_owned()),
|
||||
level: log_level,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by length so that the most specific prefixes come first
|
||||
result
|
||||
.directives
|
||||
.sort_by(|a, b| match (a.name.as_ref(), b.name.as_ref()) {
|
||||
(Some(a), Some(b)) => b.len().cmp(&a.len()),
|
||||
_ => std::cmp::Ordering::Equal,
|
||||
});
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
use crate::storage::cardstore::CardStore;
|
||||
use embedded_hal_bus::i2c::AtomicDevice;
|
||||
use esp_hal::rtc_cntl::Rtc;
|
||||
use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
|
||||
|
||||
use crate::{
|
||||
@@ -16,8 +14,6 @@ use crate::{
|
||||
)]
|
||||
pub async fn nfc_scanner(
|
||||
mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
|
||||
mut card_store: CardStore,
|
||||
rtc: Rtc<'static>,
|
||||
) {
|
||||
loop {
|
||||
while CARD_DATA.lock().await.is_none() {
|
||||
@@ -28,22 +24,10 @@ pub async fn nfc_scanner(
|
||||
log::error!("Failed to split NFC card data");
|
||||
continue;
|
||||
};
|
||||
let card = match Card::try_from(split_data) {
|
||||
Ok(card) => card,
|
||||
Err(err) => {
|
||||
log::error!("Invalid card data: {err}");
|
||||
continue;
|
||||
}
|
||||
};
|
||||
CARD_DATA.lock().await.replace(card);
|
||||
|
||||
match card_store.save_raw_card(split_data, rtc.current_time_us()) {
|
||||
Ok(()) => {}
|
||||
Err(error) => {
|
||||
log::error!("Error storing card in flash: {:?}", error)
|
||||
}
|
||||
}
|
||||
|
||||
CARD_DATA
|
||||
.lock()
|
||||
.await
|
||||
.replace(Card::try_from(split_data).unwrap());
|
||||
let elapsed_ms = start.elapsed().as_millis();
|
||||
log::info!(
|
||||
"NFC read duration: {} ms, card data length: {}",
|
||||
@@ -51,8 +35,8 @@ pub async fn nfc_scanner(
|
||||
card_data.len()
|
||||
);
|
||||
}
|
||||
Err(_) => {
|
||||
log::info!("No NFC card found");
|
||||
Err(e) => {
|
||||
log::error!("NFC read failed: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+24
-58
@@ -18,8 +18,7 @@ use creaturedex::drivers::tertiary_lcd::{
|
||||
use creaturedex::navigation::inputs::Inputs;
|
||||
use creaturedex::navigation::navigation::{self};
|
||||
use creaturedex::navigation::outputs::Outputs;
|
||||
use creaturedex::storage::cardstore::CardStore;
|
||||
use creaturedex::storage::store::Store;
|
||||
use creaturedex::network::wifi::setup_wifi;
|
||||
use embassy_executor::Spawner;
|
||||
use embedded_graphics::pixelcolor::BinaryColor;
|
||||
use embedded_graphics::{
|
||||
@@ -33,8 +32,6 @@ use esp_hal::gpio::{Input, InputConfig, Pull};
|
||||
use esp_hal::timer::timg::TimerGroup;
|
||||
use log::error;
|
||||
|
||||
use esp_hal::rtc_cntl::Rtc;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic(panic_info: &core::panic::PanicInfo) -> ! {
|
||||
error!("{}", panic_info);
|
||||
@@ -55,7 +52,7 @@ esp_bootloader_esp_idf::esp_app_desc!();
|
||||
)]
|
||||
#[esp_rtos::main]
|
||||
async fn main(spawner: Spawner) {
|
||||
creaturedex::logging::init();
|
||||
esp_println::logger::init_logger_from_env();
|
||||
|
||||
let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
|
||||
let peripherals = esp_hal::init(config);
|
||||
@@ -67,57 +64,43 @@ async fn main(spawner: Spawner) {
|
||||
let timg0 = TimerGroup::new(peripherals.TIMG0);
|
||||
esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
|
||||
|
||||
let (primary, mut secondaries) = retry(
|
||||
5,
|
||||
spi_bus::DisplayPinConfiguration {
|
||||
spi_peripheral: peripherals.SPI2,
|
||||
sck: peripherals.GPIO36,
|
||||
mosi: peripherals.GPIO35,
|
||||
miso: peripherals.GPIO37,
|
||||
cs_primary: peripherals.GPIO11,
|
||||
cs_secondary_1: peripherals.GPIO13,
|
||||
cs_secondary_2: peripherals.GPIO14,
|
||||
cs_secondary_3: peripherals.GPIO21,
|
||||
reset_primary: peripherals.GPIO10,
|
||||
reset_secondary: peripherals.GPIO47,
|
||||
dc_pin: peripherals.GPIO12,
|
||||
},
|
||||
spi_bus::DisplayPinConfiguration::build,
|
||||
);
|
||||
let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
|
||||
spi_peripheral: peripherals.SPI2,
|
||||
sck: peripherals.GPIO36,
|
||||
mosi: peripherals.GPIO35,
|
||||
miso: peripherals.GPIO37,
|
||||
cs_primary: peripherals.GPIO11,
|
||||
cs_secondary_1: peripherals.GPIO13,
|
||||
cs_secondary_2: peripherals.GPIO14,
|
||||
cs_secondary_3: peripherals.GPIO21,
|
||||
reset_primary: peripherals.GPIO10,
|
||||
reset_secondary: peripherals.GPIO47,
|
||||
dc_pin: peripherals.GPIO12,
|
||||
}
|
||||
.build();
|
||||
|
||||
// Initialize the shared I2C bus using the refactored i2c_bus module.
|
||||
let shared_i2c = {
|
||||
use alloc::boxed::Box;
|
||||
let bus = retry(5, I2cBusPinConfiguration {
|
||||
let config = I2cBusPinConfiguration {
|
||||
i2c_peripheral: peripherals.I2C0,
|
||||
scl: peripherals.GPIO18,
|
||||
sda: peripherals.GPIO17,
|
||||
}, I2cBusPinConfiguration::build);
|
||||
Box::leak(Box::new(bus))
|
||||
};
|
||||
config.build()
|
||||
};
|
||||
|
||||
let mut lcd: TertiaryDisplay = retry(
|
||||
5,
|
||||
TertiaryDisplayPinConfiguration { i2c: shared_i2c },
|
||||
TertiaryDisplayPinConfiguration::build,
|
||||
);
|
||||
let mut lcd: TertiaryDisplay = TertiaryDisplayPinConfiguration { i2c: shared_i2c }.build();
|
||||
lcd.load_charset(EXAMPLE).unwrap();
|
||||
let h = EXAMPLE[HEART];
|
||||
let e = EXAMPLE[EMPTY];
|
||||
let b = EXAMPLE[BOX];
|
||||
if let Err(e) = lcd.write(&alloc::format!(
|
||||
"Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please."
|
||||
)) {
|
||||
if let Err(e) = lcd.write(&alloc::format!("Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please.")) {
|
||||
log::error!(
|
||||
"Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
|
||||
);
|
||||
}
|
||||
|
||||
let store = Store::new(peripherals.FLASH).expect("Could not initialize Flash Store");
|
||||
let cardstore = CardStore::new(store).expect("Could not initialize Card Store");
|
||||
|
||||
let rtc = Rtc::new(peripherals.LPWR);
|
||||
//setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
|
||||
setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
|
||||
|
||||
let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
|
||||
if nfc_driver.configure_sam().await.is_ok() {
|
||||
@@ -154,14 +137,11 @@ async fn main(spawner: Spawner) {
|
||||
|
||||
log::info!("Setup complete, entering main loop");
|
||||
spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
|
||||
spawner.spawn(
|
||||
background_tasks::nfc_scanner(nfc_driver, cardstore, rtc).expect("nfc scanner task failed"),
|
||||
);
|
||||
core::future::pending::<()>().await
|
||||
spawner.spawn(background_tasks::nfc_scanner(nfc_driver).expect("nfc scanner task failed"));
|
||||
}
|
||||
|
||||
fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
|
||||
oled.clear().unwrap();
|
||||
oled.clear(BinaryColor::Off).unwrap();
|
||||
|
||||
let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
|
||||
Text::new(text, Point::new(10, 20), text_style)
|
||||
@@ -169,17 +149,3 @@ fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
|
||||
.unwrap();
|
||||
oled.flush().unwrap();
|
||||
}
|
||||
|
||||
fn retry<T, U, F: FnMut(T) -> Result<U, T>>(repetitions: u32, input: T, mut action: F) -> U {
|
||||
let mut initial_state = input;
|
||||
for iteration in 0..repetitions {
|
||||
log::debug!("Trying to initialize. Retries: {iteration}");
|
||||
|
||||
match action(initial_state) {
|
||||
Ok(success) => return success,
|
||||
Err(recovered_input) => initial_state = recovered_input,
|
||||
}
|
||||
}
|
||||
|
||||
panic!("Init failed after {repetitions} retries.")
|
||||
}
|
||||
|
||||
+10
-11
@@ -1,23 +1,22 @@
|
||||
use core::fmt::Display;
|
||||
|
||||
use crate::card::model::RawCard;
|
||||
use crate::card::model::NfcPayload;
|
||||
use alloc::string::{String, ToString};
|
||||
|
||||
pub fn split_nfc_hex(payload: &[u8]) -> Option<RawCard> {
|
||||
pub fn split_nfc_hex(payload: &[u8]) -> Option<NfcPayload<'_>> {
|
||||
if payload.len() < 0x35A {
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(RawCard {
|
||||
event_encoding: payload[0..2].try_into().ok()?,
|
||||
Some(NfcPayload {
|
||||
event_encoding: &payload[0..2],
|
||||
card_type: payload[2],
|
||||
card_uuid: payload[3..5].try_into().ok()?,
|
||||
_reserved: payload[5..9].try_into().ok()?,
|
||||
sprite: payload[9..0x2DB].try_into().ok()?,
|
||||
packed_card_text: payload[0x2DB..0x311].try_into().ok()?,
|
||||
secret: payload[0x311..0x329].try_into().ok()?,
|
||||
_opaque_trailer: payload[0x329..0x35A].try_into().ok()?,
|
||||
_padding: Default::default(),
|
||||
card_uuid: &payload[3..5],
|
||||
_reserved: &payload[5..9],
|
||||
sprite: &payload[9..0x2DB],
|
||||
packed_card_text: &payload[0x2DB..0x311],
|
||||
secret: &payload[0x311..0x329],
|
||||
_opaque_trailer: &payload[0x329..0x35A],
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
+18
-26
@@ -6,24 +6,18 @@ use num_enum::FromPrimitive;
|
||||
use crate::card::decoder::{Events, decode_known_event, decode_packed_card_text, decode_secret};
|
||||
use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
|
||||
|
||||
use binary_serde::BinarySerde;
|
||||
|
||||
#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
|
||||
#[repr(C)]
|
||||
pub struct RawCard {
|
||||
pub event_encoding: [u8; 2],
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct NfcPayload<'a> {
|
||||
pub event_encoding: &'a [u8],
|
||||
pub card_type: u8,
|
||||
pub card_uuid: [u8; 2],
|
||||
pub _reserved: [u8; 4],
|
||||
pub sprite: [u8; 722],
|
||||
pub packed_card_text: [u8; 54],
|
||||
pub secret: [u8; 24],
|
||||
pub _opaque_trailer: [u8; 49],
|
||||
pub _padding: [u8; 2],
|
||||
pub card_uuid: &'a [u8],
|
||||
pub _reserved: &'a [u8],
|
||||
pub sprite: &'a [u8],
|
||||
pub packed_card_text: &'a [u8],
|
||||
pub secret: &'a [u8],
|
||||
pub _opaque_trailer: &'a [u8],
|
||||
}
|
||||
|
||||
static_assertions::const_assert!(RawCard::SERIALIZED_SIZE.is_multiple_of(4));
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)]
|
||||
#[repr(u8)]
|
||||
pub enum CardType {
|
||||
@@ -228,7 +222,7 @@ pub struct Sprite {
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Card {
|
||||
pub uuid: u32,
|
||||
pub uuid: String,
|
||||
pub event: Events,
|
||||
pub cardtype: CardType,
|
||||
pub name: String,
|
||||
@@ -241,19 +235,17 @@ pub struct Card {
|
||||
pub sprite: Sprite,
|
||||
}
|
||||
|
||||
impl TryFrom<RawCard> for Card {
|
||||
impl<'a> TryFrom<NfcPayload<'a>> for Card {
|
||||
type Error = &'static str;
|
||||
|
||||
fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
|
||||
let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
|
||||
| (u16::from_ne_bytes(raw_card.card_uuid) as u32);
|
||||
|
||||
let event = decode_known_event(&raw_card.event_encoding);
|
||||
let cardtype = CardType::from(raw_card.card_type);
|
||||
let (name, trait1, trait2, trait3) = decode_packed_card_text(&raw_card.packed_card_text);
|
||||
let secret = decode_secret(&raw_card.secret);
|
||||
fn try_from(payload: NfcPayload<'a>) -> Result<Self, Self::Error> {
|
||||
let uuid: String = "empty for now".into(); //str::from_utf8(payload.card_uuid).unwrap().into();
|
||||
let event = decode_known_event(payload.event_encoding);
|
||||
let cardtype = CardType::from(payload.card_type);
|
||||
let (name, trait1, trait2, trait3) = decode_packed_card_text(payload.packed_card_text);
|
||||
let secret = decode_secret(payload.secret);
|
||||
let sprite = Sprite {
|
||||
data: raw_card.sprite.to_vec(),
|
||||
data: payload.sprite.to_vec(),
|
||||
};
|
||||
Ok(Self {
|
||||
uuid,
|
||||
|
||||
+10
-10
@@ -1,3 +1,4 @@
|
||||
use alloc::boxed::Box;
|
||||
use embedded_hal_bus::i2c::AtomicDevice;
|
||||
use embedded_hal_bus::util::AtomicCell;
|
||||
use esp_hal::gpio::interconnect::PeripheralInput;
|
||||
@@ -20,19 +21,18 @@ where
|
||||
SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
|
||||
SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
|
||||
{
|
||||
pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
|
||||
pub fn build(self) -> I2cBus<'a> {
|
||||
let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
|
||||
match I2c::new(self.i2c_peripheral, config) {
|
||||
Ok(bus) => {
|
||||
let i2c = bus.with_sda(self.sda).with_scl(self.scl);
|
||||
log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
|
||||
Ok(AtomicCell::new(i2c))
|
||||
}
|
||||
let i2c = match I2c::new(self.i2c_peripheral, config) {
|
||||
Ok(bus) => bus.with_sda(self.sda).with_scl(self.scl),
|
||||
Err(e) => {
|
||||
log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
|
||||
unimplemented!("Partial move makes it impossible to retry.");
|
||||
// Err(self)
|
||||
panic!("Shared I2C bus initialization failed");
|
||||
}
|
||||
}
|
||||
};
|
||||
let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
|
||||
log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
|
||||
|
||||
shared_i2c
|
||||
}
|
||||
}
|
||||
|
||||
+166
-31
@@ -1,6 +1,6 @@
|
||||
use alloc::format;
|
||||
use ch1115::{Ch1115, Size128x64};
|
||||
use alloc::{format, string::String};
|
||||
use display_interface_spi::SPIInterface;
|
||||
use embedded_graphics::pixelcolor::BinaryColor;
|
||||
use embedded_hal_bus::spi::AtomicDevice;
|
||||
use embedded_hal_bus::util::AtomicCell;
|
||||
use esp_hal::delay::Delay;
|
||||
@@ -8,10 +8,72 @@ use esp_hal::gpio::Output;
|
||||
|
||||
use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
|
||||
|
||||
pub type GenericSecondaryDisplay<'a, BUS, RST, DC> =
|
||||
Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
|
||||
pub type SecondaryDisplay<'a> =
|
||||
GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
|
||||
pub struct SecondaryDisplay<'a>(
|
||||
#[cfg(feature = "wokwi")] ssd1306_aliases::SecondaryDisplay<'a>,
|
||||
#[cfg(not(feature = "wokwi"))] ch1115_aliases::SecondaryDisplay<'a>,
|
||||
);
|
||||
|
||||
impl<'a> SecondaryDisplay<'a> {
|
||||
pub fn flush(&mut self) -> Result<(), String> {
|
||||
#[cfg(not(feature = "wokwi"))]
|
||||
return self.0.flush().map_err(|e| format!("{e:?}"));
|
||||
#[cfg(feature = "wokwi")]
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> embedded_graphics::geometry::Dimensions for SecondaryDisplay<'a> {
|
||||
fn bounding_box(&self) -> embedded_graphics::primitives::Rectangle {
|
||||
self.0.bounding_box()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> embedded_graphics::draw_target::DrawTarget for SecondaryDisplay<'a> {
|
||||
type Color = BinaryColor;
|
||||
|
||||
type Error = String;
|
||||
|
||||
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
|
||||
where
|
||||
I: IntoIterator<Item = embedded_graphics::prelude::Pixel<Self::Color>>,
|
||||
{
|
||||
self.0.draw_iter(pixels).map_err(|e| format!("{e:?}"))
|
||||
}
|
||||
|
||||
fn fill_contiguous<I>(
|
||||
&mut self,
|
||||
area: &embedded_graphics::primitives::Rectangle,
|
||||
colors: I,
|
||||
) -> Result<(), Self::Error>
|
||||
where
|
||||
I: IntoIterator<Item = Self::Color>,
|
||||
{
|
||||
self.0
|
||||
.fill_contiguous(area, colors)
|
||||
.map_err(|e| format!("{e:?}"))
|
||||
}
|
||||
|
||||
fn fill_solid(
|
||||
&mut self,
|
||||
area: &embedded_graphics::primitives::Rectangle,
|
||||
color: Self::Color,
|
||||
) -> Result<(), Self::Error> {
|
||||
self.0.fill_solid(area, color).map_err(|e| format!("{e:?}"))
|
||||
}
|
||||
|
||||
fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
|
||||
#[cfg(feature = "wokwi")]
|
||||
return self.0.clear(color).map_err(|e| format!("{e:?}"));
|
||||
|
||||
#[cfg(not(feature = "wokwi"))]
|
||||
{
|
||||
let _ = color;
|
||||
self.0.clear().map_err(|e| format!("{e:?}"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub const SECONDARY_DISPLAY_COUNT: usize = 3;
|
||||
|
||||
pub struct SecondaryDisplayPinConfiguration<'a> {
|
||||
pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
|
||||
@@ -21,39 +83,112 @@ pub struct SecondaryDisplayPinConfiguration<'a> {
|
||||
}
|
||||
|
||||
impl<'a> SecondaryDisplayPinConfiguration<'a> {
|
||||
pub fn build(self) -> [SecondaryDisplay<'a>; 3] {
|
||||
let mut displays = self.cs_pins.map(|cs| {
|
||||
let spi_dev = AtomicDevice::new(self.spi_bus, cs, Delay::new()).unwrap();
|
||||
let interface = SPIInterface::new(spi_dev, self.dc.clone());
|
||||
pub fn build(self) -> [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
|
||||
#[cfg(feature = "wokwi")]
|
||||
type Displays<'b> = [ssd1306_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
|
||||
#[cfg(not(feature = "wokwi"))]
|
||||
type Displays<'b> = [ch1115_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
|
||||
|
||||
Ch1115::new(interface, self.res.clone(), Size128x64)
|
||||
});
|
||||
let reset_pin = self.res.clone();
|
||||
let mut displays = Displays::new(self);
|
||||
displays.reset(reset_pin);
|
||||
|
||||
init_single_reset(&mut displays, self.res);
|
||||
|
||||
displays
|
||||
displays.map(SecondaryDisplay)
|
||||
}
|
||||
}
|
||||
|
||||
fn init_single_reset<'a: 'b, 'b>(
|
||||
displays: impl IntoIterator<Item = &'b mut SecondaryDisplay<'a>>,
|
||||
shared_reset: SharedReset<'a>,
|
||||
) {
|
||||
let mut displays = displays.into_iter().peekable();
|
||||
trait MultiDisplay<'a> {
|
||||
fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self;
|
||||
fn reset(&mut self, shared_reset: SharedReset<'a>);
|
||||
}
|
||||
|
||||
// Reset all secondaries via shared reset
|
||||
let Some(any_display) = displays.peek_mut() else {
|
||||
// no display to initialize
|
||||
return;
|
||||
mod ch1115_aliases {
|
||||
use super::*;
|
||||
use ch1115::{Ch1115, Size128x64};
|
||||
|
||||
type GenericSecondaryDisplay<'a, BUS, RST, DC> =
|
||||
Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
|
||||
pub type SecondaryDisplay<'a> =
|
||||
GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
|
||||
|
||||
impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
|
||||
fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
|
||||
config.cs_pins.map(|cs| {
|
||||
let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
|
||||
let interface = SPIInterface::new(spi_dev, config.dc.clone());
|
||||
|
||||
SecondaryDisplay::new(interface, config.res.clone(), Size128x64)
|
||||
})
|
||||
}
|
||||
|
||||
fn reset(&mut self, shared_reset: SharedReset<'a>) {
|
||||
let mut displays = self.iter_mut().peekable();
|
||||
|
||||
// Reset all secondaries via shared reset
|
||||
let Some(any_display) = displays.peek_mut() else {
|
||||
// no display to initialize
|
||||
return;
|
||||
};
|
||||
any_display.hard_reset(&mut Delay::new()).unwrap();
|
||||
|
||||
shared_reset.disable(true);
|
||||
|
||||
for (i, display) in displays.enumerate() {
|
||||
display
|
||||
.init(&mut Delay::new())
|
||||
.map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod ssd1306_aliases {
|
||||
use super::*;
|
||||
use ssd1306::{
|
||||
Ssd1306, mode::BufferedGraphicsMode, rotation::DisplayRotation, size::DisplaySize128x64,
|
||||
};
|
||||
any_display.hard_reset(&mut Delay::new()).unwrap();
|
||||
|
||||
shared_reset.disable(true);
|
||||
type GenericSecondaryDisplay<'a, BUS, DC> = Ssd1306<
|
||||
SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>,
|
||||
DisplaySize128x64,
|
||||
BufferedGraphicsMode<DisplaySize128x64>,
|
||||
>;
|
||||
pub type SecondaryDisplay<'a> = GenericSecondaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>>;
|
||||
|
||||
for (i, display) in displays.enumerate() {
|
||||
display
|
||||
.init(&mut Delay::new())
|
||||
.map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
|
||||
.unwrap();
|
||||
impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
|
||||
fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
|
||||
config.cs_pins.map(|cs| {
|
||||
let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
|
||||
let interface = SPIInterface::new(spi_dev, config.dc.clone());
|
||||
|
||||
Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
|
||||
.into_buffered_graphics_mode()
|
||||
})
|
||||
}
|
||||
|
||||
fn reset(&mut self, mut shared_reset: SharedReset<'a>) {
|
||||
use ssd1306::mode::DisplayConfig as _;
|
||||
|
||||
let mut displays = self.iter_mut().peekable();
|
||||
|
||||
// Reset all secondaries via shared reset
|
||||
let Some(any_display) = displays.peek_mut() else {
|
||||
// no display to initialize
|
||||
return;
|
||||
};
|
||||
any_display
|
||||
.reset(&mut shared_reset, &mut Delay::new())
|
||||
.unwrap();
|
||||
|
||||
shared_reset.disable(true);
|
||||
|
||||
for (i, display) in displays.enumerate() {
|
||||
display
|
||||
.init()
|
||||
.map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ where
|
||||
RES2: OutputPin + 'static,
|
||||
DC: OutputPin + 'static,
|
||||
{
|
||||
pub fn build(self) -> Result<(PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]), Self> {
|
||||
pub fn build(self) -> (PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]) {
|
||||
let spi = Spi::new(
|
||||
self.spi_peripheral,
|
||||
SpiConfig::default()
|
||||
@@ -178,7 +178,7 @@ where
|
||||
}
|
||||
.build();
|
||||
|
||||
Ok((primary, secondaries))
|
||||
(primary, secondaries)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -15,20 +15,19 @@ pub struct TertiaryDisplayPinConfiguration<'a> {
|
||||
}
|
||||
|
||||
impl<'a> TertiaryDisplayPinConfiguration<'a> {
|
||||
pub fn build(self) -> Result<TertiaryDisplay<'a>, Self> {
|
||||
pub fn build(self) -> TertiaryDisplay<'a> {
|
||||
let device = AtomicDevice::new(self.i2c);
|
||||
let mut lcd = CharacterDisplayPCF8574T::new(device, LcdDisplayType::Lcd16x2, Delay::new());
|
||||
match lcd.init() {
|
||||
Ok(()) => {
|
||||
log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
|
||||
Ok(TertiaryDisplay {
|
||||
TertiaryDisplay {
|
||||
display: lcd,
|
||||
charset: create_custom_char_set!(),
|
||||
})
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
|
||||
Err(self)
|
||||
panic!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -408,3 +407,4 @@ pub const BOX: CharMap = [
|
||||
];
|
||||
|
||||
pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);
|
||||
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
#![no_std]
|
||||
#![feature(vec_into_chunks)]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
@@ -7,7 +6,6 @@ pub mod background_tasks;
|
||||
pub mod card;
|
||||
pub mod display;
|
||||
pub mod drivers;
|
||||
pub mod logging;
|
||||
pub mod navigation;
|
||||
pub mod network;
|
||||
pub mod storage;
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
mod logging_config {
|
||||
include!(concat!(env!("OUT_DIR"), "/log_filter.rs"));
|
||||
}
|
||||
|
||||
struct EnvLogger;
|
||||
|
||||
impl log::Log for EnvLogger {
|
||||
fn enabled(&self, metadata: &log::Metadata) -> bool {
|
||||
let level = metadata.level();
|
||||
let target = metadata.target();
|
||||
logging_config::is_enabled(level, target)
|
||||
}
|
||||
|
||||
fn log(&self, record: &log::Record) {
|
||||
if !self.enabled(record.metadata()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// print with color? default to true if env var unset or set but empty.
|
||||
let with_color = 1
|
||||
== option_env!("ESP_LOG_COLOR")
|
||||
.unwrap_or("1")
|
||||
.parse()
|
||||
.unwrap_or(1);
|
||||
let (color, reset) = if with_color {
|
||||
const RESET: &str = "\u{001B}[0m";
|
||||
const RED: &str = "\u{001B}[31m";
|
||||
const GREEN: &str = "\u{001B}[32m";
|
||||
const YELLOW: &str = "\u{001B}[33m";
|
||||
const BLUE: &str = "\u{001B}[34m";
|
||||
const CYAN: &str = "\u{001B}[35m";
|
||||
|
||||
let color = match record.level() {
|
||||
log::Level::Error => RED,
|
||||
log::Level::Warn => YELLOW,
|
||||
log::Level::Info => GREEN,
|
||||
log::Level::Debug => BLUE,
|
||||
log::Level::Trace => CYAN,
|
||||
};
|
||||
let reset = RESET;
|
||||
(color, reset)
|
||||
} else {
|
||||
("", "")
|
||||
};
|
||||
|
||||
let [now_s, now_ms] = {
|
||||
let now = esp_hal::time::Instant::now()
|
||||
.duration_since_epoch()
|
||||
.as_millis();
|
||||
|
||||
[now / 1000, now % 1000]
|
||||
};
|
||||
|
||||
let level = match record.level() {
|
||||
log::Level::Error => "E",
|
||||
log::Level::Warn => "W",
|
||||
log::Level::Info => "I",
|
||||
log::Level::Debug => "D",
|
||||
log::Level::Trace => "T",
|
||||
};
|
||||
let args = record.args();
|
||||
let line = record.line().unwrap_or(0);
|
||||
let target = record.target();
|
||||
let module = record.module_path().unwrap_or("???");
|
||||
|
||||
let (module, divider) = if module == target {
|
||||
("", "")
|
||||
} else {
|
||||
(module, " ")
|
||||
};
|
||||
|
||||
esp_println::println!(
|
||||
"{color}{now_s:>4}.{now_ms:03}s {level} {target}{divider}{module}:{line} - {args}{reset}"
|
||||
);
|
||||
}
|
||||
|
||||
fn flush(&self) {}
|
||||
}
|
||||
|
||||
pub fn init() {
|
||||
log::set_logger(&EnvLogger).expect("Failed to init logger.");
|
||||
log::set_max_level(logging_config::FILTER_MAX);
|
||||
}
|
||||
@@ -1,6 +1,5 @@
|
||||
use embedded_graphics::{
|
||||
draw_target::DrawTarget as _,
|
||||
pixelcolor::{Rgb565, RgbColor as _},
|
||||
draw_target::DrawTarget as _, pixelcolor::{BinaryColor, Rgb565, RgbColor as _},
|
||||
};
|
||||
|
||||
use crate::drivers::{
|
||||
@@ -19,9 +18,9 @@ pub struct Outputs {
|
||||
impl Outputs {
|
||||
pub fn clear_screens(&mut self) {
|
||||
self.primary_display.clear(Rgb565::BLACK).unwrap();
|
||||
self.secondary_display_1.clear().unwrap();
|
||||
// self.secondary_display_2.clear().unwrap();
|
||||
// self.secondary_display_3.clear().unwrap();
|
||||
self.secondary_display_1.clear(BinaryColor::Off).unwrap();
|
||||
self.secondary_display_2.clear(BinaryColor::Off).unwrap();
|
||||
self.secondary_display_3.clear(BinaryColor::Off).unwrap();
|
||||
self.tertiary_display.clear().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
+2
-31
@@ -1,31 +1,2 @@
|
||||
pub struct MemoryRegion {
|
||||
offset: u32,
|
||||
size: usize,
|
||||
}
|
||||
|
||||
impl MemoryRegion {
|
||||
pub const fn new(offset: u32, size: usize) -> Self {
|
||||
assert!(offset.is_multiple_of(4), "Flash requires 4 bytes alignment");
|
||||
assert!(size.is_multiple_of(4), "Flash requires 4 bytes alignment");
|
||||
Self { offset, size }
|
||||
}
|
||||
|
||||
pub const fn end(&self) -> usize {
|
||||
self.offset as usize + self.size
|
||||
}
|
||||
}
|
||||
|
||||
const MAX_FLASH: usize = 16 * 1024 * 1024;
|
||||
|
||||
const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
|
||||
|
||||
const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
|
||||
|
||||
const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
|
||||
SETTINGS_REGION.end() as u32,
|
||||
MAX_FLASH - SETTINGS_REGION.end(),
|
||||
);
|
||||
|
||||
pub mod cardstore;
|
||||
pub mod settings;
|
||||
pub mod store;
|
||||
pub mod dex_db;
|
||||
pub mod nvs;
|
||||
|
||||
@@ -1,214 +0,0 @@
|
||||
use alloc::collections::BTreeMap;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use binary_serde::{BinarySerde, DeserializeError, Endianness};
|
||||
|
||||
//use crate::card::model::Nfcraw_card;
|
||||
|
||||
use crate::card::model::RawCard;
|
||||
use crate::storage::store::{Store, StoreError};
|
||||
|
||||
use crate::storage::{CARDSTORE_REGION, MemoryRegion};
|
||||
|
||||
const MAX_CARDS: usize = 20000;
|
||||
|
||||
pub const COUNT_REGION: MemoryRegion = MemoryRegion::new(CARDSTORE_REGION.offset, size_of::<u32>());
|
||||
|
||||
const ALLOCATION_TABLE_REGION: MemoryRegion = MemoryRegion::new(
|
||||
COUNT_REGION.end() as u32,
|
||||
MAX_CARDS * AllocationTableEntry::SERIALIZED_SIZE,
|
||||
);
|
||||
|
||||
const CARDS_REGION: MemoryRegion = MemoryRegion::new(
|
||||
ALLOCATION_TABLE_REGION.end() as u32,
|
||||
CARDSTORE_REGION.size - ALLOCATION_TABLE_REGION.end(),
|
||||
);
|
||||
|
||||
#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct AllocationTableEntry {
|
||||
uuid: u32,
|
||||
// this is the numeric offset of the AllocationTableEntry
|
||||
// as well as the card entry in flash memory
|
||||
// size_of::<AllocationTableEntry>() * offset
|
||||
// size_of::<RawCard>() * offset
|
||||
offset: u32,
|
||||
|
||||
creation_date: u64,
|
||||
last_read_date: u64,
|
||||
|
||||
// how often a card has been read by nfc
|
||||
read_count: u32,
|
||||
|
||||
deleted: bool,
|
||||
|
||||
reserved: [u64; 4],
|
||||
_padding: [u8; 3],
|
||||
}
|
||||
|
||||
static_assertions::const_assert!(AllocationTableEntry::SERIALIZED_SIZE.is_multiple_of(4));
|
||||
|
||||
impl AllocationTableEntry {
|
||||
fn new(uuid: u32, offset: u32, timestamp: u64) -> Self {
|
||||
Self {
|
||||
uuid,
|
||||
offset,
|
||||
creation_date: timestamp,
|
||||
last_read_date: timestamp,
|
||||
read_count: 0,
|
||||
deleted: true,
|
||||
reserved: Default::default(),
|
||||
_padding: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum CardStoreError {
|
||||
Store(StoreError),
|
||||
CorruptedEntry(DeserializeError),
|
||||
NoEntry,
|
||||
}
|
||||
|
||||
impl From<StoreError> for CardStoreError {
|
||||
fn from(error: StoreError) -> CardStoreError {
|
||||
CardStoreError::Store(error)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<DeserializeError> for CardStoreError {
|
||||
fn from(error: DeserializeError) -> CardStoreError {
|
||||
CardStoreError::CorruptedEntry(error)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct CardStore {
|
||||
store: Store,
|
||||
count: u32,
|
||||
pub allocation_table: BTreeMap<u32, AllocationTableEntry>,
|
||||
}
|
||||
|
||||
impl CardStore {
|
||||
pub fn new(mut store: Store) -> Result<Self, CardStoreError> {
|
||||
let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
|
||||
|
||||
store.read(COUNT_REGION.offset, &mut count_bytes)?;
|
||||
|
||||
let count: u32 = u32::from_ne_bytes(count_bytes);
|
||||
|
||||
log::info!("Found {count} cards in flash.");
|
||||
|
||||
let mut allocation_table_entries: Vec<u8> =
|
||||
Vec::with_capacity(AllocationTableEntry::SERIALIZED_SIZE * count as usize);
|
||||
|
||||
store.read(
|
||||
ALLOCATION_TABLE_REGION.offset,
|
||||
&mut allocation_table_entries,
|
||||
)?;
|
||||
|
||||
let chunks =
|
||||
allocation_table_entries.into_chunks::<{ AllocationTableEntry::SERIALIZED_SIZE }>();
|
||||
|
||||
let mut allocation_table = BTreeMap::<u32, AllocationTableEntry>::new();
|
||||
for chunk in chunks {
|
||||
let allocation_table_entry =
|
||||
AllocationTableEntry::binary_deserialize(chunk.as_ref(), Endianness::Little)?;
|
||||
allocation_table.insert(allocation_table_entry.uuid, allocation_table_entry);
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
store,
|
||||
count,
|
||||
allocation_table,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn get_card_by_uuid(&mut self, uuid: u32) -> Result<RawCard, CardStoreError> {
|
||||
let entry = self
|
||||
.allocation_table
|
||||
.get(&uuid)
|
||||
.ok_or(CardStoreError::NoEntry)?;
|
||||
|
||||
let mut raw_card: [u8; size_of::<RawCard>()] = [0; size_of::<RawCard>()];
|
||||
self.store.read(entry.offset, &mut raw_card)?;
|
||||
|
||||
Ok(RawCard::binary_deserialize(
|
||||
raw_card.as_ref(),
|
||||
Endianness::Little,
|
||||
)?)
|
||||
}
|
||||
|
||||
pub fn save_raw_card(
|
||||
&mut self,
|
||||
raw_card: RawCard,
|
||||
timestamp: u64,
|
||||
) -> Result<(), CardStoreError> {
|
||||
let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
|
||||
| (u16::from_ne_bytes(raw_card.card_uuid) as u32);
|
||||
log::info!("Saving card with uuid {:x}", uuid);
|
||||
|
||||
// check if we already got the card
|
||||
// if not find the next deleted entry,
|
||||
// if none create a new one at the end
|
||||
let (entry, is_new) = match self.allocation_table.get_mut(&uuid) {
|
||||
Some(entry) => {
|
||||
log::debug!("old entry");
|
||||
(entry, false)
|
||||
}
|
||||
None => match self
|
||||
.allocation_table
|
||||
.values_mut()
|
||||
.find(|entry| entry.deleted)
|
||||
{
|
||||
Some(entry) => {
|
||||
log::debug!("deleted entry");
|
||||
(entry, true)
|
||||
}
|
||||
None => {
|
||||
log::debug!("new entry");
|
||||
let entry = AllocationTableEntry::new(uuid, self.count + 1, timestamp);
|
||||
self.allocation_table.insert(uuid, entry);
|
||||
(
|
||||
self.allocation_table
|
||||
.get_mut(&uuid)
|
||||
.expect("entry was just inserted"),
|
||||
true,
|
||||
)
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
// only write card data if it is new. else it is already written in flash
|
||||
if is_new {
|
||||
log::debug!("writing RawCard to flash");
|
||||
let mut serialized_card: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
|
||||
raw_card.binary_serialize(&mut serialized_card, Endianness::Little);
|
||||
self.store.write_erase(
|
||||
CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32,
|
||||
&mut serialized_card,
|
||||
)?;
|
||||
} else {
|
||||
entry.last_read_date = timestamp;
|
||||
entry.read_count += 1;
|
||||
}
|
||||
|
||||
entry.deleted = false;
|
||||
|
||||
log::debug!("writing AllocationTableEntry to flash");
|
||||
let mut serialized_entry: [u8; AllocationTableEntry::SERIALIZED_SIZE] =
|
||||
[0; AllocationTableEntry::SERIALIZED_SIZE];
|
||||
entry.binary_serialize(&mut serialized_entry, Endianness::Little);
|
||||
self.store.write_erase(
|
||||
ALLOCATION_TABLE_REGION.offset
|
||||
+ entry.offset * AllocationTableEntry::SERIALIZED_SIZE as u32,
|
||||
&mut serialized_entry,
|
||||
)?;
|
||||
|
||||
self.count += 1;
|
||||
log::debug!("writing card count to flash");
|
||||
let mut serialized_count: [u8; 4] = self.count.to_le_bytes();
|
||||
self.store
|
||||
.write(COUNT_REGION.offset, serialized_count.as_mut_slice())?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
// Storage dex_db module
|
||||
@@ -0,0 +1 @@
|
||||
// Storage nvs module
|
||||
@@ -1,78 +0,0 @@
|
||||
use embedded_storage::nor_flash::NorFlash;
|
||||
use embedded_storage::nor_flash::ReadNorFlash;
|
||||
use esp_storage::{FlashStorage, FlashStorageError};
|
||||
|
||||
use crate::storage::MAGIC_REGION;
|
||||
|
||||
pub type StoreError = FlashStorageError;
|
||||
|
||||
const FLASH_ADDR: u32 = 0x9000;
|
||||
|
||||
const INITIALIZATION_SIZE: usize = 0x1000;
|
||||
const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de;
|
||||
|
||||
pub struct Store {
|
||||
pub storage: FlashStorage<'static>,
|
||||
}
|
||||
|
||||
impl Store {
|
||||
pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, StoreError> {
|
||||
let mut storage = FlashStorage::new(flash);
|
||||
|
||||
let mut magic: [u8; 4] = [0, 0, 0, 0];
|
||||
storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
|
||||
log::debug!("Magic bytes are {magic:?}");
|
||||
|
||||
if Self::has_magic_bytes(&mut storage)? {
|
||||
log::info!("Skipped flash initialization, magic bytes already present.");
|
||||
} else {
|
||||
log::info!("Initializing flash because no magic bytes found.");
|
||||
Self::initialize_flash(&mut storage)?;
|
||||
}
|
||||
|
||||
Ok(Self { storage })
|
||||
}
|
||||
|
||||
pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
|
||||
self.storage.read(FLASH_ADDR + offset, bytes)
|
||||
}
|
||||
|
||||
pub fn write(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
|
||||
log::debug!("Writing {} bytes at offset 0x{offset:08x}", bytes.len());
|
||||
self.storage.write(FLASH_ADDR + offset, bytes)
|
||||
}
|
||||
|
||||
pub fn write_erase(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
|
||||
log::debug!(
|
||||
"Erasing and Writing {} bytes at offset 0x{offset:08x}",
|
||||
bytes.len()
|
||||
);
|
||||
self.storage
|
||||
.erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
|
||||
self.storage.write(FLASH_ADDR + offset, bytes)
|
||||
}
|
||||
|
||||
pub fn has_magic_bytes(storage: &mut FlashStorage) -> Result<bool, StoreError> {
|
||||
let mut magic: [u8; 4] = [0, 0, 0, 0];
|
||||
storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
|
||||
log::debug!("Magic bytes are {magic:?}");
|
||||
|
||||
Ok(u32::from_ne_bytes(magic) == FLASH_INITIALIZE_MAGIC)
|
||||
}
|
||||
|
||||
pub fn initialize_flash(storage: &mut FlashStorage) -> Result<(), StoreError> {
|
||||
storage.erase(FLASH_ADDR, FLASH_ADDR + INITIALIZATION_SIZE as u32)?;
|
||||
let zeros: [u8; INITIALIZATION_SIZE] = [0; INITIALIZATION_SIZE];
|
||||
storage.write(FLASH_ADDR + MAGIC_REGION.end() as u32, &zeros)?;
|
||||
storage.write(
|
||||
FLASH_ADDR + MAGIC_REGION.offset,
|
||||
&FLASH_INITIALIZE_MAGIC.to_ne_bytes(),
|
||||
)?;
|
||||
|
||||
if Self::has_magic_bytes(storage)? {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(StoreError::Other(FLASH_INITIALIZE_MAGIC as i32))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
pub mod card_view;
|
||||
pub mod flash_info_view;
|
||||
pub mod journal_view;
|
||||
pub mod main_menu;
|
||||
pub mod menu_item;
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
use crate::navigation::inputs::ButtonAction;
|
||||
use crate::navigation::navigation::Action;
|
||||
use crate::navigation::navigation::Navigable;
|
||||
use crate::navigation::navigation::NewState;
|
||||
use crate::navigation::outputs::Outputs;
|
||||
use crate::views::view::View;
|
||||
use embedded_graphics::mono_font::MonoTextStyle;
|
||||
use embedded_graphics::mono_font::ascii::FONT_10X20;
|
||||
use embedded_graphics::pixelcolor::Rgb565;
|
||||
use embedded_graphics::prelude::DrawTarget;
|
||||
use embedded_graphics::prelude::RgbColor;
|
||||
use embedded_graphics::text::Text;
|
||||
|
||||
use embedded_graphics::prelude::Point;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct FlashInfoView {}
|
||||
|
||||
impl Navigable for FlashInfoView {
|
||||
fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
|
||||
let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
|
||||
Text::new("Flash Initialized: {:?}", Point::new(40, 40), style);
|
||||
|
||||
core::future::ready(())
|
||||
}
|
||||
|
||||
fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
|
||||
async move {
|
||||
let Action::Button(input) = input else {
|
||||
// Skip timer inputs
|
||||
return NewState {
|
||||
view: View::FlashInfo(self.clone()),
|
||||
replace_view: true,
|
||||
redraw: false,
|
||||
};
|
||||
};
|
||||
|
||||
let new_menu = match input {
|
||||
_ => View::FlashInfo(self.clone()),
|
||||
};
|
||||
|
||||
NewState {
|
||||
replace_view: matches!(new_menu, View::FlashInfo(_)),
|
||||
view: new_menu,
|
||||
redraw: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,11 @@
|
||||
use crate::navigation::navigation::{Action, Navigable, NewState};
|
||||
use crate::navigation::outputs::Outputs;
|
||||
use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
|
||||
|
||||
use crate::navigation::inputs::ButtonAction;
|
||||
use crate::views::{menu_item, view::View};
|
||||
|
||||
use embedded_graphics::pixelcolor::Rgb565;
|
||||
use embedded_graphics::prelude::RgbColor;
|
||||
use embedded_graphics_core::draw_target::DrawTarget;
|
||||
|
||||
pub const MAX_SELECTED: i32 = 2;
|
||||
pub const MAX_SELECTED: i8 = 2;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SettingsMenu {
|
||||
@@ -21,50 +18,16 @@ impl Navigable for SettingsMenu {
|
||||
display.clear(Rgb565::BLACK).unwrap();
|
||||
menu_item::show(display, "System Inforation", 0, self.selected);
|
||||
menu_item::show(display, "Wifi Information", 1, self.selected);
|
||||
menu_item::show(display, "Flash Information", 2, self.selected);
|
||||
|
||||
core::future::ready(())
|
||||
}
|
||||
|
||||
fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
|
||||
async move {
|
||||
let Action::Button(input) = input else {
|
||||
// Skip timer inputs
|
||||
return NewState {
|
||||
view: View::Settings(self.clone()),
|
||||
replace_view: true,
|
||||
redraw: false,
|
||||
};
|
||||
};
|
||||
|
||||
let new_menu = match input {
|
||||
ButtonAction::Up => {
|
||||
let new_selected = if (self.selected - 1) < 0 {
|
||||
MAX_SELECTED - 1
|
||||
} else {
|
||||
self.selected - 1
|
||||
};
|
||||
View::Settings(SettingsMenu {
|
||||
selected: new_selected,
|
||||
})
|
||||
}
|
||||
ButtonAction::Down => {
|
||||
let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
|
||||
View::Settings(SettingsMenu {
|
||||
selected: new_selected,
|
||||
})
|
||||
}
|
||||
ButtonAction::Ok => match self.selected {
|
||||
2 => View::FlashInfo(FlashInfoView {}),
|
||||
_ => View::Settings(self.clone()),
|
||||
},
|
||||
_ => View::Settings(self.clone()),
|
||||
};
|
||||
|
||||
NewState {
|
||||
replace_view: matches!(new_menu, View::Settings(_)),
|
||||
view: new_menu,
|
||||
redraw: true,
|
||||
view: View::Settings(SettingsMenu { selected: 0 }),
|
||||
replace_view: true,
|
||||
redraw: !matches!(input, Action::Timer),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+2
-5
@@ -1,8 +1,8 @@
|
||||
use crate::navigation::outputs::Outputs;
|
||||
use crate::views::card_view::CardView;
|
||||
use crate::views::{
|
||||
flash_info_view::FlashInfoView, journal_view::JournalView, main_menu::MainMenu,
|
||||
scan_menu::ScanMenu, settings_menu::SettingsMenu,
|
||||
journal_view::JournalView, main_menu::MainMenu, scan_menu::ScanMenu,
|
||||
settings_menu::SettingsMenu,
|
||||
};
|
||||
|
||||
use crate::navigation::navigation::{Navigable, NewState};
|
||||
@@ -14,7 +14,6 @@ pub enum View {
|
||||
Settings(SettingsMenu),
|
||||
Journal(JournalView),
|
||||
Card(CardView),
|
||||
FlashInfo(FlashInfoView),
|
||||
}
|
||||
|
||||
impl Navigable for View {
|
||||
@@ -26,7 +25,6 @@ impl Navigable for View {
|
||||
View::Settings(settings_menu) => settings_menu.display(outputs).await,
|
||||
View::Journal(journal_view) => journal_view.display(outputs).await,
|
||||
View::Card(card_view) => card_view.display(outputs).await,
|
||||
View::FlashInfo(flash_info_view) => flash_info_view.display(outputs).await,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -42,7 +40,6 @@ impl Navigable for View {
|
||||
View::Settings(settings_menu) => settings_menu.handle_input(input).await,
|
||||
View::Journal(journal_view) => journal_view.handle_input(input).await,
|
||||
View::Card(card_view) => card_view.handle_input(input).await,
|
||||
View::FlashInfo(flash_info_view) => flash_info_view.handle_input(input).await,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user