deleted some imports

.gitattributes

@@ -1 +0,0 @@
-/pcb/bom/ibom.html linguist-vendored

Cargo.lock

@@ -814,7 +814,7 @@ dependencies = [
 [[package]]
 name = "esp-hal-smartled"
 version = "0.17.0"
-source = "git+https://github.com/esp-rs/esp-hal-community.git?branch=main#ab4316534d90e3a12785907f043f6899faee0f20"
+source = "git+https://github.com/esp-rs/esp-hal-community.git?rev=ab4316534d90e3a12785907f043f6899faee0f20#ab4316534d90e3a12785907f043f6899faee0f20"
 dependencies = [
  "document-features",
  "esp-hal",
@@ -1156,7 +1156,6 @@ dependencies = [
  "smart-leds",
  "smoltcp",
  "static_cell",
- "thiserror",
 ]
 
 [[package]]

Cargo.toml

@@ -19,7 +19,7 @@ esp-radio = { version = "0.16.0", features = ["esp32c6","esp-alloc", "wifi", "lo
 esp-rtos = { version = "0.1.1", features = ["esp32c6", "embassy", "esp-radio", "esp-alloc"] }
 
 critical-section = "1.2.0"
-log = { version = "0.4", features = ["release_max_level_info"]}
+log = { version = "0.4" }
 static_cell = { version = "2.1.1", features = ["nightly"] }
 heapless = { version = "0.8.0", default-features = false }
 chrono = { version = "0.4.41", default-features = false } 
@@ -45,12 +45,11 @@ serde = { version = "1.0.219", default-features = false, features = ["derive", "
 serde_json = { version = "1.0.143", default-features = false, features = ["alloc"]}
 
 ds3231 = { version = "0.3.0", features = ["async", "temperature_f32"] }
-esp-hal-smartled = { git = "https://github.com/esp-rs/esp-hal-community.git", package = "esp-hal-smartled", branch = "main", features = ["esp32c6"]}
+esp-hal-smartled = { git = "https://github.com/esp-rs/esp-hal-community.git", rev = "ab4316534d90e3a12785907f043f6899faee0f20", package = "esp-hal-smartled", features = ["esp32c6"]}
 smart-leds = "0.4.0"
 
 embedded-sdmmc = "0.8.0"
 embedded-hal-bus = "0.3.0"
-thiserror = { version = "2.0.17", default-features = false }
 
 [profile.dev]
 # Rust debug is too slow.

src/drivers.rs

@@ -1,2 +1,3 @@
 pub mod nfc_reader;
 pub mod rtc;
+pub mod buzzer;

src/drivers/mock.rs

@@ -0,0 +1,44 @@
+use anyhow::Result;
+use log::debug;
+use std::time::Duration;
+use tokio::time::sleep;
+
+use crate::hardware::{Buzzer, Hotspot, StatusLed};
+
+pub struct MockBuzzer {}
+
+impl Buzzer for MockBuzzer {
+    async fn modulated_tone(&mut self, frequency_hz: f64, duration: Duration) -> Result<()> {
+        debug!("MockBuzzer: modulte tone: {frequency_hz} Hz");
+        sleep(duration).await;
+        Ok(())
+    }
+}
+
+pub struct MockLed {}
+
+impl StatusLed for MockLed {
+    fn turn_off(&mut self) -> Result<()> {
+        debug!("Turn mock LED off");
+        Ok(())
+    }
+
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<()> {
+        debug!("Turn mock LED on to: {color}");
+        Ok(())
+    }
+}
+
+pub struct MockHotspot {}
+
+impl Hotspot for MockHotspot {
+    async fn enable_hotspot(&self) -> Result<()> {
+        debug!("Mockhotspot: Enable hotspot");
+        Ok(())
+    }
+
+    async fn disable_hotspot(&self) -> Result<()> {
+        debug!("Mockhotspot: Disable hotspot");
+        Ok(())
+    }
+}

src/drivers/rtc.rs

@@ -1,6 +1,7 @@
 use chrono::{TimeZone, Utc};
 use ds3231::{
-    Config, DS3231, InterruptControl, Oscillator, SquareWaveFrequency, TimeRepresentation,
+    Config, DS3231, DS3231Error, InterruptControl, Oscillator, SquareWaveFrequency,
+    TimeRepresentation,
 };
 use esp_hal::{
     Async,
@@ -14,6 +15,10 @@ include!(concat!(env!("OUT_DIR"), "/build_time.rs"));
 
 const RTC_ADDRESS: u8 = 0x68;
 
+const SECS_PER_DAY: u64 = 86_400;
+const UNIX_OFFSET_DAYS: u64 = 719_163; // Days from 0000-03-01 to 1970-01-01
+const UTC_PLUS_ONE: u64 = 3600;
+
 pub struct RTCClock {
     dev: DS3231<I2c<'static, Async>>,
 }
@@ -29,7 +34,10 @@ impl RTCClock {
 
     pub async fn get_time(&mut self) -> u64 {
         match self.dev.datetime().await {
-            Ok(datetime) => datetime.and_utc().timestamp() as u64,
+            Ok(datetime) => {
+                let utc_time = datetime.and_utc().timestamp() as u64;
+                utc_time
+            }
             Err(e) => {
                 FEEDBACK_STATE.signal(feedback::FeedbackState::Error);
                 error!("Failed to read RTC datetime: {:?}", e);
@@ -39,6 +47,33 @@ impl RTCClock {
     }
 }
 
+fn unix_to_ymd_string(timestamp: u64) -> (u16, u8, u8) {
+    // Apply UTC+1 offset
+    let ts = timestamp + UTC_PLUS_ONE;
+
+    // Convert to total days since UNIX epoch
+    let days_since_epoch = ts / SECS_PER_DAY;
+
+    // Convert to proleptic Gregorian date
+    civil_from_days(days_since_epoch as i64 + UNIX_OFFSET_DAYS as i64)
+}
+
+// This function returns (year, month, day).
+// Based on the algorithm by Howard Hinnant.
+fn civil_from_days(z: i64) -> (u16, u8, u8) {
+    let mut z = z;
+    z -= 60; // shift epoch for algorithm
+    let era = (z >= 0).then_some(z).unwrap_or(z - 146096) / 146097;
+    let doe = z - era * 146097; // [0, 146096]
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // [0, 399]
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
+    let mp = (5 * doy + 2) / 153; // [0, 11]
+    let d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
+    let m = mp + (if mp < 10 { 3 } else { -9 }); // [1, 12]
+    ((y + (m <= 2) as i64) as u16, m as u8, d as u8)
+}
+
 pub async fn rtc_config(i2c: I2c<'static, Async>) -> DS3231<I2c<'static, Async>> {
     let mut rtc: DS3231<I2c<'static, Async>> = DS3231::new(i2c, RTC_ADDRESS);
     let naive_dt = Utc
@@ -52,7 +87,7 @@ pub async fn rtc_config(i2c: I2c<'static, Async>) -> DS3231<I2c<'static, Async>>
         square_wave_frequency: SquareWaveFrequency::Hz1,
         interrupt_control: InterruptControl::Interrupt, // Enable interrupt mode
         battery_backed_square_wave: false,
-        oscillator_enable: Oscillator::Enabled,
+        oscillator_enable: Oscillator::Disabled,
     };
 
     match rtc.configure(&rtc_config).await {
@@ -64,13 +99,11 @@ pub async fn rtc_config(i2c: I2c<'static, Async>) -> DS3231<I2c<'static, Async>>
         }
     }
 
-    if rtc.datetime().await.unwrap() < naive_dt {
     rtc.set_datetime(&naive_dt).await.unwrap_or_else(|e| {
         FEEDBACK_STATE.signal(feedback::FeedbackState::Error);
         error!("Failed to set RTC datetime: {:?}", e);
     });
     info!("RTC datetime set to: {}", naive_dt);
-    }
 
     match rtc.status().await {
         Ok(mut status) => {
@@ -84,7 +117,12 @@ pub async fn rtc_config(i2c: I2c<'static, Async>) -> DS3231<I2c<'static, Async>>
         Err(e) => info!("Failed to read status: {:?}", e),
     }
 
-    info!("RTC time is: {:?}", rtc.datetime().await.unwrap());
-
     rtc
 }
+
+pub async fn read_rtc_time<'a>(
+    rtc: &'a mut DS3231<I2c<'static, Async>>,
+) -> Result<u64, DS3231Error<esp_hal::i2c::master::Error>> {
+    let timestamp_result = rtc.datetime().await?;
+    Ok(timestamp_result.and_utc().timestamp() as u64)
+}

src/feedback.rs

@@ -1,6 +1,7 @@
 use embassy_time::{Duration, Timer};
-use esp_hal::gpio::Output;
+use esp_hal::rmt::Rmt;
-use esp_hal_smartled::SmartLedsAdapterAsync;
+use esp_hal::peripherals;
+use esp_hal_smartled::{SmartLedsAdapterAsync, buffer_size_async};
 use log::debug;
 use smart_leds::SmartLedsWriteAsync;
 use smart_leds::colors::{BLACK, GREEN, RED, YELLOW};
@@ -25,10 +26,18 @@ const LED_LEVEL: u8 = 255;
 
 #[embassy_executor::task]
 pub async fn feedback_task(
-    mut led: SmartLedsAdapterAsync<'static, { hardware::LED_BUFFER_SIZE }>,
+    rmt: Rmt<'static, esp_hal::Async>,
-    mut buzzer: Output<'static>,
+    led_gpio: peripherals::GPIO1<'static>,
+    buzzer_gpio: peripherals::GPIO21<'static>,
 ) {
     debug!("Starting feedback task");
+
+    let rmt_channel = rmt.channel0;
+    let rmt_buffer = [esp_hal::rmt::PulseCode::default(); buffer_size_async(hardware::NUM_LEDS)];
+
+    let mut led = SmartLedsAdapterAsync::new(rmt_channel, led_gpio, rmt_buffer);
+
+    let mut buzzer = init::hardware::setup_buzzer(buzzer_gpio);
     loop {
         let feedback_state = FEEDBACK_STATE.wait().await;
         match feedback_state {
@@ -104,8 +113,6 @@ pub async fn feedback_task(
                 buzzer.set_high();
                 Timer::after(Duration::from_millis(100)).await;
                 buzzer.set_low();
-
-                Timer::after(Duration::from_secs(2)).await;
                 led.write(brightness(
                     [BLACK; init::hardware::NUM_LEDS].into_iter(),
                     LED_LEVEL,

src/init/hardware.rs

@@ -1,12 +1,15 @@
+use core::cell::RefCell;
+use critical_section::Mutex;
 use embassy_executor::Spawner;
 use embassy_net::Stack;
 use embassy_time::{Duration, Timer};
 use esp_hal::Blocking;
 use esp_hal::delay::Delay;
-use esp_hal::gpio::AnyPin;
+use esp_hal::gpio::Input;
 use esp_hal::i2c::master::Config;
 use esp_hal::peripherals::{
-    GPIO1, GPIO16, GPIO17, GPIO18, GPIO19, GPIO20, GPIO21, GPIO22, GPIO23, I2C0, RMT, SPI2, UART1,
+    GPIO0, GPIO1, GPIO16, GPIO17, GPIO18, GPIO19, GPIO20, GPIO21, GPIO22, GPIO23, I2C0, RMT, SPI2,
+    UART1,
 };
 use esp_hal::rmt::Rmt;
 use esp_hal::spi::master::{Config as Spi_config, Spi};
@@ -18,15 +21,12 @@ use esp_hal::{
     clock::CpuClock,
     gpio::{Output, OutputConfig},
     i2c::master::I2c,
+    timer::systimer::SystemTimer,
     uart::Uart,
 };
 use esp_hal_smartled::{SmartLedsAdapterAsync, buffer_size_async};
 use esp_println::logger::init_logger;
 use log::{debug, error};
-use smart_leds::SmartLedsWriteAsync;
-use smart_leds::brightness;
-use smart_leds::colors::RED;
-use thiserror::Error;
 
 use crate::init::network;
 use crate::init::sd_card::{SDCardPersistence, setup_sdcard};
@@ -50,7 +50,8 @@ use crate::init::wifi;
  *************************************************/
 
 pub const NUM_LEDS: usize = 1;
-pub const LED_BUFFER_SIZE: usize = buffer_size_async(NUM_LEDS);
+
+static SD_DET: Mutex<RefCell<Option<Input>>> = Mutex::new(RefCell::new(None));
 
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo) -> ! {
@@ -62,36 +63,19 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
 
 esp_bootloader_esp_idf::esp_app_desc!();
 
-#[derive(Error, Debug)]
+pub async fn hardware_init(
-pub enum HardwareInitError {
+    spawner: Spawner,
-    #[error("Failed to etup UART")]
+) -> (
-    Uart(#[from] esp_hal::uart::ConfigError),
+    Uart<'static, Async>,
-
+    Stack<'static>,
-    #[error("Failed to setup I2C")]
+    I2c<'static, Async>,
-    I2C(#[from] esp_hal::i2c::master::ConfigError),
+    Rmt<'static, esp_hal::Async>,
-
+    GPIO1<'static>,
-    #[error("Failed to setup SPI")]
+    GPIO21<'static>,
-    Spi(#[from] esp_hal::spi::master::ConfigError),
+    GPIO0<'static>,
-
+    SmartLedsAdapterAsync<'static, LED_BUFFER_SIZE>,
-    #[error("Failed to setuo LED")]
+    SDCardPersistence,
-    Led(#[from] esp_hal::rmt::Error),
+) {
-
-    #[error("Failed to setup wifi")]
-    Wifi(#[from] wifi::WifiError),
-}
-
-pub struct AppHardware {
-    pub uart: Uart<'static, Async>,
-    pub network_stack: Stack<'static>,
-    pub i2c: I2c<'static, Async>,
-    pub buzzer: Output<'static>,
-    pub sd_present: AnyPin<'static>,
-    pub led: SmartLedsAdapterAsync<'static, LED_BUFFER_SIZE>,
-    pub sdcard: SDCardPersistence,
-}
-
-impl AppHardware {
-    pub async fn init(spawner: Spawner) -> Result<Self, HardwareInitError> {
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
 
@@ -104,34 +88,31 @@ impl AppHardware {
 
     init_logger(log::LevelFilter::Debug);
 
-        let mut led = setup_led(peripherals.RMT, peripherals.GPIO1)?;
-        let _ = led.write(brightness(
-                    [RED; NUM_LEDS].into_iter(),
-                    255,
-                ))
-                .await;
-
     let rng = esp_hal::rng::Rng::new();
     let network_seed = (rng.random() as u64) << 32 | rng.random() as u64;
 
     wifi::set_antenna_mode(peripherals.GPIO3, peripherals.GPIO14).await;
-        let interfaces = wifi::setup_wifi(peripherals.WIFI, spawner)?;
+    let interfaces = wifi::setup_wifi(peripherals.WIFI, spawner);
-        let network_stack = network::setup_network(network_seed, interfaces.ap, spawner);
+    let stack = network::setup_network(network_seed, interfaces.ap, spawner);
 
     Timer::after(Duration::from_millis(1)).await;
 
-        let uart_device = setup_uart(peripherals.UART1, peripherals.GPIO16, peripherals.GPIO17)?;
+    let uart_device = setup_uart(peripherals.UART1, peripherals.GPIO16, peripherals.GPIO17);
 
-        let i2c_device = setup_i2c(peripherals.I2C0, peripherals.GPIO22, peripherals.GPIO23)?;
+    let i2c_device = setup_i2c(peripherals.I2C0, peripherals.GPIO22, peripherals.GPIO23);
 
     let sd_det_gpio = peripherals.GPIO0;
 
+    let rmt: Rmt<'_, esp_hal::Async> = {let frequency: Rate = Rate::from_mhz(80);
+    Rmt::new(peripherals.RMT, frequency)}    .expect("Failed to initialize RMT")
+    .into_async();
+
     let spi_bus = setup_spi(
         peripherals.SPI2,
         peripherals.GPIO19,
         peripherals.GPIO20,
         peripherals.GPIO18,
-        )?;
+    );
 
     let sd_cs_pin = Output::new(
         peripherals.GPIO2,
@@ -141,45 +122,59 @@ impl AppHardware {
 
     let vol_mgr = setup_sdcard(spi_bus, sd_cs_pin);
 
+    let led_gpio = peripherals.GPIO1;
     let buzzer_gpio = peripherals.GPIO21;
-        let buzzer = setup_buzzer(buzzer_gpio);
+
+    let led = setup_led(peripherals.RMT, peripherals.GPIO1);
 
     Timer::after(Duration::from_millis(500)).await;
 
     debug!("hardware init done");
 
-        Ok(Self {
+    (
-            uart: uart_device,
+        uart_device,
-            network_stack,
+        stack,
-            i2c: i2c_device,
+        i2c_device,
-            buzzer,
+        rmt,
-            sd_present: sd_det_gpio.into(),
+        led_gpio,
+        buzzer_gpio,
+        sd_det_gpio,
         led,
-            sdcard: vol_mgr,
+        vol_mgr,
-        })
+    )
-    }
 }
 
 fn setup_uart(
     uart1: UART1<'static>,
     uart_tx: GPIO16<'static>,
     uart_rx: GPIO17<'static>,
-) -> Result<Uart<'static, Async>, esp_hal::uart::ConfigError> {
+) -> Uart<'static, Async> {
-    let uart_device = Uart::new(uart1, esp_hal::uart::Config::default().with_baudrate(9600))?;
+    let uard_device = Uart::new(uart1, esp_hal::uart::Config::default().with_baudrate(9600));
-    Ok(uart_device.with_rx(uart_rx).with_tx(uart_tx).into_async())
+
+    match uard_device {
+        Ok(block) => block.with_rx(uart_rx).with_tx(uart_tx).into_async(),
+        Err(e) => {
+            error!("Failed to initialize UART: {e}");
+            panic!(); //TODO panic!
+        }
+    }
 }
 
 fn setup_i2c(
     i2c0: I2C0<'static>,
     sda: GPIO22<'static>,
     scl: GPIO23<'static>,
-) -> Result<I2c<'static, Async>, esp_hal::i2c::master::ConfigError> {
+) -> I2c<'static, Async> {
     debug!("init I2C");
     let config = Config::default().with_frequency(Rate::from_khz(400));
-
+    let i2c = match I2c::new(i2c0, config) {
-    let i2c = I2c::new(i2c0, config)?;
+        Ok(i2c) => i2c.with_sda(sda).with_scl(scl).into_async(),
-
+        Err(e) => {
-    Ok(i2c.with_sda(sda).with_scl(scl).into_async())
+            error!("Failed to initialize I2C: {:?}", e);
+            panic!(); //TODO panic!
+        }
+    };
+    i2c
 }
 
 fn setup_spi(
@@ -187,34 +182,35 @@ fn setup_spi(
     sck: GPIO19<'static>,
     miso: GPIO20<'static>,
     mosi: GPIO18<'static>,
-) -> Result<Spi<'static, Blocking>, esp_hal::spi::master::ConfigError> {
+) -> Spi<'static, Blocking> {
-    let spi = Spi::new(spi2, Spi_config::default())?;
+    let spi = match Spi::new(spi2, Spi_config::default()) {
-    Ok(spi.with_sck(sck).with_miso(miso).with_mosi(mosi))
+        Ok(spi) => spi.with_sck(sck).with_miso(miso).with_mosi(mosi),
+        Err(e) => panic!("Failed to initialize SPI: {:?}", e),
+    };
+    spi
 }
 
 pub fn setup_buzzer(buzzer_gpio: GPIO21<'static>) -> Output<'static> {
     let config = esp_hal::gpio::OutputConfig::default()
         .with_drive_strength(esp_hal::gpio::DriveStrength::_40mA);
+    let buzzer = Output::new(buzzer_gpio, esp_hal::gpio::Level::Low, config);
 
-    Output::new(buzzer_gpio, esp_hal::gpio::Level::Low, config)
+    buzzer
 }
 
 fn setup_led<'a>(
     rmt: RMT<'a>,
     led_gpio: GPIO1<'a>,
-) -> Result<esp_hal_smartled::SmartLedsAdapterAsync<'a, LED_BUFFER_SIZE>, esp_hal::rmt::Error> {
+) -> esp_hal_smartled::SmartLedsAdapterAsync<'a, LED_BUFFER_SIZE> {
     let rmt: Rmt<'_, esp_hal::Async> = {
         let frequency: Rate = Rate::from_mhz(80);
         Rmt::new(rmt, frequency)
-    }?
+    }
+    .expect("Failed to initialize RMT")
     .into_async();
 
     let rmt_channel = rmt.channel0;
     let rmt_buffer = [esp_hal::rmt::PulseCode::default(); LED_BUFFER_SIZE];
 
-    Ok(SmartLedsAdapterAsync::new(
+    SmartLedsAdapterAsync::new(rmt_channel, led_gpio, rmt_buffer)
-        rmt_channel,
-        led_gpio,
-        rmt_buffer,
-    ))
 }

src/init/network.rs

@@ -1,41 +1,48 @@
+use core::{net::Ipv4Addr, str::FromStr};
+use embassy_executor::Spawner;
+use embassy_net::{Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
+use embassy_time::{Duration, Timer};
+use esp_radio::wifi::WifiDevice;
+use static_cell::make_static;
+
+use crate::webserver::WEB_TAKS_SIZE;
+
+pub const NETWORK_STACK_SIZE: usize = WEB_TAKS_SIZE + 2; // + 2 for other network taks. Breaks
+// without
+
+pub fn setup_network<'a>(seed: u64, wifi: WifiDevice<'static>, spawner: Spawner) -> Stack<'a> {
+    let gw_ip_addr_str = "192.168.2.1";
+    let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
+    let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
+        address: Ipv4Cidr::new(gw_ip_addr, 24),
+        gateway: Some(gw_ip_addr),
+        dns_servers: Default::default(),
+    });
+
+    let nw_stack: &'static mut StackResources<NETWORK_STACK_SIZE> =
+        make_static!(StackResources::<NETWORK_STACK_SIZE>::new());
+
+    let (stack, runner) = embassy_net::new(wifi, config, nw_stack, seed);
+
+    spawner.must_spawn(net_task(runner));
+    spawner.must_spawn(run_dhcp(stack, gw_ip_addr_str));
+
+    stack
+}
+
+#[embassy_executor::task]
+async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
     use core::net::{Ipv4Addr, SocketAddrV4};
+
     use edge_dhcp::{
         io::{self, DEFAULT_SERVER_PORT},
         server::{Server, ServerOptions},
     };
     use edge_nal::UdpBind;
     use edge_nal_embassy::{Udp, UdpBuffers};
-use embassy_executor::Spawner;
-use embassy_net::{Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
-use embassy_time::{Duration, Timer};
-use esp_radio::wifi::WifiDevice;
-use static_cell::StaticCell;
 
-use crate::webserver::WEB_TAKS_SIZE;
+    let ip = Ipv4Addr::from_str(gw_ip_addr).expect("dhcp task failed to parse gw ip");
 
-pub const NETWORK_STACK_SIZE: usize = WEB_TAKS_SIZE + 2; // + 2 for other network taks. Breaks without
-pub const GW_IP: Ipv4Addr = Ipv4Addr::new(192, 168, 2, 1);
-
-pub fn setup_network<'a>(seed: u64, wifi: WifiDevice<'static>, spawner: Spawner) -> Stack<'a> {
-    let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
-        address: Ipv4Cidr::new(GW_IP, 24),
-        gateway: Some(GW_IP),
-        dns_servers: Default::default(),
-    });
-
-    static NETWORK_STACK: StaticCell<StackResources<NETWORK_STACK_SIZE>> = StaticCell::new();
-    let nw_stack = NETWORK_STACK.init(StackResources::new());
-
-    let (stack, runner) = embassy_net::new(wifi, config, nw_stack, seed);
-
-    spawner.must_spawn(net_task(runner));
-    spawner.must_spawn(run_dhcp(stack));
-
-    stack
-}
-
-#[embassy_executor::task]
-async fn run_dhcp(stack: Stack<'static>) {
     let mut buf = [0u8; 1500];
 
     let mut gw_buf = [Ipv4Addr::UNSPECIFIED];
@@ -48,12 +55,12 @@ async fn run_dhcp(stack: Stack<'static>) {
             DEFAULT_SERVER_PORT,
         )))
         .await
-        .expect("Failed to bind socket for DHCP server");
+        .unwrap();
 
     loop {
         _ = io::server::run(
-            &mut Server::<_, 64>::new_with_et(GW_IP),
+            &mut Server::<_, 64>::new_with_et(ip),
-            &ServerOptions::new(GW_IP, Some(&mut gw_buf)),
+            &ServerOptions::new(ip, Some(&mut gw_buf)),
             &mut bound_socket,
             &mut buf,
         )

src/init/sd_card.rs

@@ -1,16 +1,10 @@
-use alloc::{string::ToString, vec::Vec};
+use alloc::vec::Vec;
-use core::str::from_utf8;
 use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::{
+use embedded_sdmmc::{SdCard, ShortFileName, TimeSource, Timestamp, VolumeIdx, VolumeManager};
-    SdCard, SdCardError, ShortFileName, TimeSource, Timestamp, VolumeIdx, VolumeManager,
-};
 use esp_hal::{Blocking, gpio::Output, spi::master::Spi};
-use thiserror::Error;
 
-use crate::store::{
+use crate::store::{AttendanceDay, IDMapping, day::Day, persistence::Persistence};
-    AttendanceDay, day::Day, mapping_loader::Name, persistence::Persistence, tally_id::TallyID,
-};
 
 pub struct DummyTimesource;
 
@@ -45,231 +39,113 @@ pub struct SDCardPersistence {
 }
 
 impl SDCardPersistence {
-    const MAPPING_DIRNAME: &'static str = "MAPPINGS";
+    const MAPPING_FILENAME: &'static str = "MAPPING.JS";
 
-    fn generate_filename_for_day(day: Day) -> Result<ShortFileName, PersistenceError> {
+    fn generate_filename(day: Day) -> ShortFileName {
         let basename = day.to_string();
         let mut filename: heapless::String<11> = heapless::String::new();
-        filename
+        filename.push_str(&basename).unwrap();
-            .push_str(&basename)
+        filename.push_str(".js").unwrap();
-            .map_err(|_| PersistenceError::DayFilename)?;
-        filename
-            .push_str(".JS")
-            .map_err(|_| PersistenceError::DayFilename)?;
 
-        ShortFileName::create_from_str(&filename).map_err(|_| PersistenceError::DayFilename)
+        ShortFileName::create_from_str(&filename).unwrap()
-    }
-
-    fn generate_path_for_id(
-        id: TallyID,
-    ) -> Result<(ShortFileName, ShortFileName), PersistenceError> {
-        let basename: heapless::String<12> = id.into();
-        let (dir, file) = basename.split_at(6);
-
-        let mut filename: heapless::String<11> = heapless::String::new();
-        filename
-            .push_str(file)
-            .map_err(|_| PersistenceError::IDFilename)?;
-        filename
-            .push_str(".JS")
-            .map_err(|_| PersistenceError::IDFilename)?;
-
-        let mut dirname: heapless::String<11> = heapless::String::new();
-        dirname
-            .push_str(dir)
-            .map_err(|_| PersistenceError::IDFilename)?;
-
-        Ok((
-            ShortFileName::create_from_str(&dirname).map_err(|_| PersistenceError::IDFilename)?,
-            ShortFileName::create_from_str(&filename).map_err(|_| PersistenceError::IDFilename)?,
-        ))
-    }
-
-    fn get_tallyid_from_path(
-        dirname: &ShortFileName,
-        filename: &ShortFileName,
-    ) -> Result<TallyID, PersistenceError> {
-        let mut id_str: heapless::String<12> = heapless::String::new();
-
-        id_str
-            .push_str(&dirname.to_string())
-            .map_err(|_| PersistenceError::IDFilename)?;
-        id_str
-            .push_str(from_utf8(filename.base_name()).map_err(|_| PersistenceError::IDFilename)?)
-            .map_err(|_| PersistenceError::IDFilename)?;
-
-        let id: TallyID = id_str
-            .try_into()
-            .map_err(|_| PersistenceError::IDFilename)?;
-
-        Ok(id)
-    }
-}
-
-#[derive(Error, Debug)]
-pub enum PersistenceError {
-    #[error("Failed to interact with SD card")]
-    SdCard(embedded_sdmmc::Error<SdCardError>),
-
-    #[error("Failed to parse data")]
-    Parseing(#[from] serde_json::Error),
-
-    #[error("Failed to parse Day and Filename")]
-    DayFilename,
-
-    #[error("Failed to parse TallyID for file path")]
-    IDFilename,
-
-    #[error("Item not found")]
-    NotFound,
-}
-
-impl From<embedded_sdmmc::Error<SdCardError>> for PersistenceError {
-    fn from(err: embedded_sdmmc::Error<SdCardError>) -> Self {
-        PersistenceError::SdCard(err)
     }
 }
 
 impl Persistence for SDCardPersistence {
-    type Error = PersistenceError;
+    async fn load_day(&mut self, day: Day) -> Option<AttendanceDay> {
+        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
+        let mut root_dir = vol_0.open_root_dir().unwrap();
 
-    async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, Self::Error> {
+        let filename = Self::generate_filename(day);
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
-        let mut root_dir = vol_0.open_root_dir()?;
-
-        let filename = Self::generate_filename_for_day(day)?;
         let file = root_dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadOnly);
 
         if file.is_err() {
-            return Err(PersistenceError::NotFound);
+            return None;
         }
 
-        let mut open_file = file?;
+        let mut open_file = file.unwrap();
 
         let mut read_buffer: [u8; 1024] = [0; 1024];
-        let read = open_file.read(&mut read_buffer)?;
+        let read = open_file.read(&mut read_buffer).unwrap();
-        open_file.close()?;
+        open_file.close().unwrap();
 
-        let day: AttendanceDay = serde_json::from_slice(&read_buffer[..read])?;
+        let day: AttendanceDay = serde_json::from_slice(&read_buffer[..read]).unwrap();
 
-        Ok(day)
+        Some(day)
     }
 
-    async fn save_day(&mut self, day: Day, data: &AttendanceDay) -> Result<(), Self::Error> {
+    async fn save_day(&mut self, day: Day, data: &AttendanceDay) {
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
+        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
-        let mut root_dir = vol_0.open_root_dir()?;
+        let mut root_dir = vol_0.open_root_dir().unwrap();
 
-        let filename = Self::generate_filename_for_day(day)?;
+        let filename = Self::generate_filename(day);
 
-        let mut file =
+        let mut file = root_dir
-            root_dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)?;
+            .open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)
+            .unwrap();
 
-        file.write(&serde_json::to_vec(data)?)?;
+        file.write(&serde_json::to_vec(data).unwrap()).unwrap();
 
-        file.flush()?;
+        file.flush().unwrap();
-        file.close()?;
+        file.close().unwrap();
-
-        Ok(())
     }
 
-    async fn list_days(&mut self) -> Result<Vec<Day>, Self::Error> {
+    async fn load_mapping(&mut self) -> Option<crate::store::IDMapping> {
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
+        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
-        let mut root_dir = vol_0.open_root_dir()?;
+        let mut root_dir = vol_0.open_root_dir().unwrap();
 
-        let mut days_dir = root_dir.open_dir(".")?;
+        let file =
+            root_dir.open_file_in_dir(Self::MAPPING_FILENAME, embedded_sdmmc::Mode::ReadOnly);
+
+        if file.is_err() {
+            return None;
+        }
+
+        let mut open_file = file.unwrap();
+
+        let mut read_buffer: [u8; 1024] = [0; 1024];
+        let read = open_file.read(&mut read_buffer).unwrap();
+        open_file.close().unwrap();
+
+        let mapping: IDMapping = serde_json::from_slice(&read_buffer[..read]).unwrap();
+
+        Some(mapping)
+    }
+
+    async fn save_mapping(&mut self, data: &crate::store::IDMapping) {
+        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
+        let mut root_dir = vol_0.open_root_dir().unwrap();
+
+        let mut file = root_dir
+            .open_file_in_dir(
+                Self::MAPPING_FILENAME,
+                embedded_sdmmc::Mode::ReadWriteCreateOrTruncate,
+            )
+            .unwrap();
+
+        file.write(&serde_json::to_vec(data).unwrap()).unwrap();
+
+        file.flush().unwrap();
+        file.close().unwrap();
+    }
+
+    async fn list_days(&mut self) -> Vec<Day> {
+        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
+        let mut root_dir = vol_0.open_root_dir().unwrap();
+
+        let mut days_dir = root_dir.open_dir(".").unwrap();
 
         let mut days: Vec<Day> = Vec::new();
-        days_dir.iterate_dir(|e| {
+        days_dir
+            .iterate_dir(|e| {
                 let filename = e.name.clone();
 
                 if let Ok(day) = filename.try_into() {
                     days.push(day);
                 }
-        })?;
+            })
+            .unwrap();
 
-        Ok(days)
+        days
-    }
-
-    async fn load_mapping_for_id(
-        &mut self,
-        id: crate::store::tally_id::TallyID,
-    ) -> Result<crate::store::mapping_loader::Name, Self::Error> {
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
-        let mut root_dir = vol_0.open_root_dir()?;
-        let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
-
-        let (dirname, filename) = Self::generate_path_for_id(id)?;
-
-        let mut dir = mapping_dir.open_dir(dirname)?;
-        let mut file = dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadOnly)?;
-
-        let mut read_buffer: [u8; 1024] = [0; 1024];
-        let read_bytes = file.read(&mut read_buffer)?;
-        file.close()?;
-
-        let mapping: Name = serde_json::from_slice(&read_buffer[..read_bytes])?;
-
-        Ok(mapping)
-    }
-
-    async fn save_mapping_for_id(
-        &mut self,
-        id: crate::store::tally_id::TallyID,
-        name: crate::store::mapping_loader::Name,
-    ) -> Result<(), Self::Error> {
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
-        let mut root_dir = vol_0.open_root_dir()?;
-        let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
-
-        let (dirname, filename) = Self::generate_path_for_id(id)?;
-
-        let mut dir = if let Ok(dir) = mapping_dir.open_dir(&dirname) {
-            dir
-        } else {
-            mapping_dir.make_dir_in_dir(&dirname)?;
-            mapping_dir.open_dir(&dirname)?
-        };
-
-        let mut file =
-            dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)?;
-
-        file.write(&serde_json::to_vec(&name)?)?;
-
-        Ok(())
-    }
-
-    async fn list_mappings(&mut self) -> Result<Vec<TallyID>, Self::Error> {
-        let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
-        let mut root_dir = vol_0.open_root_dir()?;
-        let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
-        let mut ids: Vec<TallyID> = Vec::new();
-
-        let mut dir_names = Vec::new();
-        mapping_dir.iterate_dir(|entry| {
-            if entry.attributes.is_directory()
-                && entry.name.to_string() != "."
-                && entry.name.to_string() != ".."
-            {
-                dir_names.push(entry.name.clone());
-            }
-        })?;
-
-        for dirname in dir_names {
-            if let Ok(mut subdir) = mapping_dir.open_dir(&dirname) {
-                let mut file_names = Vec::new();
-                subdir.iterate_dir(|file_entry| {
-                    if !file_entry.attributes.is_directory() {
-                        file_names.push(file_entry.name.clone());
-                    }
-                })?;
-
-                for filename in file_names {
-                    let id = Self::get_tallyid_from_path(&dirname, &filename)?;
-                    ids.push(id);
-                }
-            }
-        }
-
-        Ok(ids)
     }
 }

src/init/wifi.rs

@@ -8,7 +8,8 @@ use esp_radio::wifi::{
 };
 use log::debug;
 use static_cell::StaticCell;
-use thiserror::Error;
+
+static ESP_WIFI_CTRL: StaticCell<Controller<'static>> = StaticCell::new();
 
 pub async fn set_antenna_mode(gpio3: GPIO3<'static>, gpio14: GPIO14<'static>) {
     let mut rf_switch = Output::new(gpio3, esp_hal::gpio::Level::Low, OutputConfig::default());
@@ -22,45 +23,29 @@ pub async fn set_antenna_mode(gpio3: GPIO3<'static>, gpio14: GPIO14<'static>) {
     antenna_mode.set_low();
 }
 
-#[derive(Error, Debug)]
+pub fn setup_wifi<'d: 'static>(wifi: WIFI<'static>, spawner: Spawner) -> Interfaces<'d> {
-pub enum WifiError {
+    let esp_wifi_ctrl = ESP_WIFI_CTRL.init(esp_radio::init().unwrap());
-    #[error("Failed to init radio")]
-    Init(#[from] esp_radio::InitializationError),
-
-    #[error("Failed to init wifi")]
-    Wifi(#[from] esp_radio::wifi::WifiError),
-
-    #[error("Failed to spawn wifi task")]
-    Spawn(#[from] embassy_executor::SpawnError),
-}
-
-pub fn setup_wifi<'d: 'static>(
-    wifi: WIFI<'static>,
-    spawner: Spawner,
-) -> Result<Interfaces<'d>, WifiError> {
-    static ESP_WIFI_CTRL: StaticCell<Controller<'static>> = StaticCell::new();
-
-    let esp_wifi_ctrl = ESP_WIFI_CTRL.init(esp_radio::init()?);
 
     let config = esp_radio::wifi::Config::default();
-    let (controller, interfaces) = esp_radio::wifi::new(esp_wifi_ctrl, wifi, config)?;
+    let (controller, interfaces) = esp_radio::wifi::new(esp_wifi_ctrl, wifi, config).unwrap();
 
-    spawner.spawn(connection(controller))?;
+    spawner.must_spawn(connection(controller));
 
-    Ok(interfaces)
+    interfaces
 }
 #[embassy_executor::task]
 async fn connection(mut controller: WifiController<'static>) {
     debug!("start connection task");
     debug!("Device capabilities: {:?}", controller.capabilities());
-
     loop {
-        if esp_radio::wifi::ap_state() == WifiApState::Started {
+        match esp_radio::wifi::ap_state() {
+            WifiApState::Started => {
                 // wait until we're no longer connected
                 controller.wait_for_event(WifiEvent::ApStop).await;
                 Timer::after(Duration::from_millis(5000)).await
             }
-
+            _ => {}
+        }
         if !matches!(controller.is_started(), Ok(true)) {
             let client_config = ModeConfig::AccessPoint(
                 AccessPointConfig::default()

src/main.rs

@@ -17,16 +17,16 @@ use embassy_sync::{
     signal::Signal,
 };
 use embassy_time::{Duration, Timer};
-use esp_hal::gpio::InputConfig;
+use esp_hal::gpio::Input;
-use esp_hal::gpio::{AnyPin, Input};
+use esp_hal::{gpio::InputConfig, peripherals};
 use log::{debug, info};
 use static_cell::StaticCell;
 
 extern crate alloc;
 
 use crate::{
-    init::{hardware::AppHardware, sd_card::SDCardPersistence},
+    init::sd_card::SDCardPersistence,
-    store::{IDStore, day::Day, mapping_loader::MappingLoader, tally_id::TallyID},
+    store::{IDStore, day::Day, tally_id::TallyID},
     webserver::start_webserver,
 };
 
@@ -47,51 +47,36 @@ static CHAN: StaticCell<TallyChannel> = StaticCell::new();
 
 #[esp_rtos::main]
 async fn main(spawner: Spawner) -> ! {
-    let app_hardware = AppHardware::init(spawner).await.unwrap();
+    let (uart_device, stack, i2c, rmt, led_gpio, buzzer_gpio, sd_det_gpio, persistence_layer) =
+        init::hardware::hardware_init(spawner).await;
 
     info!("Starting up...");
 
-    let mut rtc = drivers::rtc::RTCClock::new(app_hardware.i2c).await;
+    let mut rtc = drivers::rtc::RTCClock::new(i2c).await;
 
-    let current_day: Day = rtc.get_time().await.into();
+    let store: UsedStore = IDStore::new_from_storage(persistence_layer).await;
-
-    let shared_sdcard: Rc<Mutex<CriticalSectionRawMutex, SDCardPersistence>> =
-        Rc::new(Mutex::new(app_hardware.sdcard));
-
-    let store: UsedStore = IDStore::new_from_storage(shared_sdcard.clone(), current_day).await;
     let shared_store = Rc::new(Mutex::new(store));
 
-    let mapping_loader = MappingLoader::new(shared_sdcard.clone());
-
     let chan: &'static mut TallyChannel = CHAN.init(PubSubChannel::new());
     let publisher: TallyPublisher = chan.publisher().unwrap();
     let mut sub: TallySubscriber = chan.subscriber().unwrap();
 
-    wait_for_stack_up(app_hardware.network_stack).await;
+    wait_for_stack_up(stack).await;
 
-    start_webserver(
+    start_webserver(spawner, stack, shared_store.clone(), chan);
-        spawner,
-        app_hardware.network_stack,
-        shared_store.clone(),
-        chan,
-        mapping_loader,
-    );
 
     /****************************** Spawning tasks ***********************************/
     debug!("spawing NFC reader task...");
     spawner.must_spawn(drivers::nfc_reader::rfid_reader_task(
-        app_hardware.uart,
+        uart_device,
         publisher,
     ));
 
     debug!("spawing feedback task..");
-    spawner.must_spawn(feedback::feedback_task(
+    spawner.must_spawn(feedback::feedback_task(rmt, led_gpio, buzzer_gpio));
-        app_hardware.led,
-        app_hardware.buzzer,
-    ));
 
     debug!("spawn sd detect task");
-    spawner.must_spawn(sd_detect_task(app_hardware.sd_present));
+    spawner.must_spawn(sd_detect_task(sd_det_gpio));
     /******************************************************************************/
 
     debug!("everything spawned");
@@ -116,7 +101,7 @@ async fn main(spawner: Spawner) -> ! {
 }
 
 #[embassy_executor::task]
-async fn sd_detect_task(sd_det_gpio: AnyPin<'static>) {
+async fn sd_detect_task(sd_det_gpio: peripherals::GPIO0<'static>) {
     let mut sd_det = Input::new(sd_det_gpio, InputConfig::default());
     sd_det.wait_for(esp_hal::gpio::Event::AnyEdge).await;
 

src/store/id_mapping.rs

@@ -0,0 +1,33 @@
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use serde::{Deserialize, Serialize};
+
+use crate::store::tally_id::TallyID;
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct Name {
+    pub first: String,
+    pub last: String,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct IDMapping {
+    #[serde(flatten)]
+    id_map: BTreeMap<TallyID, Name>,
+}
+
+impl IDMapping {
+    pub fn new() -> Self {
+        IDMapping {
+            id_map: BTreeMap::new(),
+        }
+    }
+
+    pub fn map(&self, id: &TallyID) -> Option<&Name> {
+        self.id_map.get(id)
+    }
+
+    pub fn add_mapping(&mut self, id: TallyID, name: Name) {
+        self.id_map.insert(id, name);
+    }
+}

src/store/id_store.rs

@@ -1,10 +1,8 @@
-use alloc::rc::Rc;
 use alloc::vec::Vec;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_sync::mutex::Mutex;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::IDMapping;
 use crate::store::day::Day;
 use crate::store::persistence::Persistence;
 use crate::store::tally_id::TallyID;
@@ -36,36 +34,42 @@ impl AttendanceDay {
 
 #[derive(Clone)]
 pub struct IDStore<T: Persistence> {
-    current_day: AttendanceDay,
+    pub current_day: AttendanceDay,
-    persistence_layer: Rc<Mutex<CriticalSectionRawMutex, T>>,
+    pub mapping: IDMapping,
+    persistence_layer: T,
 }
 
 impl<T: Persistence> IDStore<T> {
-    pub async fn new_from_storage(
+    pub async fn new_from_storage(mut persistence_layer: T) -> Self {
-        persistence_layer: Rc<Mutex<CriticalSectionRawMutex, T>>,
+        let mapping = match persistence_layer.load_mapping().await {
-        current_date: Day,
+            Some(map) => map,
-    ) -> Self {
+            None => IDMapping::new(),
+        };
+
+        let current_date: Day = Day::new(1);
+
         let day = persistence_layer
-            .lock()
-            .await
             .load_day(current_date)
             .await
             .unwrap_or(AttendanceDay::new(current_date));
 
         Self {
             current_day: day,
+            mapping,
             persistence_layer,
         }
     }
 
-    async fn persist_day(&mut self) -> Result<(), T::Error> {
+    async fn persist_day(&mut self) {
         self.persistence_layer
-            .lock()
-            .await
             .save_day(self.current_day.date, &self.current_day)
             .await
     }
 
+    pub async fn persist_mapping(&mut self) {
+        self.persistence_layer.save_mapping(&self.mapping).await
+    }
+
     /// Add a new id for the current day
     /// Returns false if ID is already present at the current day.
     pub async fn add_id(&mut self, id: TallyID, current_date: Day) -> bool {
@@ -88,25 +92,21 @@ impl<T: Persistence> IDStore<T> {
     }
 
     /// Load and return a AttendanceDay. Nothing more. Nothing less.
-    pub async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, T::Error> {
+    pub async fn load_day(&mut self, day: Day) -> Option<AttendanceDay> {
         if day == self.current_day.date {
-            return Ok(self.current_day.clone());
+            return Some(self.current_day.clone());
         }
 
-        self.persistence_layer.lock().await.load_day(day).await
+        self.persistence_layer.load_day(day).await
     }
 
-    pub async fn list_days_in_timespan(
+    pub async fn list_days_in_timespan(&mut self, from: Day, to: Day) -> Vec<Day> {
-        &mut self,
+        let all_days = self.persistence_layer.list_days().await;
-        from: Day,
-        to: Day,
-    ) -> Result<Vec<Day>, T::Error> {
-        let all_days = self.persistence_layer.lock().await.list_days().await?;
 
-        Ok(all_days
+        all_days
             .into_iter()
             .filter(|e| *e >= from)
             .filter(|e| *e <= to)
-            .collect())
+            .collect()
     }
 }

src/store/mapping_loader.rs

@@ -1,31 +0,0 @@
-use alloc::{rc::Rc, string::String, vec::Vec};
-use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
-use serde::{Deserialize, Serialize};
-
-use crate::store::{persistence::Persistence, tally_id::TallyID};
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct Name {
-    pub first: String,
-    pub last: String,
-}
-
-pub struct MappingLoader<T: Persistence>(Rc<Mutex<CriticalSectionRawMutex, T>>);
-
-impl<T: Persistence> MappingLoader<T> {
-    pub fn new(persistence_layer: Rc<Mutex<CriticalSectionRawMutex, T>>) -> Self {
-        Self(persistence_layer)
-    }
-
-    pub async fn get_mapping(&self, id: TallyID) -> Result<Name, T::Error> {
-        self.0.lock().await.load_mapping_for_id(id).await
-    }
-
-    pub async fn set_mapping(&self, id: TallyID, name: Name) -> Result<(), T::Error> {
-        self.0.lock().await.save_mapping_for_id(id, name).await
-    }
-
-    pub async fn list_mappings(&self) -> Result<Vec<TallyID>,T::Error> {
-        self.0.lock().await.list_mappings().await
-    }
-}

src/store/mod.rs

@@ -1,7 +1,9 @@
+pub use id_mapping::{IDMapping, Name};
 pub use id_store::{IDStore,AttendanceDay};
 
+mod id_mapping;
 pub mod persistence;
 mod id_store;
 pub mod tally_id;
 pub mod day;
-pub mod mapping_loader;
+

src/store/persistence.rs

@@ -1,15 +1,12 @@
 use alloc::vec::Vec;
 
-use crate::store::{day::Day, id_store::AttendanceDay, mapping_loader::Name, tally_id::TallyID};
+use crate::store::{IDMapping, day::Day, id_store::AttendanceDay};
 
 pub trait Persistence {
-    type Error: core::error::Error;
+    async fn load_day(&mut self, day: Day) -> Option<AttendanceDay>;
+    async fn save_day(&mut self, day: Day, data: &AttendanceDay);
+    async fn list_days(&mut self) -> Vec<Day>;
 
-    async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, Self::Error>;
+    async fn load_mapping(&mut self) -> Option<IDMapping>;
-    async fn save_day(&mut self, day: Day, data: &AttendanceDay) -> Result<(), Self::Error>;
+    async fn save_mapping(&mut self, data: &IDMapping);
-    async fn list_days(&mut self) -> Result<Vec<Day>, Self::Error>;
-
-    async fn load_mapping_for_id(&mut self, id: TallyID) -> Result<Name, Self::Error>;
-    async fn save_mapping_for_id(&mut self, id: TallyID, name: Name) -> Result<(), Self::Error>;
-    async fn list_mappings(&mut self) -> Result<Vec<TallyID>, Self::Error>;
 }

src/store/tally_id.rs

@@ -1,4 +1,3 @@
-use alloc::string::String;
 use core::{fmt::Display, str::FromStr};
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 
@@ -103,7 +102,7 @@ impl<'de> Deserialize<'de> for TallyID {
     where
         D: Deserializer<'de>,
     {
-        let s = <String>::deserialize(deserializer)?;
+        let s = <&str>::deserialize(deserializer)?;
-        TallyID::from_str(&s).map_err(|_| de::Error::custom("Failed to parse Tally ID"))
+        TallyID::from_str(s).map_err(|_| de::Error::custom("Failed to parse Tally ID"))
     }
 }

src/webserver/api.rs

@@ -6,7 +6,7 @@ use picoserve::{
 use serde::Deserialize;
 
 use crate::{
-    store::{day::Day, mapping_loader::Name, tally_id::TallyID},
+    store::{Name, day::Day, tally_id::TallyID},
     webserver::{app::AppState, sse::IDEvents},
 };
 
@@ -28,40 +28,10 @@ pub struct QueryDay {
     day: Option<u32>,
 }
 
-#[derive(Deserialize)]
-pub struct QueryMapping {
-    id: TallyID,
-}
-
-// GET /api/mappings
-pub async fn get_mappings(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, impl IntoResponse> {
-    let loader = state.mapping_loader.lock().await;
-
-    match loader.list_mappings().await {
-        Ok(ids) => Ok(response::Json(ids)),
-        Err(_) => Err((
-            response::StatusCode::INTERNAL_SERVER_ERROR,
-            "INTERNAL_SERVER_ERROR",
-        )),
-    }
-}
-
 // GET /api/mapping
-pub async fn get_mapping(
+pub async fn get_mapping(State(state): State<AppState>) -> impl IntoResponse {
-    State(state): State<AppState>,
+    let store = state.store.lock().await;
-    Query(QueryMapping { id }): Query<QueryMapping>,
+    response::Json(store.mapping.clone())
-) -> Result<impl IntoResponse, impl IntoResponse> {
-    let loader = state.mapping_loader.lock().await;
-
-    match loader.get_mapping(id).await {
-        Ok(name) => Ok(response::Json(name)),
-        Err(_) => Err((
-            response::StatusCode::INTERNAL_SERVER_ERROR,
-            "INTERNAL_SERVER_ERROR",
-        )),
-    }
 }
 
 // POST /api/mapping
@@ -69,14 +39,9 @@ pub async fn add_mapping(
     State(state): State<AppState>,
     Json(data): Json<NewMapping>,
 ) -> impl IntoResponse {
-    let loader = state.mapping_loader.lock().await;
+    let mut store = state.store.lock().await;
-    match loader.set_mapping(data.id, data.name).await {
+    store.mapping.add_mapping(data.id, data.name);
-        Ok(_) => (response::StatusCode::CREATED, ""),
+    store.persist_mapping().await;
-        Err(_) => (
-            response::StatusCode::INTERNAL_SERVER_ERROR,
-            "INTERNAL_SERVER_ERROR",
-        ),
-    }
 }
 
 // SSE /api/idevent
@@ -105,13 +70,9 @@ pub async fn get_days(
 
     let mut store = state.store.lock().await;
 
-    match store.list_days_in_timespan(from_day, to_day).await {
+    let days = store.list_days_in_timespan(from_day, to_day).await;
-        Ok(days) => Ok(response::Json(days)),
+
-        Err(_) => Err((
+    response::Json(days)
-            response::StatusCode::INTERNAL_SERVER_ERROR,
-            "Internal server error",
-        )),
-    }
 }
 
 // GET /api/day
@@ -127,10 +88,7 @@ pub async fn get_day(
     let mut store = state.store.lock().await;
 
     match store.load_day(parsed_day).await {
-        Ok(att_day) => Ok(response::Json(att_day)),
+        Some(att_day) => Ok(response::Json(att_day)),
-        Err(_) => Err((
+        None => Err((response::StatusCode::NOT_FOUND, "Not found")),
-            response::StatusCode::INTERNAL_SERVER_ERROR,
-            "Internal server error",
-        )),
     }
 }

src/webserver/app.rs

@@ -4,10 +4,8 @@ use picoserve::{AppWithStateBuilder, routing::get};
 
 use crate::{
     TallyChannel, UsedStore,
-    init::sd_card::SDCardPersistence,
-    store::mapping_loader::MappingLoader,
     webserver::{
-        api::{add_mapping, get_day, get_days, get_idevent, get_mapping, get_mappings},
+        api::{add_mapping, get_day, get_days, get_idevent, get_mapping},
         assets::Assets,
     },
 };
@@ -16,7 +14,6 @@ use crate::{
 pub struct AppState {
     pub store: Rc<Mutex<CriticalSectionRawMutex, UsedStore>>,
     pub chan: &'static TallyChannel,
-    pub mapping_loader: Rc<Mutex<CriticalSectionRawMutex, MappingLoader<SDCardPersistence>>>,
 }
 
 pub struct AppProps;
@@ -28,7 +25,6 @@ impl AppWithStateBuilder for AppProps {
     fn build_app(self) -> picoserve::Router<Self::PathRouter, AppState> {
         picoserve::Router::from_service(Assets)
             .route("/api/mapping", get(get_mapping).post(add_mapping))
-            .route("/api/mappings", get(get_mappings))
             .route("/api/idevent", get(get_idevent))
             .route("/api/days", get(get_days))
             .route("/api/day", get(get_day))

src/webserver/mod.rs

@@ -8,8 +8,6 @@ use static_cell::make_static;
 
 use crate::{
     TallyChannel, UsedStore,
-    init::sd_card::SDCardPersistence,
-    store::mapping_loader::{self, MappingLoader},
     webserver::app::{AppProps, AppState},
 };
 
@@ -25,16 +23,10 @@ pub fn start_webserver(
     stack: Stack<'static>,
     store: Rc<Mutex<CriticalSectionRawMutex, UsedStore>>,
     chan: &'static TallyChannel,
-    mapping_loader: MappingLoader<SDCardPersistence>,
 ) {
     let app = make_static!(AppProps.build_app());
 
-    let shared_mapping_loader = Rc::new(Mutex::new(mapping_loader));
+    let state = make_static!(AppState { store, chan });
-    let state = make_static!(AppState {
-        store,
-        chan,
-        mapping_loader: shared_mapping_loader
-    });
 
     let config = make_static!(picoserve::Config::new(picoserve::Timeouts {
         start_read_request: Some(Duration::from_secs(5)),

web/package-lock.json

@@ -19,7 +19,7 @@
         "svelte": "^5.28.1",
         "svelte-check": "^4.1.6",
         "typescript": "~5.8.3",
-        "vite": "^6.4.1"
+        "vite": "^6.3.5"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -771,7 +771,6 @@
       "integrity": "sha512-MCFS6CrQDu1yGwspm4qtli0e63vaPCehf6V7pIMP15AsWgMKrqDGCPFF/0kn4SP0ii4aySu4Pa62+fIRGFMjgw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@sveltejs/vite-plugin-svelte-inspector": "^4.0.1",
         "debug": "^4.4.0",
@@ -1101,7 +1100,6 @@
       "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2213,7 +2211,6 @@
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
       "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -2580,7 +2577,6 @@
       "integrity": "sha512-QIYtKnJGkubWXtNkrUBKVCvyo9gjcccdbnvXfwsGNhvbeNNdQjRDTa/BiQcJ2kWXbXPQbWKyT7CUu53KIj1rfw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.3.0",
         "@jridgewell/sourcemap-codec": "^1.5.0",
@@ -2704,7 +2700,6 @@
       "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -2734,11 +2729,10 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.4.1",
+      "version": "6.3.5",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz",
-      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "integrity": "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",

web/package.json

@@ -15,7 +15,7 @@
     "svelte": "^5.28.1",
     "svelte-check": "^4.1.6",
     "typescript": "~5.8.3",
-    "vite": "^6.4.1",
+    "vite": "^6.3.5",
     "body-parser": "^2.2.0",
     "express": "^5.1.0"
   },

web/src/App.svelte

@@ -5,12 +5,7 @@
   import AddIDModal from "./lib/AddIDModal.svelte";
   import ExportModal from "./lib/ExportModal.svelte";
   import { generateCSVFile } from "./lib/exporting";
-  import {
+  import { fetchMapping, type IDMap } from "./lib/IDMapping";
-    cacheMappingInLocalstore,
-    fetchMapping,
-    loadCachedMappingFromLocalstore,
-    type IDMap,
-  } from "./lib/IDMapping";
   import { downloadBlob } from "./lib/downloadBlob";
 
   let lastID: string = $state("");
@@ -20,16 +15,12 @@
   let exportModal: ExportModal;
 
   onMount(async () => {
-    mapping = loadCachedMappingFromLocalstore();
+    mapping = await fetchMapping();
-
-    let fetchedMapping = await fetchMapping();
-    mapping = fetchedMapping;
-    cacheMappingInLocalstore(fetchedMapping);
 
     let sse = new EventSource("/api/idevent");
-    sse.addEventListener("msg", function (e) {
+    sse.onmessage = (e) => {
       lastID = e.data;
-    });
+    };
   });
 </script>
 
@@ -65,23 +56,13 @@
           addModal.open(id, firstName, lastName);
         }}
       />
-      <span>Gesammmte einträge: {Object.keys(mapping).length}</span>
-    {:else}
-      Lade ...
     {/if}
   </div>
 
   <AddIDModal
     bind:this={addModal}
-    onSubmitted={async (id, firstName, lastname) => {
+    onSubmitted={async () => {
-      if (mapping == null) {
+      mapping = await fetchMapping();
-        return;
-      }
-
-      mapping[id] = {
-        first: firstName,
-        last: lastname,
-      };
     }}
   />
 

web/src/lib/AddIDModal.svelte

@@ -1,11 +1,7 @@
 <script lang="ts">
   import Modal from "./Modal.svelte";
 
-  let {
+  let { onSubmitted }: { onSubmitted?: () => void } = $props();
-    onSubmitted,
-  }: {
-    onSubmitted?: (id: string, firstName: string, lastName: string) => void;
-  } = $props();
 
   let displayID = $state("");
   let firstName = $state("");
@@ -13,11 +9,7 @@
 
   let modal: Modal;
 
-  export function open(
+  export function open(presetID: string, presetFirstName?: string, presetLastName?: string) {
-    presetID: string,
-    presetFirstName?: string,
-    presetLastName?: string,
-  ) {
     displayID = presetID;
 
     firstName = presetFirstName ?? "";
@@ -41,14 +33,13 @@
         "Content-Type": "application/json",
       },
       body: JSON.stringify(data),
-    }).then((res) => {
+    }).then(() => {
-      if (res.status == 201) {
+      onSubmitted?.();
-        onSubmitted?.(displayID, firstName, lastName);
+    });
-      }
+
     firstName = "";
     lastName = "";
     displayID = "";
-    });
   }
 </script>
 

web/src/lib/IDMapping.ts

@@ -7,55 +7,21 @@ export interface Name {
   last: string,
 }
 
-async function fetchIDList(): Promise<string[]> {
+function stupidSerdeFix(pairs: [string, Name][]): IDMap {
-  let res = await fetch("/api/mappings");
+  const map: IDMap = {};
-  let data = await res.json();
+  for (const [key, value] of pairs) {
-  return data;
+    map[key] = value;
-}
-
-async function fetchID(id: string): Promise<Name> {
-  let res = await fetch("/api/mapping?id=" + id);
-  let data = await res.json();
-  return data;
-}
-
-export async function fetchMapping(): Promise<IDMap> {
-  let ids = await fetchIDList();
-
-  let map: IDMap = {};
-
-  for (const id of ids) {
-    let id_name = await fetchID(id);
-    map[id] = id_name;
   }
 
   return map;
 }
 
-const CACHE_KEY = "idmap";
+export async function fetchMapping(): Promise<IDMap> {
+  let res = await fetch("/api/mapping");
 
-export function cacheMappingInLocalstore(mapping: IDMap) {
+  let data = await res.json();
-  if (!localStorage) {
-    console.error("localStorage is not available");
-    return;
-  }
 
-  localStorage.setItem(CACHE_KEY, JSON.stringify(mapping));
+  return stupidSerdeFix(data);
-}
-
-export function loadCachedMappingFromLocalstore(): IDMap | null {
-  if (!localStorage) {
-    console.error("localStorage is not available");
-    return null;
-  }
-
-  const data = localStorage.getItem(CACHE_KEY);
-  if (!data) {
-    return null;
-  }
-
-  const mapping = JSON.parse(data);
-  return mapping;
 }
 
 export async function addMapping(id: string, firstName: string, lastName: string) {