trying to fix, not success yet

datasheet.txt

@@ -0,0 +1,2 @@
+https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf
+https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf

flake.nix

@@ -21,8 +21,11 @@
         gcc
         gnumake
         rustup
+        rust-analyzer
         cargo-espflash
         espup
+	mosquitto
+	mermaid-cli
       ];
 
 shellHook = ''
@@ -33,16 +36,33 @@ shellHook = ''
     espup install
   fi
 
-  # Activate Xtensa Rust toolchain
-  export RUSTUP_TOOLCHAIN=esp
+  # Ensure the real rust-analyzer from Nix is used (not rustup's shim)
+  export PATH=${pkgs.rust-analyzer}/bin:$PATH
+
+  # Keep ESP toolchain binaries on PATH for building/flashing
+  # (do NOT set RUSTUP_TOOLCHAIN=esp globally; that breaks rust-analyzer)
   export PATH=$HOME/.rustup/toolchains/esp/bin:$PATH
  
   # Add GCC/binutils path for xtensa-esp32-elf-gcc
   export PATH=$HOME/.rustup/toolchains/esp/xtensa-esp-elf/esp-14.2.0_20240906/xtensa-esp-elf/bin:$PATH
  
+  # Helpers that force the ESP toolchain explicitly when needed
+  alias cargo-esp="RUSTUP_TOOLCHAIN=esp cargo"
+  alias rustc-esp="RUSTUP_TOOLCHAIN=esp rustc"
+
   echo "Xtensa Rust toolchain ready."
   rustc --version
   which xtensa-esp32-elf-gcc || echo "⚠️ xtensa-esp32-elf-gcc not found in PATH"
+
+  echo "cargo espflash save-image --release --chip esp32 test.bin"
+  echo ""
+  echo "MQTT broker test (run manually in two terminals):"
+  echo "  Terminal 1:"
+  echo "    mosquitto_sub -h mqtt.farmeris.sk -p 1883 -t esp32/topic -i subEsp -v"
+  echo ""
+  echo "  Terminal 2:"
+  echo "    mosquitto_pub -h mqtt.farmeris.sk -p 1883 -t esp32/topic -m \"AAAAA\" -i pubEsp"
+  echo ""
 '';
     };
   };

mqtt/.cargo/config.toml

@@ -0,0 +1,17 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-C", "link-arg=-Tdefmt.x",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

mqtt/.env_temp

@@ -0,0 +1,4 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"
+BROKER_IP= "5.196.78.28"
+BROKER_PORT= "1883"

mqtt/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

mqtt/Cargo.toml

@@ -0,0 +1,90 @@
+[package]
+edition      = "2021"
+name         = "projekt_final"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "projekt_final"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+  "esp32",
+  "log-04",
+  "unstable",
+] }
+log = "0.4.27"
+
+embassy-net = { version = "0.7.0", features = [
+  "dhcpv4",
+  "proto-ipv6",
+  "log",
+  "medium-ethernet",
+  "tcp",
+  "udp",
+] }
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.5.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+esp-wifi = { version = "0.15.0", features = [
+  "builtin-scheduler",
+  "esp-alloc",
+  "esp32",
+  "log-04",
+  "smoltcp",
+  "wifi",
+] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "proto-ipv6",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+rust-mqtt = { version = "0.3.0", default-features = false, features = ["no_std"] }
+defmt-rtt = "1.0.0"
+embassy-futures = "0.1.2"
+embassy-sync = "0.7.2"
+heapless = "0.9.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

mqtt/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+info:
+	espflash board-info

mqtt/build.rs

@@ -0,0 +1,73 @@
+fn main() {
+    // Explicitly load .env from the project root, even when called from other dirs
+    let project_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let dotenv_path = std::path::Path::new(&project_root).join(".env");
+    if dotenvy::from_path(dotenv_path.clone()).is_ok() {
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    // Pass WIFI credentials into firmware
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+    if let Ok(ip) = std::env::var("BROKER_IP") {
+        println!("cargo:rustc-env=BROKER_IP={}", ip);
+    }
+    if let Ok(port) = std::env::var("BROKER_PORT") {
+        println!("cargo:rustc-env=BROKER_PORT={}", port);
+    }
+
+    linker_be_nice();
+
+    println!("cargo:rustc-link-arg=-Tlinkall.x");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

mqtt/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

mqtt/src/bin/main.rs

@@ -0,0 +1,181 @@
+// src/bin/main.rs
+
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types"
+)]
+
+use embassy_executor::Spawner;
+use embassy_futures::select::{select, Either};
+use embassy_net::{Runner, StackResources};
+use embassy_time::{Duration, Timer};
+use esp_alloc as _;
+use esp_backtrace as _;
+use esp_hal::{clock::CpuClock, rng::Rng, timer::timg::TimerGroup};
+use esp_wifi::{
+    init,
+    wifi::{ClientConfiguration, Configuration, WifiController, WifiDevice, WifiEvent, WifiState},
+    EspWifiController,
+};
+use log::info;
+use rust_mqtt::packet::v5::publish_packet::QualityOfService;
+use projekt_final::mqtt::client::{
+    mqtt_events, mqtt_publish, mqtt_subscribe, mqtt_task, IncomingMsg,
+};
+use defmt_rtt as _;
+
+extern crate alloc;
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
+const SSID: &str = env!("SSID");
+const PASSWORD: &str = env!("PASSWORD");
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) -> ! {
+    esp_println::logger::init_logger_from_env();
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+
+    esp_alloc::heap_allocator!(size: 72 * 1024);
+
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    let mut rng = Rng::new(peripherals.RNG);
+
+    let esp_wifi_ctrl = &*mk_static!(
+        EspWifiController<'static>,
+        init(timg0.timer0, rng.clone()).unwrap()
+    );
+
+    let (controller, interfaces) =
+        esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).unwrap();
+
+    let wifi_interface = interfaces.sta;
+
+    let timg1 = TimerGroup::new(peripherals.TIMG1);
+    esp_hal_embassy::init(timg1.timer0);
+
+    let config = embassy_net::Config::dhcpv4(Default::default());
+
+    let seed = (rng.random() as u64) << 32 | rng.random() as u64;
+
+    // Init network stack
+    let (stack, runner) = embassy_net::new(
+        wifi_interface,
+        config,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
+        seed,
+    );
+
+    spawner.spawn(connection(controller)).ok();
+    spawner.spawn(net_task(runner)).ok();
+
+    // Wait for link up
+    loop {
+        if stack.is_link_up() {
+            break;
+        }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+
+    info!("Waiting to get IP address...");
+    loop {
+        if let Some(config) = stack.config_v4() {
+            info!("Got IP: {}", config.address);
+            break;
+        }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+
+    spawner.spawn(mqtt_task(stack)).expect("failed to spawn MQTT task");
+    info!("MQTT task started");
+
+    mqtt_publish("esp32/topic", b"hello from ESP32 (init)", QualityOfService::QoS1, false).await;
+    info!("Sent initial MQTT message");
+
+    mqtt_subscribe("esp32/topic").await;
+
+    // Get a receiver for incoming MQTT messages
+    let mqtt_rx = mqtt_events();
+
+    loop {
+        // Drive both: either process an MQTT message or publish periodically
+        match select(mqtt_rx.receive(), Timer::after(Duration::from_secs(5))).await
+        {
+            // Received inbound MQTT message (from broker)
+            Either::First(msg) => {
+                handle_incoming(msg);
+            }
+            // Time-based example publish
+            Either::Second(_) => {
+                // mqtt_publish(
+                //     "esp32/topic",
+                //     b"hello from main",
+                //     QualityOfService::QoS1,
+                //     false,
+                // )
+                // .await;
+            }
+        }
+    }
+}
+
+fn handle_incoming(msg: IncomingMsg) {
+    if let Ok(txt) = core::str::from_utf8(&msg.payload) {
+        info!("MAIN RX [{}]: {}", msg.topic.as_str(), txt);
+        info!("Received MQTT message -> topic: '{}', payload: '{}'", msg.topic.as_str(), txt);
+    } else {
+        info!("MAIN RX [{}]: {:?}", msg.topic.as_str(), msg.payload);
+    }
+}
+
+#[embassy_executor::task]
+async fn connection(mut controller: WifiController<'static>) {
+    info!("start connection task");
+    info!("Device capabilities: {:?}", controller.capabilities());
+    loop {
+        match esp_wifi::wifi::wifi_state() {
+            WifiState::StaConnected => {
+                controller.wait_for_event(WifiEvent::StaDisconnected).await;
+                Timer::after(Duration::from_millis(5000)).await
+            }
+            _ => {}
+        }
+        if !matches!(controller.is_started(), Ok(true)) {
+            let client_config = Configuration::Client(ClientConfiguration {
+                ssid: SSID.into(),
+                password: PASSWORD.into(),
+                ..Default::default()
+            });
+            controller.set_configuration(&client_config).unwrap();
+            info!("Starting wifi");
+            controller.start_async().await.unwrap();
+            info!("Wifi started!");
+        }
+        info!("About to connect...");
+
+        match controller.connect_async().await {
+            Ok(_) => info!("Wifi connected!"),
+            Err(e) => {
+                info!("Failed to connect to wifi: {e:?}");
+                Timer::after(Duration::from_millis(5000)).await
+            }
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
+    runner.run().await
+}

mqtt/src/lib.rs

@@ -0,0 +1,3 @@
+#![no_std]
+
+pub mod mqtt;

mqtt/src/mqtt/client.rs

@@ -0,0 +1,233 @@
+// src/mqtt/client.rs
+use embassy_futures::select::{select, Either};
+use embassy_net::{tcp::TcpSocket, Stack};
+use embassy_time::{Duration, Timer};
+use log::info;
+use rust_mqtt::client::client::MqttClient;
+use rust_mqtt::client::client_config::{ClientConfig, MqttVersion};
+use rust_mqtt::packet::v5::publish_packet::QualityOfService;
+use rust_mqtt::packet::v5::reason_codes::ReasonCode;
+use rust_mqtt::utils::rng_generator::CountingRng;
+use static_cell::ConstStaticCell;
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::{Channel, Receiver};
+
+use heapless::{String as HString, Vec as HVec};
+
+use crate::mqtt::config::mqtt_broker_endpoint;
+
+const RECONNECT_DELAY_SECS: u64 = 5;
+const KEEPALIVE_SECS: u64 = 60;
+const PING_PERIOD: Duration = Duration::from_secs(KEEPALIVE_SECS / 2);
+
+// Limits for small, static buffers (no heap)
+pub const TOPIC_MAX: usize = 128;
+pub const PAYLOAD_MAX: usize = 512;
+const COMMAND_QUEUE: usize = 8;
+const EVENT_QUEUE: usize = 8;
+
+// TCP socket buffers (for embassy-net TcpSocket)
+static TCP_RX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
+static TCP_TX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
+
+// MQTT client buffers (separate from the TcpSocket's buffers)
+static MQTT_TX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
+static MQTT_RX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
+
+// Tie TcpSocket lifetime to session
+type Client<'a, 'net> = MqttClient<'a, TcpSocket<'net>, 8, CountingRng>;
+
+// ===================== Improved Section Starts Here ===================== //
+
+#[derive(Clone)]
+pub struct IncomingMsg {
+    pub topic: HString<TOPIC_MAX>,
+    pub payload: HVec<u8, PAYLOAD_MAX>,
+}
+
+#[derive(Clone)]
+struct PublishMsg {
+    topic: HString<TOPIC_MAX>,
+    payload: HVec<u8, PAYLOAD_MAX>,
+    qos: QualityOfService,
+    retain: bool,
+}
+
+#[derive(Clone)]
+enum Command {
+    Publish(PublishMsg),
+    Subscribe(HString<TOPIC_MAX>),
+}
+
+static CMD_CHAN: Channel<CriticalSectionRawMutex, Command, COMMAND_QUEUE> = Channel::new();
+static EVT_CHAN: Channel<CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> = Channel::new();
+
+// --- Public API ---
+
+pub async fn mqtt_publish(topic: &str, payload: &[u8], qos: QualityOfService, retain: bool) {
+    CMD_CHAN
+        .send(Command::Publish(PublishMsg {
+            topic: truncate_str::<TOPIC_MAX>(topic),
+            payload: truncate_payload(payload),
+            qos,
+            retain,
+        }))
+        .await;
+}
+
+pub async fn mqtt_subscribe(topic: &str) {
+    CMD_CHAN.send(Command::Subscribe(truncate_str::<TOPIC_MAX>(topic))).await;
+}
+
+pub fn mqtt_events(
+) -> Receiver<'static, CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> {
+    EVT_CHAN.receiver()
+}
+
+// --- Helper functions for memory-safe truncation ---
+fn truncate_str<const N: usize>(s: &str) -> HString<N> {
+    let mut h = HString::new();
+    let _ = h.push_str(&s[..s.len().min(N)]);
+    h
+}
+
+fn truncate_payload(data: &[u8]) -> HVec<u8, PAYLOAD_MAX> {
+    let mut v = HVec::new();
+    let _ = v.extend_from_slice(&data[..data.len().min(PAYLOAD_MAX)]);
+    v
+}
+
+// --- MQTT configuration and client setup ---
+fn build_client_config() -> ClientConfig<'static, 8, CountingRng> {
+    let mut cfg = ClientConfig::new(MqttVersion::MQTTv5, CountingRng(0));
+    cfg.keep_alive = KEEPALIVE_SECS as u16;
+    cfg.add_client_id("esp32-client");
+    cfg
+}
+
+fn build_client<'a, 'net>(
+    socket: TcpSocket<'net>,
+    mqtt_tx: &'a mut [u8],
+    mqtt_rx: &'a mut [u8],
+) -> Client<'a, 'net> {
+    let mqtt_tx_len = mqtt_tx.len();
+    let mqtt_rx_len = mqtt_rx.len();
+    MqttClient::new(socket, mqtt_tx, mqtt_tx_len, mqtt_rx, mqtt_rx_len, build_client_config())
+}
+
+// --- Connection lifecycle and main session loop ---
+
+async fn connect_tcp<'net>(socket: &mut TcpSocket<'net>) -> Result<(), ()> {
+    match socket.connect(mqtt_broker_endpoint()).await {
+        Ok(_) => {
+            info!("Connected TCP to MQTT broker");
+            Ok(())
+        }
+        Err(e) => {
+            info!("TCP connect failed: {:?}", e);
+            Err(())
+        }
+    }
+}
+
+async fn connect_mqtt(client: &mut Client<'_, '_>) -> Result<(), ReasonCode> {
+    client.connect_to_broker().await
+}
+
+async fn run_loop(client: &mut Client<'_, '_>) -> Result<(), ReasonCode> {
+    let default_topic = "esp32/topic";
+    match client.subscribe_to_topic(default_topic).await {
+        Ok(_) => info!("Subscribed to '{}'", default_topic),
+        Err(e) => info!("Default subscribe failed: {:?}", e),
+    };
+
+    loop {
+        let net_or_ping = select(client.receive_message(), Timer::after(PING_PERIOD));
+
+        match select(CMD_CHAN.receive(), net_or_ping).await {
+            Either::First(cmd) => handle_command(client, cmd).await?,
+            Either::Second(Either::First(result)) => handle_incoming(result).await?,
+            Either::Second(Either::Second(_)) => client.send_ping().await?,
+        }
+    }
+}
+
+async fn handle_command(client: &mut Client<'_, '_>, cmd: Command) -> Result<(), ReasonCode> {
+    match cmd {
+        Command::Publish(msg) => {
+            client
+                .send_message(msg.topic.as_str(), &msg.payload, msg.qos, msg.retain)
+                .await
+        }
+        Command::Subscribe(topic) => {
+            client.subscribe_to_topic(topic.as_str()).await?;
+            info!("Subscribed to '{}'", topic);
+            Ok(())
+        }
+    }
+}
+
+async fn handle_incoming(result: Result<(&str, &[u8]), ReasonCode>) -> Result<(), ReasonCode> {
+    let (topic, payload) = result?;
+    EVT_CHAN
+        .send(IncomingMsg {
+            topic: truncate_str::<TOPIC_MAX>(topic),
+            payload: truncate_payload(payload),
+        })
+        .await;
+    Ok(())
+}
+
+// --- Session and reconnect control ---
+async fn run_one_session(
+    stack: Stack<'static>,
+    tcp_rx: &mut [u8],
+    tcp_tx: &mut [u8],
+    mqtt_tx: &mut [u8],
+    mqtt_rx: &mut [u8],
+) -> Result<(), ()> {
+    let mut socket = TcpSocket::new(stack, tcp_rx, tcp_tx);
+    if connect_tcp(&mut socket).await.is_err() {
+        return Err(());
+    }
+
+    let mut client = build_client(socket, mqtt_tx, mqtt_rx);
+    match connect_mqtt(&mut client).await {
+        Ok(_) => info!("MQTT CONNACK received"),
+        Err(reason) => {
+            info!("MQTT connect failed: {:?}", reason);
+            return Err(());
+        }
+    }
+
+    run_loop(&mut client).await.map_err(|_| ())
+}
+
+// --- Main MQTT embassy task ---
+#[embassy_executor::task]
+pub async fn mqtt_task(stack: Stack<'static>) {
+    info!("MQTT task starting...");
+
+    let tcp_rx = TCP_RX_BUFFER.take();
+    let tcp_tx = TCP_TX_BUFFER.take();
+    let mqtt_tx = MQTT_TX_BUF.take();
+    let mqtt_rx = MQTT_RX_BUF.take();
+
+    loop {
+        let _ = run_one_session(
+            stack,
+            &mut tcp_rx[..],
+            &mut tcp_tx[..],
+            &mut mqtt_tx[..],
+            &mut mqtt_rx[..],
+        )
+        .await;
+
+        info!(
+            "Reconnecting in {}s after session end/failure",
+            RECONNECT_DELAY_SECS
+        );
+        Timer::after(Duration::from_secs(RECONNECT_DELAY_SECS)).await;
+    }
+}

mqtt/src/mqtt/config.rs

@@ -0,0 +1,122 @@
+// src/mqtt/config.rs
+#![allow(dead_code)]
+
+use embassy_net::{IpAddress, Ipv4Address, Ipv6Address};
+
+// Compile-time values injected by build.rs
+const BROKER_IP: &str = env!("BROKER_IP");
+const BROKER_PORT: &str = env!("BROKER_PORT");
+
+pub fn mqtt_broker_endpoint() -> (IpAddress, u16) {
+    (parse_ip(BROKER_IP), parse_port(BROKER_PORT))
+}
+
+fn parse_port(s: &str) -> u16 {
+    let p: u16 = s
+        .parse()
+        .unwrap_or_else(|_| panic!("BROKER_PORT must be a valid u16 (1..=65535)"));
+    assert!(p != 0, "BROKER_PORT cannot be 0");
+    p
+}
+
+fn parse_ip(s: &str) -> IpAddress {
+    if s.contains(':') {
+        IpAddress::Ipv6(parse_ipv6(s))
+    } else {
+        IpAddress::Ipv4(parse_ipv4(s))
+    }
+}
+
+fn parse_ipv4(s: &str) -> Ipv4Address {
+    let mut it = s.split('.');
+    let a = parse_octet(it.next(), 1);
+    let b = parse_octet(it.next(), 2);
+    let c = parse_octet(it.next(), 3);
+    let d = parse_octet(it.next(), 4);
+    assert!(it.next().is_none(), "Too many IPv4 octets");
+    Ipv4Address::new(a, b, c, d)
+}
+
+fn parse_octet(part: Option<&str>, idx: usize) -> u8 {
+    let p = part.unwrap_or_else(|| panic!("IPv4 missing octet {}", idx));
+    let v: u16 = p
+        .parse()
+        .unwrap_or_else(|_| panic!("Invalid IPv4 octet {}: {}", idx, p));
+    assert!(v <= 255, "IPv4 octet {} out of range: {}", idx, v);
+    v as u8
+}
+
+// Minimal IPv6 parser with '::' compression. Does not handle IPv4-embedded IPv6.
+fn parse_ipv6(s: &str) -> Ipv6Address {
+    assert!(
+        !s.contains('.'),
+        "IPv4-embedded IPv6 like ::ffff:192.0.2.1 not supported; \
+         use pure hex IPv6"
+    );
+
+    let has_double = s.contains("::");
+    let (left_s, right_s) = if has_double {
+        let mut sp = s.splitn(2, "::");
+        (sp.next().unwrap_or(""), sp.next().unwrap_or(""))
+    } else {
+        (s, "")
+    };
+
+    let mut left = [0u16; 8];
+    let mut right = [0u16; 8];
+    let mut ll = 0usize;
+    let mut rl = 0usize;
+
+    if !left_s.is_empty() {
+        for part in left_s.split(':') {
+            left[ll] = parse_group(part);
+            ll += 1;
+            assert!(ll <= 8, "Too many IPv6 groups on the left");
+        }
+    }
+
+    if !right_s.is_empty() {
+        for part in right_s.split(':') {
+            right[rl] = parse_group(part);
+            rl += 1;
+            assert!(rl <= 8, "Too many IPv6 groups on the right");
+        }
+    }
+
+    let zeros = if has_double {
+        assert!(ll + rl < 8, "Invalid IPv6 '::' usage");
+        8 - (ll + rl)
+    } else {
+        assert!(ll == 8, "IPv6 must have 8 groups without '::'");
+        0
+    };
+
+    let mut g = [0u16; 8];
+    let mut idx = 0usize;
+
+    for i in 0..ll {
+        g[idx] = left[i];
+        idx += 1;
+    }
+    for _ in 0..zeros {
+        g[idx] = 0;
+        idx += 1;
+    }
+    for i in 0..rl {
+        g[idx] = right[i];
+        idx += 1;
+    }
+    assert!(idx == 8, "IPv6 did not resolve to 8 groups");
+
+    Ipv6Address::new(g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7])
+}
+
+fn parse_group(part: &str) -> u16 {
+    assert!(
+        !part.is_empty(),
+        "Empty IPv6 group (use '::' instead for compression)"
+    );
+    assert!(part.len() <= 4, "IPv6 group too long: {}", part);
+    u16::from_str_radix(part, 16)
+        .unwrap_or_else(|_| panic!("Invalid IPv6 hex group: {}", part))
+}

mqtt/src/mqtt/mod.rs

@@ -0,0 +1,4 @@
+// src/mqtt/mod.rs
+
+pub mod client;
+pub mod config;

mqtt_display/.cargo/config.toml

@@ -0,0 +1,17 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-C", "link-arg=-Tdefmt.x",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

mqtt_display/.env_temp

@@ -0,0 +1,4 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"
+BROKER_IP= "5.196.78.28"
+BROKER_PORT= "1883"

mqtt_display/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

mqtt_display/Cargo.toml

@@ -0,0 +1,96 @@
+[package]
+edition      = "2021"
+name         = "projekt_final"
+rust-version = "1.89.0"
+version      = "0.2.0"
+
+[[bin]]
+name = "projekt_final"
+path = "./src/bin/main.rs"
+
+[dependencies]
+pages-tui = { path = "../../../pages-tui" }
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+  "esp32",
+  "log-04",
+  "unstable",
+] }
+log = "0.4.27"
+
+embassy-net = { version = "0.7.0", features = [
+  "dhcpv4",
+  "proto-ipv6",
+  "log",
+  "medium-ethernet",
+  "tcp",
+  "udp",
+] }
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04", "defmt-espflash"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.5.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+esp-wifi = { version = "0.15.0", features = [
+  "builtin-scheduler",
+  "esp-alloc",
+  "esp32",
+  "log-04",
+  "smoltcp",
+  "wifi",
+] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "proto-ipv6",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+rust-mqtt = { version = "0.3.0", default-features = false, features = ["no_std"] }
+embassy-futures = "0.1.2"
+embassy-sync = "0.7.2"
+heapless = "0.9.1"
+mousefood = { git = "https://github.com/j-g00da/mousefood", branch = "main", default-features = false }
+ssd1306 = "0.10.0"
+ratatui = { version = "0.30.0", default-features = false, features = ["macros", "all-widgets", "portable-atomic"] }
+embedded-hal-bus = "0.3.0"
+embedded-hal = "1.0.0"
+defmt = "1.0.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

mqtt_display/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+info:
+	espflash board-info

mqtt_display/build.rs

@@ -0,0 +1,73 @@
+fn main() {
+    // Explicitly load .env from the project root, even when called from other dirs
+    let project_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let dotenv_path = std::path::Path::new(&project_root).join(".env");
+    if dotenvy::from_path(dotenv_path.clone()).is_ok() {
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    // Pass WIFI credentials into firmware
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+    if let Ok(ip) = std::env::var("BROKER_IP") {
+        println!("cargo:rustc-env=BROKER_IP={}", ip);
+    }
+    if let Ok(port) = std::env::var("BROKER_PORT") {
+        println!("cargo:rustc-env=BROKER_PORT={}", port);
+    }
+
+    linker_be_nice();
+
+    println!("cargo:rustc-link-arg=-Tlinkall.x");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

mqtt_display/docs/critical_data_flow_points.mermaid

@@ -0,0 +1,37 @@
+graph TD
+    START[MPU reads @50ms = 20 Hz] --> A{IMU_CHANNEL<br/>try_send}
+    
+    A -->|Full| DROP1[❌ DROP: Channel full<br/>16 slots @ 50ms = 800ms buffer]
+    A -->|OK| B[Main Loop receive]
+    
+    B --> C[Drain loop:<br/>Get freshest reading]
+    C --> D{Time check:<br/>≥3s since last?}
+    
+    D -->|No| E[Skip MQTT]
+    D -->|Yes| F{mqtt_set_imu<br/>try_lock IMU_LATEST}
+    
+    F -->|Locked| DROP2[❌ SKIP: Mutex busy]
+    F -->|OK| G[Store payload]
+    
+    E --> H[show_imu]
+    G --> H
+    
+    H --> I{DISPLAY_CHANNEL<br/>try_send}
+    I -->|Full| DROP3[❌ DROP: Display slow<br/>8 slots @ 100ms = 800ms buffer]
+    I -->|OK| J[Display renders]
+    
+    G --> K[MQTT Task loop]
+    K --> L{IMU_LATEST<br/>try_lock}
+    
+    L -->|Empty/Locked| M[Skip this iteration]
+    L -->|Has data| N[Send to broker<br/>QoS0 no retain]
+    
+    N --> O{TCP send result}
+    O -->|Fail| RECONNECT[❌ Session dies<br/>Reconnect in 5s]
+    O -->|OK| P[✅ Data sent]
+    
+    style DROP1 fill:#ffcccc
+    style DROP2 fill:#ffcccc
+    style DROP3 fill:#ffcccc
+    style RECONNECT fill:#ffcccc
+    style P fill:#ccffcc

mqtt_display/docs/mpu_data_flow.mermaid

@@ -0,0 +1,54 @@
+sequenceDiagram
+    participant HW as MPU6050 Hardware
+    participant MPU as MPU Task<br/>(Core 0)
+    participant CH as IMU_CHANNEL<br/>[16 slots]
+    participant MAIN as Main Loop<br/>(Core 0)
+    participant LATEST as IMU_LATEST<br/>(Mutex)
+    participant MQTT as MQTT Task<br/>(Core 1)
+    participant DISP as Display API
+    
+    Note over MPU: Every 50ms
+    MPU->>HW: Read sensor (I2C)
+    HW-->>MPU: Raw data
+    MPU->>MPU: Convert to ImuReading
+    MPU->>CH: try_send(reading)
+    
+    alt Channel full
+        CH--xMPU: Drop (log warning)
+    else Channel has space
+        CH-->>MPU: OK
+    end
+    
+    Note over MAIN: Continuous loop
+    MAIN->>CH: receive() [blocking]
+    CH-->>MAIN: reading
+    
+    Note over MAIN: Drain queue
+    loop While available
+        MAIN->>CH: try_receive()
+        CH-->>MAIN: newer reading
+    end
+    
+    MAIN->>DISP: show_imu(reading)<br/>[try_send]
+    
+    Note over MAIN: Every 3 seconds
+    alt Time >= 3s since last
+        MAIN->>MAIN: Format JSON payload
+        MAIN->>LATEST: mqtt_set_imu()<br/>[try_lock]
+        
+        alt Mutex available
+            LATEST-->>MAIN: Stored
+        else Mutex locked
+            LATEST--xMAIN: Skip
+        end
+    end
+    
+    Note over MQTT: Continuous loop
+    MQTT->>LATEST: try_lock()
+    
+    alt Data available
+        LATEST-->>MQTT: payload
+        MQTT->>MQTT: send_message("esp32/imu")
+    else No data
+        LATEST--xMQTT: None
+    end

mqtt_display/docs/overall_system_architecture.mermaid

@@ -0,0 +1,42 @@
+graph TB
+    subgraph "Core 0 - Application"
+        MPU[MPU Task<br/>50ms sampling]
+        DISPLAY[Display Task<br/>100ms refresh]
+        MAIN[Main Loop]
+        BUTTONS[Button Task]
+    end
+    
+    subgraph "Core 1 - Network"
+        WIFI[WiFi Connection Task]
+        NETWORK[Network Stack Runner]
+        MQTT[MQTT Task]
+    end
+    
+    subgraph "Shared Channels"
+        IMU_CH[(IMU_CHANNEL<br/>size: 16)]
+        DISP_CH[(DISPLAY_CHANNEL<br/>size: 8)]
+        CMD_CH[(CMD_CHAN<br/>size: 8)]
+        EVT_CH[(EVT_CHAN<br/>size: 8)]
+        IMU_LATEST[(IMU_LATEST<br/>Mutex)]
+    end
+    
+    subgraph "Hardware"
+        MPU_HW[MPU6050<br/>I2C 0x68]
+        OLED[SSD1306<br/>I2C]
+        BROKER[MQTT Broker]
+    end
+    
+    MPU_HW -->|I2C Read| MPU
+    MPU -->|send| IMU_CH
+    IMU_CH -->|receive| MAIN
+    MAIN -->|try_send| DISP_CH
+    MAIN -->|mqtt_set_imu| IMU_LATEST
+    DISP_CH -->|receive| DISPLAY
+    DISPLAY -->|I2C Write| OLED
+    IMU_LATEST -->|try_lock| MQTT
+    MQTT <-->|TCP/IP| BROKER
+    BUTTONS -->|push_key| DISP_CH
+    
+    style IMU_CH fill:#ff9999
+    style DISP_CH fill:#99ccff
+    style IMU_LATEST fill:#ffcc99

mqtt_display/old_main.rs

@@ -0,0 +1,181 @@
+// src/bin/main.rs
+
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types"
+)]
+
+use embassy_executor::Spawner;
+use embassy_futures::select::{select, Either};
+use embassy_net::{Runner, StackResources};
+use embassy_time::{Duration, Timer};
+use esp_alloc as _;
+use esp_backtrace as _;
+use esp_hal::{clock::CpuClock, rng::Rng, timer::timg::TimerGroup};
+use esp_wifi::{
+    init,
+    wifi::{ClientConfiguration, Configuration, WifiController, WifiDevice, WifiEvent, WifiState},
+    EspWifiController,
+};
+use log::info;
+use rust_mqtt::packet::v5::publish_packet::QualityOfService;
+use projekt_final::mqtt::client::{
+    mqtt_events, mqtt_publish, mqtt_subscribe, mqtt_task, IncomingMsg,
+};
+use defmt_rtt as _;
+
+extern crate alloc;
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
+const SSID: &str = env!("SSID");
+const PASSWORD: &str = env!("PASSWORD");
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) -> ! {
+    esp_println::logger::init_logger_from_env();
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+
+    esp_alloc::heap_allocator!(size: 72 * 1024);
+
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    let mut rng = Rng::new(peripherals.RNG);
+
+    let esp_wifi_ctrl = &*mk_static!(
+        EspWifiController<'static>,
+        init(timg0.timer0, rng.clone()).unwrap()
+    );
+
+    let (controller, interfaces) =
+        esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).unwrap();
+
+    let wifi_interface = interfaces.sta;
+
+    let timg1 = TimerGroup::new(peripherals.TIMG1);
+    esp_hal_embassy::init(timg1.timer0);
+
+    let config = embassy_net::Config::dhcpv4(Default::default());
+
+    let seed = (rng.random() as u64) << 32 | rng.random() as u64;
+
+    // Init network stack
+    let (stack, runner) = embassy_net::new(
+        wifi_interface,
+        config,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
+        seed,
+    );
+
+    spawner.spawn(connection(controller)).ok();
+    spawner.spawn(net_task(runner)).ok();
+
+    // Wait for link up
+    loop {
+        if stack.is_link_up() {
+            break;
+        }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+
+    info!("Waiting to get IP address...");
+    loop {
+        if let Some(config) = stack.config_v4() {
+            info!("Got IP: {}", config.address);
+            break;
+        }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+
+    spawner.spawn(mqtt_task(stack)).expect("failed to spawn MQTT task");
+    info!("MQTT task started");
+
+    mqtt_publish("esp32/topic", b"hello from ESP32 (init)", QualityOfService::QoS1, false).await;
+    info!("Sent initial MQTT message");
+
+    mqtt_subscribe("esp32/topic").await;
+
+    // Get a receiver for incoming MQTT messages
+    let mqtt_rx = mqtt_events();
+
+    loop {
+        // Drive both: either process an MQTT message or publish periodically
+        match select(mqtt_rx.receive(), Timer::after(Duration::from_secs(5))).await
+        {
+            // Received inbound MQTT message (from broker)
+            Either::First(msg) => {
+                handle_incoming(msg);
+            }
+            // Time-based example publish
+            Either::Second(_) => {
+                // mqtt_publish(
+                //     "esp32/topic",
+                //     b"hello from main",
+                //     QualityOfService::QoS1,
+                //     false,
+                // )
+                // .await;
+            }
+        }
+    }
+}
+
+fn handle_incoming(msg: IncomingMsg) {
+    if let Ok(txt) = core::str::from_utf8(&msg.payload) {
+        info!("MAIN RX [{}]: {}", msg.topic.as_str(), txt);
+        info!("Received MQTT message -> topic: '{}', payload: '{}'", msg.topic.as_str(), txt);
+    } else {
+        info!("MAIN RX [{}]: {:?}", msg.topic.as_str(), msg.payload);
+    }
+}
+
+#[embassy_executor::task]
+async fn connection(mut controller: WifiController<'static>) {
+    info!("start connection task");
+    info!("Device capabilities: {:?}", controller.capabilities());
+    loop {
+        match esp_wifi::wifi::wifi_state() {
+            WifiState::StaConnected => {
+                controller.wait_for_event(WifiEvent::StaDisconnected).await;
+                Timer::after(Duration::from_millis(5000)).await
+            }
+            _ => {}
+        }
+        if !matches!(controller.is_started(), Ok(true)) {
+            let client_config = Configuration::Client(ClientConfiguration {
+                ssid: SSID.into(),
+                password: PASSWORD.into(),
+                ..Default::default()
+            });
+            controller.set_configuration(&client_config).unwrap();
+            info!("Starting wifi");
+            controller.start_async().await.unwrap();
+            info!("Wifi started!");
+        }
+        info!("About to connect...");
+
+        match controller.connect_async().await {
+            Ok(_) => info!("Wifi connected!"),
+            Err(e) => {
+                info!("Failed to connect to wifi: {e:?}");
+                Timer::after(Duration::from_millis(5000)).await
+            }
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
+    runner.run().await
+}

mqtt_display/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

mqtt_display/src/bin/main.rs

@@ -0,0 +1,293 @@
+// src/bin/main.rs
+
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types"
+)]
+// TODO WARNING core 1 should be logic, core 0 wifi, its flipped now
+
+use embassy_executor::Spawner;
+use embassy_futures::select::{select, Either, select3, Either3};
+use embassy_net::{Runner, StackResources};
+use embassy_sync::signal::Signal;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_time::{Duration, Timer, Instant};
+use projekt_final::bus::I2cInner;
+use projekt_final::mqtt::client;
+
+use esp_alloc as _;
+use esp_backtrace as _;
+
+use esp_hal::{
+    gpio::InputConfig,
+    clock::CpuClock,
+    gpio::{Input, Pull},
+    i2c::master::{Config as I2cConfig, I2c},
+    rng::Rng,
+    system::{CpuControl, Stack},
+    timer::timg::TimerGroup,
+};
+use esp_wifi::{
+    wifi::{ClientConfiguration, Configuration, WifiController, WifiDevice, WifiEvent, WifiState},
+    EspWifiController,
+};
+
+use pages_tui::input::Key;
+use log::info;
+use rust_mqtt::packet::v5::publish_packet::QualityOfService;
+use static_cell::StaticCell;
+use core::cell::RefCell;
+use heapless::String;
+use core::fmt::Write;
+
+use projekt_final::{
+    bus,
+    display,
+    mpu,
+    mqtt::client::{mqtt_events, mqtt_try_publish, mqtt_publish, mqtt_subscribe, mqtt_task, IncomingMsg},
+};
+
+extern crate alloc;
+use alloc::format;
+
+static I2C_BUS: StaticCell<RefCell<I2cInner>> = StaticCell::new();
+static APP_CORE_STACK: StaticCell<Stack<8192>> = StaticCell::new();
+static EXECUTOR_CORE1: StaticCell<esp_hal_embassy::Executor> = StaticCell::new();
+static NETWORK_READY: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
+const SSID: &str = env!("SSID");
+const PASSWORD: &str = env!("PASSWORD");
+const MQTT_PUBLISH_DIVIDER: u32 = 10;
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) -> ! {
+    esp_println::logger::init_logger_from_env();
+    info!("===============================");
+    info!("  ESP32 IoT Firmware Starting");
+    info!("===============================");
+
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    esp_alloc::heap_allocator!(size: 72 * 1024);
+
+    info!("Initializing I2C bus...");
+    let i2c = I2c::new(peripherals.I2C0, I2cConfig::default())
+        .expect("Failed to create I2C instance")
+        .with_sda(peripherals.GPIO21)
+        .with_scl(peripherals.GPIO22)
+        .into_async();
+
+    let i2c_bus = I2C_BUS.init(RefCell::new(i2c));
+    let display_i2c = bus::new_device(i2c_bus);
+    let mpu_i2c = bus::new_device(i2c_bus);
+
+    info!("Initializing WiFi...");
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    let mut rng = Rng::new(peripherals.RNG);
+
+    let esp_wifi_ctrl = mk_static!(
+        EspWifiController<'static>,
+        esp_wifi::init(timg0.timer0, rng.clone()).unwrap()
+    );
+
+    let (controller, interfaces) =
+        esp_wifi::wifi::new(esp_wifi_ctrl, peripherals.WIFI).unwrap();
+
+    let wifi_interface = interfaces.sta;
+    let timg1 = TimerGroup::new(peripherals.TIMG1);
+    esp_hal_embassy::init([timg1.timer0, timg1.timer1]);
+
+    let seed = (rng.random() as u64) << 32 | rng.random() as u64;
+
+    // Start core 1 for WiFi and MQTT (network stack created there)
+    let mut cpu_control = CpuControl::new(peripherals.CPU_CTRL);
+    let _guard = cpu_control.start_app_core(
+        APP_CORE_STACK.init(Stack::new()),
+        move || {
+            let executor = EXECUTOR_CORE1.init(esp_hal_embassy::Executor::new());
+            executor.run(|spawner| {
+                spawner.spawn(core1_network_task(spawner, controller, wifi_interface, seed)).ok();
+            });
+        }
+    ).unwrap();
+
+    // Wait for network to be ready (signaled from core 1)
+    NETWORK_READY.wait().await;
+    info!("Network ready, starting core 0 tasks");
+
+    let config = InputConfig::default().with_pull(Pull::Down);
+    let button_select = Input::new(peripherals.GPIO32, config);
+    let button_next = Input::new(peripherals.GPIO35, config);
+    spawner.spawn(button_detection_task(button_select, button_next)).unwrap();
+
+    // Core 0: display and MPU tasks
+    spawner.spawn(display::task::display_task(display_i2c)).expect("spawn display_task");
+    spawner.spawn(mpu::task::mpu_task(mpu_i2c)).expect("spawn mpu_task");
+
+    display::api::set_status("Booting...").await;
+    mqtt_subscribe("esp32/read").await;
+    mqtt_publish("esp32/imu", b"online", QualityOfService::QoS1, false).await;
+
+    display::api::set_status("Running").await;
+    display::api::set_mqtt_status(true, 0).await;
+
+    let mqtt_rx = mqtt_events();
+    let imu_rx = mpu::api::events();
+    let mut imu_reading_count: u32 = 0;
+    let mut mqtt_msg_count: u32 = 0;
+    let mut mqtt_publish_drops: u32 = 0;
+    let mut last_mqtt_publish = Instant::now();
+    let mqtt_publish_interval = Duration::from_secs(3);
+
+    loop {
+        match select3(
+            mqtt_rx.receive(),
+            imu_rx.receive(),
+            Timer::after(Duration::from_secs(5)),
+        ).await {
+            Either3::First(msg) => {
+                mqtt_msg_count += 1;
+                handle_mqtt_message(msg).await;
+                display::api::set_mqtt_status(true, mqtt_msg_count).await;
+            }
+            Either3::Second(mut reading) => {
+                // Drain zabezpečuje, že 'reading' je najčerstvejšia možná hodnota
+                let mut drained = 0;
+                while let Ok(next) = imu_rx.try_receive() {
+                    reading = next;
+                    drained += 1;
+                }
+                
+                imu_reading_count += 1;
+                display::api::show_imu(reading);
+
+                // 3. Nahraďte pôvodnú podmienku týmto časovým zámkom
+                if last_mqtt_publish.elapsed() >= mqtt_publish_interval {
+                    let payload = client::encode_imu_json(&reading);
+                    client::mqtt_set_imu_payload(payload);
+                    last_mqtt_publish = Instant::now();
+                }
+            }
+            Either3::Third(_) => {
+                crate::mpu::api::IMU_CHANNEL.clear();
+                info!("IMU heartbeat: force-cleared queue, {} readings total, {} mqtt drops", 
+                      imu_reading_count, mqtt_publish_drops);
+            }
+        }
+    }
+}
+
+// Runs on core 1 - creates and owns the network stack
+#[embassy_executor::task]
+async fn core1_network_task(
+    spawner: Spawner,
+    controller: WifiController<'static>,
+    wifi_interface: WifiDevice<'static>,
+    seed: u64,
+) {
+    spawner.spawn(connection_task(controller)).ok();
+
+    let net_config = embassy_net::Config::dhcpv4(Default::default());
+    let (stack, runner) = embassy_net::new(
+        wifi_interface,
+        net_config,
+        mk_static!(StackResources<3>, StackResources::<3>::new()),
+        seed,
+    );
+
+    spawner.spawn(net_task(runner)).ok();
+
+    // Wait for network
+    loop {
+        if stack.is_link_up() { break; }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+    loop {
+        if let Some(config) = stack.config_v4() {
+            info!("Got IP: {}", config.address);
+            break;
+        }
+        Timer::after(Duration::from_millis(500)).await;
+    }
+
+    // Signal core 0 that network is ready
+    NETWORK_READY.signal(());
+
+    spawner.spawn(mqtt_task(stack)).ok();
+}
+
+async fn handle_mqtt_message(msg: IncomingMsg) {
+    if let Ok(txt) = core::str::from_utf8(&msg.payload) {
+        match txt {
+            "clear" => { display::api::clear().await; }
+            "status" => { mqtt_publish("esp32/status", b"running", QualityOfService::QoS1, false).await; }
+            _ => { display::api::add_chat_message(txt).await; }
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn connection_task(mut controller: WifiController<'static>) {
+    loop {
+        if esp_wifi::wifi::wifi_state() == WifiState::StaConnected {
+            controller.wait_for_event(WifiEvent::StaDisconnected).await;
+            Timer::after(Duration::from_millis(5000)).await;
+        }
+        if !matches!(controller.is_started(), Ok(true)) {
+            let client_config = Configuration::Client(ClientConfiguration {
+                ssid: SSID.into(),
+                password: PASSWORD.into(),
+                ..Default::default()
+            });
+            controller.set_configuration(&client_config).unwrap();
+            info!("Wi-Fi starting...");
+            controller.start_async().await.unwrap();
+        }
+        match controller.connect_async().await {
+            Ok(_) => info!("Wifi connected!"),
+            Err(e) => {
+                info!("Failed to connect to wifi: {e:#?}");
+                Timer::after(Duration::from_millis(5000)).await
+            }
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
+    runner.run().await
+}
+
+#[embassy_executor::task]
+async fn button_detection_task(mut select_btn: Input<'static>, mut next_btn: Input<'static>) {
+    loop {
+        match select(
+            select_btn.wait_for_rising_edge(),
+            next_btn.wait_for_rising_edge(),
+        ).await {
+            Either::First(_) => {
+                info!("Detection: GPIO 32 (Select) triggered!");
+                display::api::push_key(Key::enter()).await;
+            }
+            Either::Second(_) => {
+                info!("Detection: GPIO 35 (Next) triggered!");
+                display::api::push_key(Key::tab()).await
+            }
+        }
+        // Debounce: prevent mechanical bouncing from double-triggering
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(200)).await;
+    }
+}

mqtt_display/src/bus/mod.rs

@@ -0,0 +1,22 @@
+// src/bus/mod.rs
+//! Shared access to the hardware I2C peripheral on a
+//! single core.
+
+use core::cell::RefCell;
+use embedded_hal_bus::i2c::RefCellDevice;
+use esp_hal::i2c::master::I2c;
+use esp_hal::Async;
+
+/// I2C peripheral type
+pub type I2cInner = I2c<'static, Async>;
+
+/// RefCell to share the bus on a single core.
+pub type SharedI2c = RefCell<I2cInner>;
+
+/// Shared I2C device.
+pub type I2cDevice = RefCellDevice<'static, I2cInner>;
+
+/// New I2C device handle from the shared bus.
+pub fn new_device(bus: &'static SharedI2c) -> I2cDevice {
+    RefCellDevice::new(bus)
+}

mqtt_display/src/contracts.rs

@@ -0,0 +1,31 @@
+// src/contracts.rs
+//! Cross-feature message contracts.
+//! 
+//! Features depend on these types, not on each other.
+
+use heapless::String;
+use pages_tui::input::Key;
+
+/// IMU sensor reading from MPU6050
+#[derive(Clone, Copy, Default, Debug)]
+pub struct ImuReading {
+    pub accel_g: [f32; 3],
+    pub gyro_dps: [f32; 3],
+    pub temp_c: f32,
+    /// Timestamp in milliseconds since boot
+    pub timestamp_ms: u64,
+}
+
+/// Commands that can be sent to the display actor
+#[derive(Clone, Debug)]
+pub enum DisplayCommand {
+    SetImu(ImuReading),
+    SetStatus(String<32>),
+    ShowError(String<64>),
+    SetMqttStatus { connected: bool, msg_count: u32 },
+    /// Clear the display to default state
+    Clear,
+
+    PushKey(Key),
+    AddChatMessage(String<24>),
+}

mqtt_display/src/display/api.rs

@@ -0,0 +1,66 @@
+// src/display/api.rs
+//! display API
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::{Channel, Receiver, TrySendError};
+use heapless::String;
+
+use crate::contracts::{DisplayCommand, ImuReading};
+use pages_tui::input::Key;
+
+const QUEUE_SIZE: usize = 8;
+
+pub(crate) static DISPLAY_CHANNEL: Channel<CriticalSectionRawMutex, DisplayCommand, QUEUE_SIZE> =
+    Channel::new();
+
+pub async fn send(cmd: DisplayCommand) {
+    DISPLAY_CHANNEL.send(cmd).await;
+}
+
+pub fn try_send(cmd: DisplayCommand) -> Result<(), DisplayCommand> {
+    DISPLAY_CHANNEL.try_send(cmd).map_err(|e| match e {
+        TrySendError::Full(command) => command,
+    })
+}
+
+pub(crate) fn receiver() -> Receiver<'static, CriticalSectionRawMutex, DisplayCommand, QUEUE_SIZE> {
+    DISPLAY_CHANNEL.receiver()
+}
+
+/// Show IMU data - NON-BLOCKING to prevent backpressure deadlock
+pub fn show_imu(reading: ImuReading) {
+    // try_send instead of send().await
+    // If display is slow, we drop the reading rather than blocking the main loop
+    let _ = try_send(DisplayCommand::SetImu(reading));
+}
+
+pub async fn set_status(text: &str) {
+    let mut s = String::<32>::new();
+    let _ = s.push_str(&text[..text.len().min(32)]);
+    send(DisplayCommand::SetStatus(s)).await;
+}
+
+pub async fn show_error(text: &str) {
+    let mut s = String::<64>::new();
+    let _ = s.push_str(&text[..text.len().min(64)]);
+    send(DisplayCommand::ShowError(s)).await;
+}
+
+pub async fn set_mqtt_status(connected: bool, msg_count: u32) {
+    send(DisplayCommand::SetMqttStatus { connected, msg_count }).await;
+}
+
+pub async fn clear() {
+    send(DisplayCommand::Clear).await;
+}
+
+pub async fn push_key(key: Key) {
+    send(DisplayCommand::PushKey(key)).await;
+}
+
+/// Add a chat message (for Chat page)
+pub async fn add_chat_message(msg: &str) {
+    let mut s = String::<24>::new();
+    let _ = s.push_str(&msg[..msg.len().min(24)]);
+    send(DisplayCommand::AddChatMessage(s)).await;
+}

mqtt_display/src/display/mod.rs

@@ -0,0 +1,6 @@
+// src/display/mod.rs
+//! SSD1306 OLED display
+
+pub mod api;
+pub mod task;
+pub mod tui;

mqtt_display/src/display/task.rs

@@ -0,0 +1,101 @@
+// src/display/task.rs
+use embassy_time::{Duration, Timer};
+use log::{error, info};
+
+use alloc::boxed::Box;
+use mousefood::{EmbeddedBackend, EmbeddedBackendConfig};
+use ratatui::Terminal;
+use ssd1306::{mode::BufferedGraphicsMode, prelude::*, I2CDisplayInterface, Ssd1306};
+
+use crate::bus::I2cDevice;
+use crate::display::api::receiver;
+use crate::display::tui::{render_frame, DisplayState, Screen, ScreenEvent};
+use crate::contracts::DisplayCommand;
+use pages_tui::prelude::*;
+
+const REFRESH_INTERVAL_MS: u64 = 100;
+
+#[embassy_executor::task]
+pub async fn display_task(i2c: I2cDevice) {
+    info!("Display task starting...");
+
+    let interface = I2CDisplayInterface::new(i2c);
+    let mut display = Ssd1306::new(interface, DisplaySize128x32, DisplayRotation::Rotate0)
+        .into_buffered_graphics_mode();
+
+    if let Err(e) = display.init() {
+        error!("Display init failed: {:?}", e);
+        loop { Timer::after(Duration::from_secs(60)).await; }
+    }
+
+    let config = EmbeddedBackendConfig {
+        flush_callback: Box::new(|d: &mut Ssd1306<_, _, BufferedGraphicsMode<DisplaySize128x32>>| {
+            let _ = d.flush();
+        }),
+        ..Default::default()
+    };
+
+    let backend = EmbeddedBackend::new(&mut display, config);
+    let mut terminal = Terminal::new(backend).expect("terminal init failed");
+
+    let mut state = DisplayState::default();
+    let mut orchestrator = Orchestrator::<Screen>::new();
+    let rx = receiver();
+
+    // Register pages
+    // Enum-based registration
+    orchestrator.register(Screen::Menu);
+    orchestrator.register(Screen::Imu);
+    orchestrator.register(Screen::Chat);
+
+    orchestrator.bind(Key::tab(), ComponentAction::Next);
+    orchestrator.bind(Key::enter(), ComponentAction::Select);
+
+    let _ = orchestrator.navigate_to(Screen::Menu);
+
+    info!("Display ready");
+
+    loop {
+        while let Ok(cmd) = rx.try_receive() {
+            match cmd {
+                DisplayCommand::PushKey(key) => {
+                    if key == Key::tab() {
+                        orchestrator.focus_manager_mut().next();
+                    } else if key == Key::enter() {
+                        if let Ok(events) = orchestrator.process_frame(key) {
+                            for event in events {
+                                match event {
+                                    ScreenEvent::GoToImu => {
+                                        let _ = orchestrator.navigate_to(Screen::Imu);
+                                    }
+                                    ScreenEvent::GoToChat => {
+                                        let _ = orchestrator.navigate_to(Screen::Chat);
+                                    }
+                                    ScreenEvent::NavigatePrev => {
+                                        if let Some(cur) = orchestrator.current() {
+                                            let prev = cur.prev();
+                                            let _ = orchestrator.navigate_to(prev);
+                                        }
+                                    }
+                                    ScreenEvent::NavigateNext => {
+                                        if let Some(cur) = orchestrator.current() {
+                                            let next = cur.next();
+                                            let _ = orchestrator.navigate_to(next);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                _ => state.apply_command(cmd),
+            }
+        }
+
+        if let Some(screen) = orchestrator.current() {
+            render_frame(&mut terminal, screen, orchestrator.focus_manager().current(), &state);
+        }
+
+        Timer::after(Duration::from_millis(REFRESH_INTERVAL_MS)).await;
+    }
+}

mqtt_display/src/display/tui.rs

@@ -0,0 +1,277 @@
+// src/display/tui.rs
+use crate::contracts::{DisplayCommand, ImuReading};
+use alloc::format;
+use heapless::String;
+use pages_tui::prelude::*;
+use ratatui::{
+    layout::Rect,
+    style::Stylize,
+    widgets::Paragraph,
+    Terminal,
+};
+use log::info;
+
+/// Focus targets - different per screen
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum PageFocus {
+    MenuImu,
+    MenuChat,
+    NavPrev,
+    NavNext,
+}
+
+impl FocusId for PageFocus {}
+
+const MENU_TARGETS: &[PageFocus] = &[PageFocus::MenuImu, PageFocus::MenuChat];
+const NAV_TARGETS: &[PageFocus] = &[PageFocus::NavPrev, PageFocus::NavNext];
+
+/// Display state
+pub struct DisplayState {
+    pub(crate) status: String<32>,
+    pub(crate) last_imu: Option<ImuReading>,
+    pub(crate) last_error: Option<String<64>>,
+    pub(crate) mqtt_connected: bool,
+    pub(crate) mqtt_msg_count: u32,
+    pub(crate) chat_msg1: String<24>,
+    pub(crate) chat_msg2: String<24>,
+}
+
+impl Default for DisplayState {
+    fn default() -> Self {
+        Self {
+            status: String::new(),
+            last_imu: None,
+            last_error: None,
+            mqtt_connected: false,
+            mqtt_msg_count: 0,
+            chat_msg1: String::new(),
+            chat_msg2: String::new(),
+        }
+    }
+}
+
+impl DisplayState {
+    pub fn apply_command(&mut self, cmd: DisplayCommand) {
+        match cmd {
+            DisplayCommand::SetImu(reading) => {
+                self.last_imu = Some(reading);
+                self.last_error = None;
+            }
+            DisplayCommand::SetStatus(s) => self.status = s,
+            DisplayCommand::ShowError(e) => self.last_error = Some(e),
+            DisplayCommand::SetMqttStatus { connected, msg_count } => {
+                self.mqtt_connected = connected;
+                self.mqtt_msg_count = msg_count;
+            }
+            DisplayCommand::Clear => {
+                self.last_imu = None;
+                self.last_error = None;
+                self.status = String::new();
+            }
+            DisplayCommand::PushKey(_) => {}
+            DisplayCommand::AddChatMessage(msg) => {
+                self.add_chat_message(msg.as_str());
+            }
+        }
+    }
+
+    pub fn add_chat_message(&mut self, msg: &str) {
+        self.chat_msg2 = self.chat_msg1.clone();
+        self.chat_msg1.clear();
+        let _ = self.chat_msg1.push_str(&msg[..msg.len().min(24)]);
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Screen {
+    Menu,
+    Imu,
+    Chat,
+}
+
+#[derive(Clone, Debug)]
+pub enum ScreenEvent {
+    GoToImu,
+    GoToChat,
+    NavigatePrev,
+    NavigateNext,
+}
+
+impl Component for Screen {
+    type Action = ComponentAction;
+    type Event = ScreenEvent;
+    type Focus = PageFocus;
+
+    fn handle(
+        &mut self,
+        focus: &Self::Focus,
+        action: Self::Action,
+    ) -> Result<Option<Self::Event>, ComponentError> {
+        if let ComponentAction::Select = action {
+            info!("Select {:?} focus:{:?}", self, focus);
+            return Ok(Some(match focus {
+                PageFocus::MenuImu => ScreenEvent::GoToImu,
+                PageFocus::MenuChat => ScreenEvent::GoToChat,
+                PageFocus::NavPrev => ScreenEvent::NavigatePrev,
+                PageFocus::NavNext => ScreenEvent::NavigateNext,
+            }));
+        }
+        Ok(None)
+    }
+
+    fn targets(&self) -> &[Self::Focus] {
+        match self {
+            Screen::Menu => MENU_TARGETS,
+            Screen::Imu | Screen::Chat => NAV_TARGETS,
+        }
+    }
+
+    fn on_enter(&mut self) -> Result<(), ComponentError> {
+        info!("Enter: {:?}", self);
+        Ok(())
+    }
+
+    fn on_exit(&mut self) -> Result<(), ComponentError> {
+        Ok(())
+    }
+}
+
+// PAGE ORDER
+const PAGE_ORDER: &[Screen] = &[Screen::Menu, Screen::Imu, Screen::Chat];
+
+impl Screen {
+    pub fn next(&self) -> Screen {
+        let idx = PAGE_ORDER.iter().position(|p| p == self).unwrap_or(0);
+        PAGE_ORDER[(idx + 1) % PAGE_ORDER.len()].clone()
+    }
+
+    pub fn prev(&self) -> Screen {
+        let idx = PAGE_ORDER.iter().position(|p| p == self).unwrap_or(0);
+        if idx == 0 {
+            PAGE_ORDER[PAGE_ORDER.len() - 1].clone()
+        } else {
+            PAGE_ORDER[idx - 1].clone()
+        }
+    }
+
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            Screen::Menu => "menu",
+            Screen::Imu => "imu",
+            Screen::Chat => "chat",
+        }
+    }
+}
+
+// RENDERING
+/// Get row rect (0-3) for 128x32 display
+#[inline]
+fn row(area: Rect, n: u16) -> Rect {
+    Rect::new(area.x, area.y + n, area.width, 1)
+}
+
+pub fn render_frame<B: ratatui::backend::Backend>(
+    terminal: &mut Terminal<B>,
+    current_screen: &Screen,
+    focused: Option<&PageFocus>,
+    state: &DisplayState,
+) {
+    let _ = terminal.draw(|f| {
+        let area = f.area();
+        
+        if let Some(ref err) = state.last_error {
+            f.render_widget(Paragraph::new(format!("ERR:{}", err.as_str())).white().bold(), area);
+            return;
+        }
+
+        match current_screen {
+            Screen::Menu => render_menu(f, area, focused, state),
+            Screen::Imu => render_imu(f, area, focused, state),
+            Screen::Chat => render_chat(f, area, focused, state),
+        }
+    });
+}
+
+fn render_menu(f: &mut ratatui::Frame, area: Rect, focused: Option<&PageFocus>, state: &DisplayState) {
+    // Row 0 Title
+    let conn = if state.mqtt_connected { "*" } else { "x" };
+    f.render_widget(
+        Paragraph::new(format!("-- ESP32 Hub {} --", conn)).white().bold(),
+        row(area, 0),
+    );
+
+    // Row 1 Sensors
+    let imu_sel = focused == Some(&PageFocus::MenuImu);
+    f.render_widget(
+        Paragraph::new(if imu_sel { " > Sensors" } else { "   Sensors" })
+            .style(if imu_sel { ratatui::style::Style::default().white().bold() } else { ratatui::style::Style::default().white() }),
+        row(area, 1),
+    );
+
+    // Row 2 Messages  
+    let chat_sel = focused == Some(&PageFocus::MenuChat);
+    f.render_widget(
+        Paragraph::new(if chat_sel { " > Messages" } else { "   Messages" })
+            .style(if chat_sel { ratatui::style::Style::default().white().bold() } else { ratatui::style::Style::default().white() }),
+        row(area, 2),
+    );
+}
+
+fn render_imu(f: &mut ratatui::Frame, area: Rect, focused: Option<&PageFocus>, state: &DisplayState) {
+    if let Some(ref imu) = state.last_imu {
+        // Row 0 Gyro
+        f.render_widget(
+            Paragraph::new(format!("G:{:+5.0}{:+5.0}{:+5.0}", imu.gyro_dps[0], imu.gyro_dps[1], imu.gyro_dps[2])).cyan(),
+            row(area, 0),
+        );
+        // Row 1 Accel
+        f.render_widget(
+            Paragraph::new(format!("A:{:+.1} {:+.1} {:+.1}", imu.accel_g[0], imu.accel_g[1], imu.accel_g[2])).green(),
+            row(area, 1),
+        );
+        // Row 2 Temp
+        f.render_widget(
+            Paragraph::new(format!("T: {:.1}C", imu.temp_c)).yellow(),
+            row(area, 2),
+        );
+    } else {
+        f.render_widget(Paragraph::new("Waiting for MPU...").white(), row(area, 1));
+    }
+
+    // Row 3 Nav bar
+    // render_nav_bar(f, row(area, 3), focused);
+}
+
+fn render_chat(f: &mut ratatui::Frame, area: Rect, focused: Option<&PageFocus>, state: &DisplayState) {
+    // Row 0 Message 1
+    if state.chat_msg1.is_empty() {
+        f.render_widget(Paragraph::new("(no messages)").white(), row(area, 0));
+    } else {
+        f.render_widget(Paragraph::new(format!(">{}", state.chat_msg1.as_str())).green(), row(area, 0));
+    }
+
+    // Row 1 Message 2
+    if !state.chat_msg2.is_empty() {
+        f.render_widget(Paragraph::new(format!(">{}", state.chat_msg2.as_str())).white(), row(area, 1));
+    }
+
+    // Row 3 Nav bar
+    render_nav_bar(f, row(area, 2), focused);
+}
+
+/// Nav bar: --[<]-------[>]--
+fn render_nav_bar(f: &mut ratatui::Frame, area: Rect, focused: Option<&PageFocus>) {
+    let prev_sel = focused == Some(&PageFocus::NavPrev);
+    let next_sel = focused == Some(&PageFocus::NavNext);
+    
+    let prev = if prev_sel { "[<]" } else { " < " };
+    let next = if next_sel { "[>]" } else { " > " };
+    
+    // Build the line: --[<]-------[>]--
+    let line = format!("--{}-------{}--", prev, next);
+    
+    f.render_widget(
+        Paragraph::new(line).style(ratatui::style::Style::default().white()),
+        area,
+    );
+}

mqtt_display/src/i2c/com.rs

@@ -0,0 +1,28 @@
+// src/i2c/com.rs
+
+use embassy_time::{Duration, Timer};
+use esp_hal::{
+    i2c::master::{Config, I2c},
+    peripherals::Peripherals,
+};
+use log::info;
+
+#[embassy_executor::task]
+pub async fn i2c_check() {
+    let peripherals = unsafe { Peripherals::steal() };
+    let mut i2c = I2c::new(peripherals.I2C0, Config::default())
+        .expect("Failed to initialize I2C")
+        .with_sda(peripherals.GPIO21)
+        .with_scl(peripherals.GPIO22);
+
+    loop {
+        info!("hehe");
+        esp_println::println!("I2C bus scan start");
+        for addr in 0x03..0x78 {
+            if i2c.write(addr, &[]).is_ok() {
+                esp_println::println!("Device found at address 0x{:02X}", addr);
+            }
+        }
+        Timer::after(Duration::from_secs(5)).await;
+    }
+}

mqtt_display/src/i2c/mod.rs

@@ -0,0 +1,3 @@
+// src/i2c/mod.rs
+
+pub mod com;

mqtt_display/src/lib.rs

@@ -0,0 +1,8 @@
+#![no_std]
+extern crate alloc;
+
+pub mod mqtt;
+pub mod bus;
+pub mod contracts;
+pub mod display;
+pub mod mpu;

mqtt_display/src/mpu/api.rs

@@ -0,0 +1,17 @@
+// src/mpu/api.rs
+//! Public API for the MPU6050 feature.
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::{Channel, Receiver, Sender};
+use crate::contracts::ImuReading;
+
+const QUEUE_SIZE: usize = 16;
+
+pub static IMU_CHANNEL: Channel<CriticalSectionRawMutex, ImuReading, QUEUE_SIZE> = Channel::new();
+
+pub fn events() -> Receiver<'static, CriticalSectionRawMutex, ImuReading, QUEUE_SIZE> {
+    IMU_CHANNEL.receiver()
+}
+
+pub(crate) fn sender() -> Sender<'static, CriticalSectionRawMutex, ImuReading, QUEUE_SIZE> {
+    IMU_CHANNEL.sender()
+}

mqtt_display/src/mpu/driver.rs

@@ -0,0 +1,241 @@
+// src/mpu/driver.rs
+//! MPU6050 driver using raw register I/O.
+
+use embedded_hal::i2c::I2c;
+
+/// MPU6050 register addresses
+mod reg {
+    pub const PWR_MGMT_1: u8 = 0x6B;
+    pub const CONFIG: u8 = 0x1A;
+    pub const GYRO_CONFIG: u8 = 0x1B;
+    pub const ACCEL_CONFIG: u8 = 0x1C;
+    pub const ACCEL_XOUT_H: u8 = 0x3B; // Start of 14-byte burst read
+    pub const WHO_AM_I: u8 = 0x75;
+}
+
+/// Expected WHO_AM_I value for MPU6050
+const MPU6050_WHO_AM_I: u8 = 0x68;
+
+/// MPU6050 accelerometer full-scale range
+#[derive(Clone, Copy, Debug, Default)]
+pub enum AccelRange {
+    #[default]
+    G2 = 0,  // ±2g  -> 16384 LSB/g
+    G4 = 1,  // ±4g  -> 8192 LSB/g
+    G8 = 2,  // ±8g  -> 4096 LSB/g
+    G16 = 3, // ±16g -> 2048 LSB/g
+}
+
+impl AccelRange {
+    /// LSB per g for this range
+    pub fn sensitivity(self) -> f32 {
+        match self {
+            AccelRange::G2 => 16384.0,
+            AccelRange::G4 => 8192.0,
+            AccelRange::G8 => 4096.0,
+            AccelRange::G16 => 2048.0,
+        }
+    }
+}
+
+/// MPU6050 gyroscope full-scale range
+#[derive(Clone, Copy, Debug, Default)]
+pub enum GyroRange {
+    #[default]
+    Dps250 = 0,  // ±250°/s  -> 131 LSB/°/s
+    Dps500 = 1,  // ±500°/s  -> 65.5 LSB/°/s
+    Dps1000 = 2, // ±1000°/s -> 32.8 LSB/°/s
+    Dps2000 = 3, // ±2000°/s -> 16.4 LSB/°/s
+}
+
+impl GyroRange {
+    /// LSB per degree/second for this range
+    pub fn sensitivity(self) -> f32 {
+        match self {
+            GyroRange::Dps250 => 131.0,
+            GyroRange::Dps500 => 65.5,
+            GyroRange::Dps1000 => 32.8,
+            GyroRange::Dps2000 => 16.4,
+        }
+    }
+}
+
+/// Raw sensor data from a single read
+#[derive(Clone, Copy, Debug, Default)]
+pub struct RawReading {
+    pub accel: [i16; 3], // X, Y, Z
+    pub gyro: [i16; 3],  // X, Y, Z
+    pub temp: i16,
+}
+
+/// MPU6050 driver
+pub struct Mpu6050<I> {
+    i2c: I,
+    addr: u8,
+    accel_range: AccelRange,
+    gyro_range: GyroRange,
+}
+
+impl<I> Mpu6050<I> {
+    /// Create a new MPU6050 driver.
+    ///
+    /// Default I2C address is 0x68. Use 0x69 if AD0 pin is high.
+    pub fn new(i2c: I, addr: u8) -> Self {
+        Self {
+            i2c,
+            addr,
+            accel_range: AccelRange::default(),
+            gyro_range: GyroRange::default(),
+        }
+    }
+
+    /// Create with default address 0x68
+    pub fn new_default(i2c: I) -> Self {
+        Self::new(i2c, 0x68)
+    }
+
+    /// Release the I2C peripheral
+    pub fn release(self) -> I {
+        self.i2c
+    }
+
+    /// Get current accelerometer range
+    pub fn accel_range(&self) -> AccelRange {
+        self.accel_range
+    }
+
+    /// Get current gyroscope range
+    pub fn gyro_range(&self) -> GyroRange {
+        self.gyro_range
+    }
+}
+
+impl<I, E> Mpu6050<I>
+where
+    I: I2c<Error = E>,
+{
+    /// Initialize the sensor with default configuration.
+    ///
+    /// - Wakes up the device (exits sleep mode)
+    /// - Sets DLPF to ~44Hz bandwidth
+    /// - Sets accel range to ±2g
+    /// - Sets gyro range to ±250°/s
+    ///
+    /// Call this once after creating the driver.
+    /// Consider adding a ~50ms delay after init before first read.
+    pub fn init(&mut self) -> Result<(), E> {
+        // Wake up (clear sleep bit in PWR_MGMT_1)
+        self.write_reg(reg::PWR_MGMT_1, 0x00)?;
+
+        // Set DLPF (Digital Low Pass Filter) to ~44Hz
+        // CONFIG register, bits 2:0 = DLPF_CFG
+        self.write_reg(reg::CONFIG, 0x03)?;
+
+        // Set accelerometer range (default ±2g)
+        self.write_reg(reg::ACCEL_CONFIG, (self.accel_range as u8) << 3)?;
+
+        // Set gyroscope range (default ±250°/s)
+        self.write_reg(reg::GYRO_CONFIG, (self.gyro_range as u8) << 3)?;
+
+        Ok(())
+    }
+
+    /// Verify the device is responding and is an MPU6050.
+    ///
+    /// Returns true if WHO_AM_I register returns expected value.
+    pub fn verify(&mut self) -> Result<bool, E> {
+        let who = self.read_reg(reg::WHO_AM_I)?;
+        Ok(who == MPU6050_WHO_AM_I)
+    }
+
+    /// Set accelerometer full-scale range.
+    ///
+    /// Takes effect immediately.
+    pub fn set_accel_range(&mut self, range: AccelRange) -> Result<(), E> {
+        self.accel_range = range;
+        self.write_reg(reg::ACCEL_CONFIG, (range as u8) << 3)
+    }
+
+    /// Set gyroscope full-scale range.
+    ///
+    /// Takes effect immediately.
+    pub fn set_gyro_range(&mut self, range: GyroRange) -> Result<(), E> {
+        self.gyro_range = range;
+        self.write_reg(reg::GYRO_CONFIG, (range as u8) << 3)
+    }
+
+    /// Read all sensor data in a single burst.
+    ///
+    /// This reads 14 bytes starting at ACCEL_XOUT_H:
+    /// - Accelerometer X, Y, Z (6 bytes)
+    /// - Temperature (2 bytes)
+    /// - Gyroscope X, Y, Z (6 bytes)
+    ///
+    /// Returns raw values; use `convert_reading` for physical units.
+    pub fn read_raw(&mut self) -> Result<RawReading, E> {
+        let mut buf = [0u8; 14];
+        self.i2c.write_read(self.addr, &[reg::ACCEL_XOUT_H], &mut buf)?;
+
+        Ok(RawReading {
+            accel: [
+                i16::from_be_bytes([buf[0], buf[1]]),
+                i16::from_be_bytes([buf[2], buf[3]]),
+                i16::from_be_bytes([buf[4], buf[5]]),
+            ],
+            temp: i16::from_be_bytes([buf[6], buf[7]]),
+            gyro: [
+                i16::from_be_bytes([buf[8], buf[9]]),
+                i16::from_be_bytes([buf[10], buf[11]]),
+                i16::from_be_bytes([buf[12], buf[13]]),
+            ],
+        })
+    }
+
+    /// Convert raw reading to physical units.
+    ///
+    /// Returns (accel_g, gyro_dps, temp_c)
+    pub fn convert_reading(&self, raw: &RawReading) -> ([f32; 3], [f32; 3], f32) {
+        let accel_sens = self.accel_range.sensitivity();
+        let gyro_sens = self.gyro_range.sensitivity();
+
+        let accel_g = [
+            raw.accel[0] as f32 / accel_sens,
+            raw.accel[1] as f32 / accel_sens,
+            raw.accel[2] as f32 / accel_sens,
+        ];
+
+        let gyro_dps = [
+            raw.gyro[0] as f32 / gyro_sens,
+            raw.gyro[1] as f32 / gyro_sens,
+            raw.gyro[2] as f32 / gyro_sens,
+        ];
+
+        // Temperature formula from datasheet:
+        // Temp in °C = (TEMP_OUT / 340.0) + 36.53
+        let temp_c = (raw.temp as f32 / 340.0) + 36.53;
+
+        (accel_g, gyro_dps, temp_c)
+    }
+
+    /// Read and convert in one call.
+    ///
+    /// Convenience method that combines `read_raw` and `convert_reading`.
+    pub fn read(&mut self) -> Result<([f32; 3], [f32; 3], f32), E> {
+        let raw = self.read_raw()?;
+        Ok(self.convert_reading(&raw))
+    }
+
+    // ─────────────────────────────────────────────────────────────────
+    // Low-level register access
+    // ─────────────────────────────────────────────────────────────────
+
+    fn write_reg(&mut self, reg: u8, val: u8) -> Result<(), E> {
+        self.i2c.write(self.addr, &[reg, val])
+    }
+
+    fn read_reg(&mut self, reg: u8) -> Result<u8, E> {
+        let mut buf = [0u8];
+        self.i2c.write_read(self.addr, &[reg], &mut buf)?;
+        Ok(buf[0])
+    }
+}

mqtt_display/src/mpu/mod.rs

@@ -0,0 +1,6 @@
+// src/mpu/mod.rs
+//! MPU6050 accelerometer/gyroscope
+
+pub mod api;
+pub mod driver;
+pub mod task;

mqtt_display/src/mpu/task.rs

@@ -0,0 +1,142 @@
+// src/mpu/task.rs
+//! MPU6050 sampling task.
+//!
+//! This task:
+//! 1. Initializes the MPU6050 sensor
+//! 2. Continuously reads sensor data at a fixed rate
+//! 3. Publishes readings to the IMU channel
+
+use embassy_time::{Duration, Instant, Timer};
+use log::{error, info, warn};
+
+use crate::bus::I2cDevice;
+use crate::contracts::ImuReading;
+use crate::mpu::api::sender;
+use crate::mpu::driver::Mpu6050;
+
+/// Sampling interval in milliseconds.
+/// 50ms = 20Hz
+const SAMPLE_INTERVAL_MS: u64 = 50;
+
+/// MPU6050 I2C address (0x68 with AD0 low, 0x69 with AD0 high)
+const MPU_ADDR: u8 = 0x68;
+
+/// The MPU6050 sampling task.
+///
+/// # Arguments
+/// * `i2c` - An I2C device handle from the shared bus
+///
+/// # Panics
+/// Does not panic; logs errors and retries on failure.
+#[embassy_executor::task]
+pub async fn mpu_task(i2c: I2cDevice) {
+    info!("MPU task starting...");
+
+    let mut mpu = Mpu6050::new(i2c, MPU_ADDR);
+
+    // Initialize with retries
+    let mut init_attempts = 0;
+    loop {
+        init_attempts += 1;
+
+        // Verify device is present
+        match mpu.verify() {
+            Ok(true) => {
+                info!("MPU6050 detected at 0x{:02X}", MPU_ADDR);
+            }
+            Ok(false) => {
+                warn!(
+                    "Device at 0x{:02X} is not MPU6050 (attempt {})",
+                    MPU_ADDR, init_attempts
+                );
+                Timer::after(Duration::from_secs(2)).await;
+                continue;
+            }
+            Err(_) => {
+                warn!(
+                    "I2C error verifying MPU6050 (attempt {})",
+                    init_attempts
+                );
+                Timer::after(Duration::from_secs(2)).await;
+                continue;
+            }
+        }
+
+        // Initialize sensor
+        match mpu.init() {
+            Ok(()) => {
+                info!("MPU6050 initialized successfully");
+                break;
+            }
+            Err(_) => {
+                error!("MPU6050 init failed (attempt {})", init_attempts);
+                Timer::after(Duration::from_secs(2)).await;
+                continue;
+            }
+        }
+    }
+
+    // Allow sensor to stabilize after wake-up
+    Timer::after(Duration::from_millis(100)).await;
+    info!(
+        "MPU task entering sampling loop ({}ms interval)",
+        SAMPLE_INTERVAL_MS
+    );
+
+    let tx = sender();
+    let mut consecutive_errors = 0u32;
+    let mut sent_count: u32 = 0;
+
+    loop {
+        let start = Instant::now();
+
+        match mpu.read() {
+            Ok((accel_g, gyro_dps, temp_c)) => {
+                consecutive_errors = 0;
+
+                let reading = ImuReading {
+                    accel_g,
+                    gyro_dps,
+                    temp_c,
+                    timestamp_ms: start.as_millis(),
+                };
+
+                sent_count = sent_count.wrapping_add(1);
+                if tx.try_send(reading).is_ok() {
+                    if sent_count % 20 == 0 {
+                        info!(
+                            "IMU send#{} ax:{:.2} ay:{:.2} az:{:.2} t:{:.1}",
+                            sent_count, accel_g[0], accel_g[1], accel_g[2], temp_c
+                        );
+                    }
+                } else if sent_count % 20 == 0 {
+                    info!("IMU drop: channel full ({} sent)", sent_count);
+                }
+            }
+
+            Err(_) => {
+                consecutive_errors += 1;
+                if consecutive_errors == 1 || consecutive_errors % 10 == 0 {
+                    warn!("MPU read error (consecutive: {})", consecutive_errors);
+                }
+
+                // If too many errors, try to reinitialize
+                if consecutive_errors >= 50 {
+                    error!("Too many MPU errors, attempting reinit...");
+                    if mpu.init().is_ok() {
+                        info!("MPU reinit successful");
+                        consecutive_errors = 0;
+                        Timer::after(Duration::from_millis(100)).await;
+                    }
+                }
+            }
+        }
+
+        // Maintain a steady period
+        let elapsed = start.elapsed();
+        let target = Duration::from_millis(SAMPLE_INTERVAL_MS);
+        if elapsed < target {
+            Timer::after(target - elapsed).await;
+        }
+    }
+}

mqtt_display/src/mqtt/client.rs

@@ -0,0 +1,442 @@
+// src/mqtt/client.rs
+
+use embassy_net::{tcp::TcpSocket, Stack};
+use embassy_time::{Duration, Timer, Instant};
+use embassy_futures::select::{select, Either};
+use rust_mqtt::client::client::MqttClient;
+use rust_mqtt::client::client_config::{ClientConfig, MqttVersion};
+use rust_mqtt::packet::v5::publish_packet::QualityOfService;
+use rust_mqtt::packet::v5::reason_codes::ReasonCode;
+use rust_mqtt::utils::rng_generator::CountingRng;
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_sync::channel::{Channel, Receiver};
+use embassy_sync::signal::Signal;
+use heapless::{String, Vec};
+use static_cell::ConstStaticCell;
+use core::fmt::Write;
+use log::{info, warn};
+
+use crate::mqtt::config::mqtt_broker_endpoint;
+use crate::contracts::ImuReading;
+
+const RECONNECT_DELAY_SECS: u64 = 5;
+const KEEPALIVE_SECS: u64 = 60;
+const PING_PERIOD: Duration = Duration::from_secs(KEEPALIVE_SECS / 2);
+const SOCKET_POLL_TIMEOUT: Duration = Duration::from_secs(1);
+const PING_TIMEOUT: Duration = Duration::from_secs(5);
+// Must be > PING_PERIOD, ideally > KEEPALIVE
+const NO_SUCCESS_TIMEOUT: Duration = Duration::from_secs(120);
+const NO_IMU_SIG_WARN: Duration = Duration::from_secs(10);
+const SUBS_MAX: usize = 8;
+
+// Limits for static buffers
+pub const TOPIC_MAX: usize = 128;
+pub const PAYLOAD_MAX: usize = 512;
+const COMMAND_QUEUE: usize = 8;
+const EVENT_QUEUE: usize = 8;
+
+// TCP socket buffers (for embassy-net TcpSocket)
+static TCP_RX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
+static TCP_TX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
+
+// MQTT client buffers (separate from the TcpSocket buffers)
+static MQTT_TX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
+static MQTT_RX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
+
+// Tie TcpSocket lifetime to session
+type Client<'a, 'net> = MqttClient<'a, TcpSocket<'net>, 8, CountingRng>;
+
+#[derive(Clone)]
+pub struct IncomingMsg {
+    pub topic: String<TOPIC_MAX>,
+    pub payload: Vec<u8, PAYLOAD_MAX>,
+}
+
+#[derive(Clone)]
+struct PublishMsg {
+    topic: String<TOPIC_MAX>,
+    payload: Vec<u8, PAYLOAD_MAX>,
+    qos: QualityOfService,
+    retain: bool,
+}
+
+#[derive(Clone)]
+enum Command {
+    Publish(PublishMsg),
+    Subscribe(String<TOPIC_MAX>),
+}
+
+// Command/info channels
+static CMD_CHAN: Channel<CriticalSectionRawMutex, Command, COMMAND_QUEUE> = Channel::new();
+static EVT_CHAN: Channel<CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> = Channel::new();
+
+/// Latest-value + wake-up semantics for IMU publish payload (single consumer: MQTT task)
+static IMU_SIG: Signal<CriticalSectionRawMutex, Vec<u8, PAYLOAD_MAX>> = Signal::new();
+
+static SUBS: Mutex<CriticalSectionRawMutex, Vec<String<TOPIC_MAX>, SUBS_MAX>> =
+    Mutex::new(Vec::new());
+
+/// Public API
+
+pub async fn mqtt_publish(topic: &str, payload: &[u8], qos: QualityOfService, retain: bool) {
+    CMD_CHAN
+        .send(Command::Publish(PublishMsg {
+            topic: truncate_str::<TOPIC_MAX>(topic),
+            payload: truncate_payload(payload),
+            qos,
+            retain,
+        }))
+        .await;
+}
+
+pub fn mqtt_try_publish(topic: &str, payload: &[u8], qos: QualityOfService, retain: bool) -> bool {
+    CMD_CHAN
+        .try_send(Command::Publish(PublishMsg {
+            topic: truncate_str::<TOPIC_MAX>(topic),
+            payload: truncate_payload(payload),
+            qos,
+            retain,
+        }))
+        .is_ok()
+}
+
+pub fn mqtt_set_imu(reading: ImuReading) {
+    // Encode JSON into a bounded buffer (no alloc::format!)
+    let payload = encode_imu_json(&reading);
+    IMU_SIG.signal(payload);
+}
+
+pub fn mqtt_set_imu_payload(payload: Vec<u8, PAYLOAD_MAX>) {
+    IMU_SIG.signal(payload);
+}
+
+pub fn encode_imu_json(reading: &ImuReading) -> Vec<u8, PAYLOAD_MAX> {
+    let mut s: String<256> = String::new();
+    let _ = write!(
+        &mut s,
+        "{{\"ax\":{:.2},\"ay\":{:.2},\"az\":{:.2},\"gx\":{:.1},\"gy\":{:.1},\"gz\":{:.1},\"t\":{:.1},\"ts\":{}}}",
+        reading.accel_g[0], reading.accel_g[1], reading.accel_g[2],
+        reading.gyro_dps[0], reading.gyro_dps[1], reading.gyro_dps[2],
+        reading.temp_c,
+        reading.timestamp_ms
+    );
+    let mut v: Vec<u8, PAYLOAD_MAX> = Vec::new();
+    let _ = v.extend_from_slice(s.as_bytes());
+    v
+}
+
+pub async fn mqtt_subscribe(topic: &str) {
+    let t = truncate_str::<TOPIC_MAX>(topic);
+    {
+        let mut subs = SUBS.lock().await;
+        let exists = subs.iter().any(|s| s.as_str() == t.as_str());
+        if !exists {
+            let _ = subs.push(t.clone());
+        }
+    }
+    CMD_CHAN.send(Command::Subscribe(t)).await;
+}
+
+pub fn mqtt_events(
+) -> Receiver<'static, CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> {
+    EVT_CHAN.receiver()
+}
+
+/// Internals
+
+fn truncate_str<const N: usize>(s: &str) -> String<N> {
+    let mut h = String::new();
+    if N == 0 {
+        return h;
+    }
+    if s.len() <= N {
+        let _ = h.push_str(s);
+        return h;
+    }
+
+    let mut cut = N;
+    while cut > 0 && !s.is_char_boundary(cut) {
+        cut -= 1;
+    }
+    let _ = h.push_str(&s[..cut]);
+    h
+}
+
+fn truncate_payload(data: &[u8]) -> Vec<u8, PAYLOAD_MAX> {
+    let mut v = Vec::new();
+    let _ = v.extend_from_slice(&data[..data.len().min(PAYLOAD_MAX)]);
+    v
+}
+
+async fn handle_command(client: &mut Client<'_, '_>, cmd: Command) -> Result<(), ReasonCode> {
+    match cmd {
+        Command::Publish(msg) => {
+            client
+                .send_message(msg.topic.as_str(), &msg.payload, msg.qos, msg.retain)
+                .await
+        }
+        Command::Subscribe(topic) => {
+            let res = client.subscribe_to_topic(topic.as_str()).await;
+            if res.is_ok() {
+                info!("Subscribed to '{}'", topic);
+            }
+            res
+        }
+    }
+}
+
+async fn handle_incoming(result: Result<(&str, &[u8]), ReasonCode>) -> Result<(), ReasonCode> {
+    let (topic, payload) = result?;
+    let msg = IncomingMsg {
+        topic: truncate_str::<TOPIC_MAX>(topic),
+        payload: truncate_payload(payload),
+    };
+    if EVT_CHAN.try_send(msg).is_err() {
+        warn!("MQTT EVT queue full, dropping incoming message");
+    }
+    Ok(())
+}
+
+async fn run_one_session(
+    stack: Stack<'static>,
+    tcp_rx: &mut [u8],
+    tcp_tx: &mut [u8],
+    mqtt_tx: &mut [u8],
+    mqtt_rx: &mut [u8],
+) -> Result<(), ()> {
+    let mut socket = TcpSocket::new(stack, tcp_rx, tcp_tx);
+    socket.set_timeout(Some(SOCKET_POLL_TIMEOUT * 10));
+    match socket.connect(mqtt_broker_endpoint()).await {
+        Ok(_) => info!("Connected TCP to MQTT broker"),
+        Err(e) => {
+            info!("TCP connect failed: {:#?}", e);
+            return Err(());
+        }
+    }
+
+    let mut cfg: ClientConfig<8, CountingRng> =
+        ClientConfig::new(MqttVersion::MQTTv5, CountingRng(0));
+    cfg.keep_alive = KEEPALIVE_SECS as u16;
+    cfg.add_client_id("esp32-client");
+
+    let mut client =
+        MqttClient::new(socket, mqtt_tx, mqtt_tx.len(), mqtt_rx, mqtt_rx.len(), cfg);
+
+    match client.connect_to_broker().await {
+        Ok(_) => info!("MQTT CONNACK received"),
+        Err(reason) => {
+            info!("MQTT connect failed: {:?}", reason);
+            return Err(());
+        }
+    }
+
+    // Re-subscribe after every (re)connect
+    let mut subs_snapshot: Vec<String<TOPIC_MAX>, SUBS_MAX> = Vec::new();
+    {
+        let subs = SUBS.lock().await;
+        for t in subs.iter() {
+            let _ = subs_snapshot.push(t.clone());
+        }
+    }
+    for t in subs_snapshot.iter() {
+        match client.subscribe_to_topic(t.as_str()).await {
+            Ok(_) => info!("Subscribed to '{}'", t),
+            Err(e) => {
+                warn!("MQTT resubscribe failed: {:?}", e);
+                return Err(());
+            }
+        }
+    }
+
+    let mut next_ping_at = Instant::now() + PING_PERIOD;
+    let cmd_rx = CMD_CHAN.receiver();
+
+    // Only restart the session after N consecutive IMU publish failures
+    let mut imu_tx_fail_streak: u8 = 0;
+    let mut hb_at = Instant::now() + Duration::from_secs(10);
+    let mut tx_ok: u32 = 0;
+    let mut tx_err: u32 = 0;
+    let mut rx_ok: u32 = 0;
+    let mut ping_ok: u32 = 0;
+    let mut last_ok = Instant::now();        // last successful MQTT I/O (tx/rx/ping)
+    let mut last_imu_sig = Instant::now();   // last time we received IMU_SIG in MQTT task
+
+    loop {
+        let now = Instant::now();
+
+        if now - last_ok > NO_SUCCESS_TIMEOUT {
+            warn!(
+                "MQTT no successful I/O for {:?} -> restart session",
+                now - last_ok
+            );
+            return Err(());
+        }
+
+        if now - last_imu_sig > NO_IMU_SIG_WARN {
+            // This is diagnostic: if core0 claims it's sending, but this prints, you have cross-core signaling loss.
+            warn!(
+                "MQTT hasn't received IMU_SIG for {:?} (core0->core1 sync likely broken)",
+                now - last_imu_sig
+            );
+            // Rate-limit the warning
+            last_imu_sig = now;
+        }
+
+        let ping_in = if next_ping_at > now { next_ping_at - now } else { Duration::from_secs(0) };
+
+        // Timebox receive_message() even if lower layers misbehave.
+        let recv_fut = async {
+            match select(client.receive_message(), Timer::after(SOCKET_POLL_TIMEOUT)).await {
+                Either::First(res) => Some(res),
+                Either::Second(_) => None,
+            }
+        };
+
+        // 4-way select using nested selects to avoid relying on select4()
+        match select(
+            select(cmd_rx.receive(), IMU_SIG.wait()),
+            select(recv_fut, Timer::after(ping_in)),
+        )
+        .await
+        {
+            // Command received
+            Either::First(Either::First(cmd)) => {
+                handle_command(&mut client, cmd).await.map_err(|_| ())?;
+                next_ping_at = Instant::now() + PING_PERIOD;
+                last_ok = Instant::now();
+
+                // Drain any additional queued commands quickly
+                while let Ok(cmd) = CMD_CHAN.try_receive() {
+                    handle_command(&mut client, cmd).await.map_err(|_| ())?;
+                    last_ok = Instant::now();
+                    next_ping_at = Instant::now() + PING_PERIOD;
+                }
+            }
+
+            // IMU update signaled (latest value semantics)
+            Either::First(Either::Second(payload)) => {
+                last_imu_sig = Instant::now();
+                // Enable temporarily for diagnostics:
+                // info!("IMU_SIG received in MQTT task (len={})", payload.len());
+
+                // Timebox the publish so we don't hang forever inside send_message().await
+                let send_res = match select(
+                    client.send_message("esp32/imu", &payload, QualityOfService::QoS0, false),
+                    Timer::after(Duration::from_secs(5)),
+                )
+                    .await
+                    {
+                        Either::First(res) => res,
+                        Either::Second(_) => Err(ReasonCode::NetworkError),
+                    };
+
+                match send_res {
+                    Ok(_) => {
+                        next_ping_at = Instant::now() + PING_PERIOD;
+                        imu_tx_fail_streak = 0;
+                        last_ok = Instant::now();
+
+                        tx_ok = tx_ok.wrapping_add(1);
+                        if (tx_ok % 10) == 0 {
+                            info!(
+                                "MQTT alive: tx_ok={} tx_err={} rx_ok={} streak={}",
+                                tx_ok, tx_err, rx_ok, imu_tx_fail_streak
+                            );
+                        }
+                    }
+                    Err(e) => {
+                        tx_err = tx_err.wrapping_add(1);
+                        imu_tx_fail_streak = imu_tx_fail_streak.saturating_add(1);
+                        warn!("MQTT IMU TX fail {}/5: {:?}", imu_tx_fail_streak, e);
+
+                        if imu_tx_fail_streak >= 5 {
+                            warn!("MQTT IMU TX fail 5x -> restart session");
+                            return Err(());
+                        }
+                    }
+                }
+            }
+
+            // Incoming message (or None on timeout)
+            Either::Second(Either::First(opt)) => {
+                if let Some(res) = opt {
+                    match res {
+                        Ok((topic, payload)) => {
+                            rx_ok = rx_ok.wrapping_add(1);
+                            let _ = handle_incoming(Ok((topic, payload))).await;
+
+                            last_ok = Instant::now();
+                            imu_tx_fail_streak = 0;
+                            next_ping_at = Instant::now() + PING_PERIOD;
+                        }
+                        Err(ReasonCode::NetworkError) => {
+                            // idle tick
+                        }
+                        Err(e) => {
+                            warn!("MQTT receive error (fatal): {:?}", e);
+                            return Err(());
+                        }
+                    }
+                }
+            }
+
+            // Ping timer fired
+            Either::Second(Either::Second(_)) => {
+                if Instant::now() >= hb_at {
+                    info!(
+                        "MQTT hb tx_ok={} tx_err={} rx_ok={} ping_ok={} streak={}",
+                        tx_ok, tx_err, rx_ok, ping_ok, imu_tx_fail_streak
+                    );
+                    hb_at = Instant::now() + Duration::from_secs(10);
+                }
+
+                let ping_res = match select(client.send_ping(), Timer::after(PING_TIMEOUT)).await {
+                    Either::First(res) => res,
+                    Either::Second(_) => Err(ReasonCode::NetworkError),
+                };
+
+                match ping_res {
+                    Ok(_) => {
+                        ping_ok = ping_ok.wrapping_add(1);
+                        imu_tx_fail_streak = 0;
+                        last_ok = Instant::now();
+                        next_ping_at = Instant::now() + PING_PERIOD;
+                    }
+                    Err(e) => {
+                        warn!("MQTT ping failed/timeout: {:?}", e);
+                        return Err(());
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[embassy_executor::task]
+pub async fn mqtt_task(stack: Stack<'static>) {
+    info!("MQTT task starting...");
+
+    let tcp_rx = TCP_RX_BUFFER.take();
+    let tcp_tx = TCP_TX_BUFFER.take();
+    let mqtt_tx = MQTT_TX_BUF.take();
+    let mqtt_rx = MQTT_RX_BUF.take();
+
+    loop {
+        let _ = run_one_session(
+            stack,
+            &mut tcp_rx[..],
+            &mut tcp_tx[..],
+            &mut mqtt_tx[..],
+            &mut mqtt_rx[..],
+        )
+        .await;
+
+        info!(
+            "Reconnecting in {}s after session end/failure",
+            RECONNECT_DELAY_SECS
+        );
+        Timer::after(Duration::from_secs(RECONNECT_DELAY_SECS)).await;
+    }
+}

mqtt_display/src/mqtt/config.rs

@@ -0,0 +1,122 @@
+// src/mqtt/config.rs
+#![allow(dead_code)]
+
+use embassy_net::{IpAddress, Ipv4Address, Ipv6Address};
+
+// Compile-time values injected by build.rs
+const BROKER_IP: &str = env!("BROKER_IP");
+const BROKER_PORT: &str = env!("BROKER_PORT");
+
+pub fn mqtt_broker_endpoint() -> (IpAddress, u16) {
+    (parse_ip(BROKER_IP), parse_port(BROKER_PORT))
+}
+
+fn parse_port(s: &str) -> u16 {
+    let p: u16 = s
+        .parse()
+        .unwrap_or_else(|_| panic!("BROKER_PORT must be a valid u16 (1..=65535)"));
+    assert!(p != 0, "BROKER_PORT cannot be 0");
+    p
+}
+
+fn parse_ip(s: &str) -> IpAddress {
+    if s.contains(':') {
+        IpAddress::Ipv6(parse_ipv6(s))
+    } else {
+        IpAddress::Ipv4(parse_ipv4(s))
+    }
+}
+
+fn parse_ipv4(s: &str) -> Ipv4Address {
+    let mut it = s.split('.');
+    let a = parse_octet(it.next(), 1);
+    let b = parse_octet(it.next(), 2);
+    let c = parse_octet(it.next(), 3);
+    let d = parse_octet(it.next(), 4);
+    assert!(it.next().is_none(), "Too many IPv4 octets");
+    Ipv4Address::new(a, b, c, d)
+}
+
+fn parse_octet(part: Option<&str>, idx: usize) -> u8 {
+    let p = part.unwrap_or_else(|| panic!("IPv4 missing octet {}", idx));
+    let v: u16 = p
+        .parse()
+        .unwrap_or_else(|_| panic!("Invalid IPv4 octet {}: {}", idx, p));
+    assert!(v <= 255, "IPv4 octet {} out of range: {}", idx, v);
+    v as u8
+}
+
+// Minimal IPv6 parser with '::' compression. Does not handle IPv4-embedded IPv6.
+fn parse_ipv6(s: &str) -> Ipv6Address {
+    assert!(
+        !s.contains('.'),
+        "IPv4-embedded IPv6 like ::ffff:192.0.2.1 not supported; \
+         use pure hex IPv6"
+    );
+
+    let has_double = s.contains("::");
+    let (left_s, right_s) = if has_double {
+        let mut sp = s.splitn(2, "::");
+        (sp.next().unwrap_or(""), sp.next().unwrap_or(""))
+    } else {
+        (s, "")
+    };
+
+    let mut left = [0u16; 8];
+    let mut right = [0u16; 8];
+    let mut ll = 0usize;
+    let mut rl = 0usize;
+
+    if !left_s.is_empty() {
+        for part in left_s.split(':') {
+            left[ll] = parse_group(part);
+            ll += 1;
+            assert!(ll <= 8, "Too many IPv6 groups on the left");
+        }
+    }
+
+    if !right_s.is_empty() {
+        for part in right_s.split(':') {
+            right[rl] = parse_group(part);
+            rl += 1;
+            assert!(rl <= 8, "Too many IPv6 groups on the right");
+        }
+    }
+
+    let zeros = if has_double {
+        assert!(ll + rl < 8, "Invalid IPv6 '::' usage");
+        8 - (ll + rl)
+    } else {
+        assert!(ll == 8, "IPv6 must have 8 groups without '::'");
+        0
+    };
+
+    let mut g = [0u16; 8];
+    let mut idx = 0usize;
+
+    for i in 0..ll {
+        g[idx] = left[i];
+        idx += 1;
+    }
+    for _ in 0..zeros {
+        g[idx] = 0;
+        idx += 1;
+    }
+    for i in 0..rl {
+        g[idx] = right[i];
+        idx += 1;
+    }
+    assert!(idx == 8, "IPv6 did not resolve to 8 groups");
+
+    Ipv6Address::new(g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7])
+}
+
+fn parse_group(part: &str) -> u16 {
+    assert!(
+        !part.is_empty(),
+        "Empty IPv6 group (use '::' instead for compression)"
+    );
+    assert!(part.len() <= 4, "IPv6 group too long: {}", part);
+    u16::from_str_radix(part, 16)
+        .unwrap_or_else(|_| panic!("Invalid IPv6 hex group: {}", part))
+}

mqtt_display/src/mqtt/mod.rs

@@ -0,0 +1,4 @@
+// src/mqtt/mod.rs
+
+pub mod client;
+pub mod config;

test1/src/bin/mqtt_docs.md

@@ -1,13 +0,0 @@
-# MQTT Implementation Notes
-
-* WiFi connection runs in a separate task with auto-reconnect functionality
-* Network stack operates in a dedicated packet processing task
-* MQTT uses TCP socket connection (MqttClient wraps this socket)
-* ClientConfig specifies: MQTT version, QoS levels, client ID
-* Standard flow: connect_to_broker() → send_message() or subscribe()
-
-## Implementation:
-1. Perform DNS lookup for broker hostname
-2. Establish TCP socket connection
-3. Create MqttClient with configuration
-4. Implement connect, publish, and subscribe logic

test_LED2/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

test_LED2/.env_temp

@@ -0,0 +1,2 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"

test_LED2/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

test_LED2/Cargo.toml

@@ -0,0 +1,68 @@
+[package]
+edition      = "2021"
+name         = "test1"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "test1"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+  "esp32",
+  "log-04",
+  "unstable",
+] }
+log = "0.4.27"
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.4.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+heapless = "0.9.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

test_LED2/Makefile

@@ -0,0 +1,9 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor

test_LED2/build.rs

@@ -0,0 +1,65 @@
+fn main() {
+    // load .env and pass SSID/PASSWORD to compiler
+    if let Ok(dotenv_path) = dotenvy::dotenv() {
+        // Only rebuild if .env changes
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+
+    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");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

test_LED2/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

test_LED2/src/bin/main.rs

@@ -0,0 +1,49 @@
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
+    holding buffers for the duration of a data transfer."
+)]
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Timer};
+use esp_backtrace as _;
+use esp_hal::gpio::{Output, Level, OutputConfig};
+use esp_hal::clock::CpuClock;
+use esp_hal::timer::timg::TimerGroup;
+use log::info;
+
+extern crate alloc;
+
+// This creates a default app-descriptor required by the esp-idf bootloader.
+// For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
+esp_bootloader_esp_idf::esp_app_desc!();
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    
+    esp_alloc::heap_allocator!(size: 64 * 1024);
+    
+    let timer0 = TimerGroup::new(peripherals.TIMG1);
+    esp_hal_embassy::init(timer0.timer0);
+
+    // Initialize GPIO4 as output (starts LOW)
+    let mut gpio4 = Output::new(peripherals.GPIO4, Level::Low, OutputConfig::default());
+    
+    info!("Embassy initialized!");
+    loop {
+        gpio4.set_high();
+        info!("GPIO4 ON");
+        Timer::after(Duration::from_secs(1)).await;
+
+        gpio4.set_low();
+        info!("GPIO4 OFF");
+        Timer::after(Duration::from_secs(1)).await;
+    }
+    
+    // for inspiration have a look at the examples at https://github.com/esp-rs/esp-hal/tree/esp-hal-v1.0.0-rc.0/examples/src/bin
+}

test_LED2/src/lib.rs

@@ -0,0 +1 @@
+#![no_std]

test_LED3_timer/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

test_LED3_timer/.env_temp

@@ -0,0 +1,2 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"

test_LED3_timer/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

test_LED3_timer/Cargo.toml

@@ -0,0 +1,68 @@
+[package]
+edition      = "2021"
+name         = "test1"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "test1"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+  "esp32",
+  "log-04",
+  "unstable",
+] }
+log = "0.4.27"
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.4.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+heapless = "0.9.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

test_LED3_timer/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+clean:
+	cargo espflash erase-flash

test_LED3_timer/build.rs

@@ -0,0 +1,65 @@
+fn main() {
+    // load .env and pass SSID/PASSWORD to compiler
+    if let Ok(dotenv_path) = dotenvy::dotenv() {
+        // Only rebuild if .env changes
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+
+    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");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

test_LED3_timer/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

test_LED3_timer/src/bin/main.rs

@@ -0,0 +1,66 @@
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
+    holding buffers for the duration of a data transfer."
+)]
+use embassy_executor::Spawner;
+// use embassy_time::{Duration, Timer};
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    gpio::{Level, Output, OutputConfig},
+    timer::Timer,
+    timer::timg::TimerGroup,
+    time::Duration,
+};
+use log::info;
+
+extern crate alloc;
+
+// This creates a default app-descriptor required by the esp-idf bootloader.
+// For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
+esp_bootloader_esp_idf::esp_app_desc!();
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    
+    esp_alloc::heap_allocator!(size: 64 * 1024);
+    
+    let timer_group1 = TimerGroup::new(peripherals.TIMG1);
+    let timer0 = timer_group1.timer0;
+
+    // Initialize GPIO4 as output (starts LOW)
+    let mut gpio4 = Output::new(peripherals.GPIO4, Level::Low, OutputConfig::default());
+    
+    info!("Embassy initialized!");
+    loop {
+        gpio4.set_high();
+        info!("GPIO4 ON");
+
+        // Start timer for 1 second and block until done
+        let duration = Duration::from_secs(1);
+        timer0.load_value(duration).unwrap();
+        timer0.start();
+        info!("{:?}", duration);
+
+        // Wait until timer completes
+        while !timer0.is_interrupt_set() {}
+        timer0.clear_interrupt();
+
+        gpio4.set_low();
+        info!("GPIO4 OFF");
+
+        // Start timer for 1 second and block until done
+        timer0.load_value(duration).unwrap();
+        timer0.start();
+
+        while !timer0.is_interrupt_set() {}
+        timer0.clear_interrupt();
+    }
+}

test_LED3_timer/src/lib.rs

@@ -0,0 +1 @@
+#![no_std]

test_LED4_soft_interrupt/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

test_LED4_soft_interrupt/.env_temp

@@ -0,0 +1,2 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"

test_LED4_soft_interrupt/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

test_LED4_soft_interrupt/Cargo.toml

@@ -0,0 +1,68 @@
+[package]
+edition      = "2021"
+name         = "test1"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "test1"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+  "esp32",
+  "log-04",
+  "unstable",
+] }
+log = "0.4.27"
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.4.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+heapless = "0.9.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

test_LED4_soft_interrupt/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+clean:
+	cargo espflash erase-flash

test_LED4_soft_interrupt/build.rs

@@ -0,0 +1,65 @@
+fn main() {
+    // load .env and pass SSID/PASSWORD to compiler
+    if let Ok(dotenv_path) = dotenvy::dotenv() {
+        // Only rebuild if .env changes
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+
+    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");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

test_LED4_soft_interrupt/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

test_LED4_soft_interrupt/src/bin/main.rs

@@ -0,0 +1,55 @@
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
+    holding buffers for the duration of a data transfer."
+)]
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Timer};
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    gpio::{Level, Output, OutputConfig},
+    timer::timg::TimerGroup,
+};
+use log::info;
+extern crate alloc;
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+
+#[embassy_executor::task]
+async fn led_blink_task(mut led: Output<'static>) {
+    loop {
+        led.toggle();
+        info!("LED toggled");
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    esp_alloc::heap_allocator!(size: 64 * 1024);
+    
+    let timer_group1 = TimerGroup::new(peripherals.TIMG1);
+    esp_hal_embassy::init(timer_group1.timer0);
+
+    let gpio4 = Output::new(peripherals.GPIO4, Level::Low, OutputConfig::default());
+    
+    info!("Embassy initialized!");
+    
+    // Spawn LED blink task - runs independently
+    spawner.spawn(led_blink_task(gpio4)).unwrap();
+    
+    // CPU does other work here
+    let mut counter: u8 = 230;
+    loop {
+        info!("CPU doing other work: {}", counter);
+        counter = counter.wrapping_add(1);
+        Timer::after(Duration::from_millis(300)).await;
+    }
+}

test_LED4_soft_interrupt/src/lib.rs

@@ -0,0 +1 @@
+#![no_std]

test_LED5_hard_interrupt/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

test_LED5_hard_interrupt/.env_temp

@@ -0,0 +1,2 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"

test_LED5_hard_interrupt/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

test_LED5_hard_interrupt/Cargo.toml

@@ -0,0 +1,64 @@
+[package]
+edition      = "2021"
+name         = "test1"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "test1"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = ["esp32", "log-04", "rt", "unstable"] }
+log = "0.4.27"
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.4.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+heapless = "0.9.1"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

test_LED5_hard_interrupt/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+clean:
+	cargo espflash erase-flash

test_LED5_hard_interrupt/build.rs

@@ -0,0 +1,65 @@
+fn main() {
+    // load .env and pass SSID/PASSWORD to compiler
+    if let Ok(dotenv_path) = dotenvy::dotenv() {
+        // Only rebuild if .env changes
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+
+    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");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

test_LED5_hard_interrupt/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

test_LED5_hard_interrupt/src/bin/main.rs

@@ -0,0 +1,87 @@
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
+    holding buffers for the duration of a data transfer."
+)]
+use embassy_executor::Spawner;
+// use embassy_time::{Duration, Timer};
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    gpio::{Level, Output, OutputConfig},
+    timer::Timer,
+    interrupt,
+    peripherals,
+    timer::timg::TimerGroup,
+    time::Duration,
+};
+use core::cell::RefCell;
+use critical_section::Mutex;
+use esp_hal::handler;
+use log::info;
+
+extern crate alloc;
+
+// This creates a default app-descriptor required by the esp-idf bootloader.
+// For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
+esp_bootloader_esp_idf::esp_app_desc!();
+
+static mut INTERRUPT_FIRED: bool = false;
+static TIMER0: Mutex<RefCell<Option<esp_hal::timer::timg::Timer<'static>>>> = Mutex::new(RefCell::new(None));
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    
+    esp_alloc::heap_allocator!(size: 64 * 1024);
+    
+    let timer_group1 = TimerGroup::new(peripherals.TIMG1);
+    let timer0 = timer_group1.timer0;
+
+    timer0.set_interrupt_handler(TG1_T0_LEVEL);
+    timer0.clear_interrupt();
+    timer0.load_value(Duration::from_secs(1)).unwrap();
+    timer0.enable_interrupt(true);
+    timer0.enable_auto_reload(true);
+    timer0.start();
+
+    // Store timer in the static safely
+    critical_section::with(|cs| {
+        TIMER0.borrow_ref_mut(cs).replace(timer0);
+    });
+
+    // Initialize GPIO4 as output (starts LOW)
+    let mut gpio4 = Output::new(peripherals.GPIO4, Level::Low, OutputConfig::default());
+    
+    info!("Embassy initialized!");
+    loop {
+
+        info!("info!");
+        // let mut counter = 0;
+        // while counter < 10000000 {
+        //     counter += 1;
+        // }
+        if unsafe { INTERRUPT_FIRED } {
+            gpio4.toggle();
+            info!("tick");
+            unsafe { INTERRUPT_FIRED = false; }
+        }
+        esp_hal::delay::Delay::new().delay_millis(100);
+    }
+}
+
+#[handler]
+fn TG1_T0_LEVEL() {
+    critical_section::with(|cs| {
+        if let Some(timer) = TIMER0.borrow_ref_mut(cs).as_mut() {
+
+            timer.clear_interrupt();
+            unsafe { INTERRUPT_FIRED = true; }
+        }
+    });
+}

test_LED5_hard_interrupt/src/lib.rs

@@ -0,0 +1 @@
+#![no_std]

test_LED6_async_hard_interrupt/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]

test_LED6_async_hard_interrupt/.env_temp

@@ -0,0 +1,2 @@
+SSID = "nazov_wifi_siete"
+PASSWORD = "heslo_od_wifi"

test_LED6_async_hard_interrupt/.gitignore

@@ -0,0 +1,20 @@
+# will have compiled files and executables
+debug/
+target/
+.vscode/
+.zed/
+.helix/
+.env
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

test_LED6_async_hard_interrupt/Cargo.toml

@@ -0,0 +1,65 @@
+[package]
+edition      = "2021"
+name         = "test1"
+rust-version = "1.86"
+version      = "0.1.0"
+
+[[bin]]
+name = "test1"
+path = "./src/bin/main.rs"
+
+[dependencies]
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
+esp-hal = { version = "=1.0.0-rc.0", features = ["esp32", "log-04", "rt", "unstable"] }
+log = "0.4.27"
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+  "esp32",
+  "exception-handler",
+  "panic-handler",
+  "println",
+] }
+esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+critical-section = "1.2.0"
+embassy-executor = { version = "0.7.0", features = [
+  "log",
+  "task-arena-size-20480",
+] }
+embassy-time = { version = "0.4.0", features = ["log"] }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
+] }
+static_cell = "2.1.1"
+heapless = "0.9.1"
+embassy-sync = "0.7.2"
+
+[build-dependencies]
+dotenvy = "0.15.7"
+
+[profile.dev]
+# Rust debug is too slow.
+# For debug builds always builds with some optimization
+opt-level = "s"
+
+[profile.release]
+codegen-units    = 1     # LLVM can perform better optimizations using a single thread
+debug            = 2
+debug-assertions = false
+incremental      = false
+lto              = 'fat'
+opt-level        = 's'
+overflow-checks  = false

test_LED6_async_hard_interrupt/Makefile

@@ -0,0 +1,12 @@
+.PHONY: all build flash
+
+all: build flash
+
+build:
+	cargo build --release
+
+flash:
+	cargo espflash flash --release --monitor
+
+clean:
+	cargo espflash erase-flash

test_LED6_async_hard_interrupt/build.rs

@@ -0,0 +1,65 @@
+fn main() {
+    // load .env and pass SSID/PASSWORD to compiler
+    if let Ok(dotenv_path) = dotenvy::dotenv() {
+        // Only rebuild if .env changes
+        println!("cargo:rerun-if-changed={}", dotenv_path.display());
+    }
+
+    if let Ok(ssid) = std::env::var("SSID") {
+        println!("cargo:rustc-env=SSID={}", ssid);
+    }
+    if let Ok(password) = std::env::var("PASSWORD") {
+        println!("cargo:rustc-env=PASSWORD={}", password);
+    }
+
+    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");
+}
+
+fn linker_be_nice() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() > 1 {
+        let kind = &args[1];
+        let what = &args[2];
+
+        match kind.as_str() {
+            "undefined-symbol" => match what.as_str() {
+                "_defmt_timestamp" => {
+                    eprintln!();
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
+                    eprintln!();
+                }
+                "_stack_start" => {
+                    eprintln!();
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
+                    eprintln!();
+                }
+                "esp_wifi_preempt_enable"
+                | "esp_wifi_preempt_yield_task"
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
+        }
+
+        std::process::exit(0);
+    }
+
+    println!(
+        "cargo:rustc-link-arg=-Wl,--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}

test_LED6_async_hard_interrupt/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "esp"

test_LED6_async_hard_interrupt/src/bin/main.rs

@@ -0,0 +1,89 @@
+#![no_std]
+#![no_main]
+#![deny(
+    clippy::mem_forget,
+    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
+    holding buffers for the duration of a data transfer."
+)]
+use embassy_executor::Spawner;
+use embassy_sync::signal::Signal;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_time::Duration;
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    gpio::{Level, Output, OutputConfig},
+    timer::Timer as HalTimer,
+    interrupt,
+    peripherals,
+    timer::timg::TimerGroup,
+    time::Duration as HalDuration,
+};
+use core::cell::RefCell;
+use critical_section::Mutex;
+use esp_hal::handler;
+use log::info;
+
+// This creates a default app-descriptor required by the esp-idf bootloader.
+// For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
+esp_bootloader_esp_idf::esp_app_desc!();
+
+static SIGNAL: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+static TIMER0: Mutex<RefCell<Option<esp_hal::timer::timg::Timer<'static>>>> = Mutex::new(RefCell::new(None));
+
+#[esp_hal_embassy::main]
+async fn main(spawner: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    
+    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+    let peripherals = esp_hal::init(config);
+    
+    esp_alloc::heap_allocator!(size: 64 * 1024);
+    let timer_group0 = TimerGroup::new(peripherals.TIMG0);
+    esp_hal_embassy::init(timer_group0.timer0);
+    
+    let timer_group1 = TimerGroup::new(peripherals.TIMG1);
+    let timer0 = timer_group1.timer0;
+
+    timer0.set_interrupt_handler(TG1_T0_LEVEL);
+    timer0.clear_interrupt();
+    timer0.load_value(HalDuration::from_secs(1)).unwrap();
+    timer0.enable_interrupt(true);
+    timer0.enable_auto_reload(true);
+    timer0.start();
+
+    // Store timer in the static safely
+    critical_section::with(|cs| {
+        TIMER0.borrow_ref_mut(cs).replace(timer0);
+    });
+
+    // Initialize GPIO4 as output (starts LOW)
+    let gpio4 = Output::new(peripherals.GPIO4, Level::Low, OutputConfig::default());
+
+    spawner.spawn(led_task(gpio4)).unwrap();
+    
+    info!("Embassy initialized!");
+    loop {
+        embassy_time::Timer::after(Duration::from_secs(5)).await;
+        info!("x");
+    }
+}
+
+#[embassy_executor::task]
+async fn led_task(mut gpio4: Output<'static>) {
+    loop {
+        SIGNAL.wait().await;
+        gpio4.toggle();
+        info!("tick");
+    }
+}
+
+#[handler]
+fn TG1_T0_LEVEL() {
+    critical_section::with(|cs| {
+        if let Some(timer) = TIMER0.borrow_ref_mut(cs).as_mut() {
+            timer.clear_interrupt();
+            SIGNAL.signal(());
+        }
+    });
+}

test_LED6_async_hard_interrupt/src/lib.rs

@@ -0,0 +1 @@
+#![no_std]

test_LED_pwm/.cargo/config.toml

@@ -0,0 +1,16 @@
+[target.xtensa-esp32-none-elf]
+runner = "espflash flash --monitor --chip esp32"
+
+[env]
+ESP_LOG="info"
+
+[build]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+  "-Z", "stack-protector=all",
+]
+
+target = "xtensa-esp32-none-elf"
+
+[unstable]
+build-std = ["alloc", "core"]