m5stack-core 0.6.1

[package]
name = "m5stack-core"
version = "0.6.1"
edition = "2024"
rust-version = "1.96"
license = "MIT OR Apache-2.0"
description = "Board support crate for M5Stack Fire27 and CoreS3 (ESP32/ESP32-S3)"
repository = "https://github.com/emobotics-dev/m5stack-core"
# Self-hosted rustdoc, built by .forgejo/workflows/docs.yml. docs.rs runs the
# stock rust-lang toolchain, which has no Xtensa backend, so it cannot build
# this crate for either board — see the docs section in README.md.
documentation = "https://emobotics-dev.github.io/m5stack-core"
readme = "README.md"
keywords = ["esp32", "m5stack", "embedded", "bsp", "embassy"]
categories = ["embedded", "no-std", "hardware-support"]
# An allow-list, not the `exclude` it replaces: cargo packages every
# untracked-but-unignored file, so a blocklist must name each tool directory
# that might ever appear — and `.claude/` shipped in 0.5.0 because it did not
# (#59). Unknown files now fail closed, loudly, and `.cargo/credentials.toml`
# cannot ship at all since only `config.toml` is named.
include = [
    "/src/**/*.rs",
    "/tools/**",
    "/docs/**",
    "/build.rs",
    "/Cargo.toml",
    "/README.md",
    "/CHANGELOG.md",
    "/LICENSE-MIT",
    "/LICENSE-APACHE",
    "/hil.toml.example",
    "/rust-toolchain.toml",
    "/.cargo/config.toml",
    "/.gitignore",
]

[lib]
test = false
bench = false

[features]
# The `esp-bootloader-esp-idf?/<chip>` arms only bite when the optional dep is
# already on (via `heap`) — `init_heap`'s `#[ram(reclaimed)]` region needs the
# esp-idf bootloader crate in the graph; a heap-free build never pulls it.
fire27 = ["esp-hal/esp32", "esp-radio/esp32", "esp-sync/esp32", "esp-bootloader-esp-idf?/esp32", "esp-rtos?/esp32"]
cores3 = ["esp-hal/esp32s3", "esp-radio/esp32s3", "esp-sync/esp32s3", "esp-bootloader-esp-idf?/esp32s3", "esp-rtos?/esp32s3"]
# Enables the masked 1-Wire ROM search (driver::onewire::Search::new_with_mask),
# constraining enumeration to addresses matching fixed bits under a mask.
search-masks = []
# HIL serial-cmd driver — exposes a Read endpoint over UART0 (fire27) or
# USB-Serial-JTAG (cores3). Paired with `alternator-regulator/serial-cmd`.
serial-cmd = []
# Bench regression only: injects `M5_TEST_AW_NACK` simulated AW9523B "not ready"
# results into `board::cores3::power_display_reset`, so the cold-boot retry
# recovery (issue #3 companion) is testable without a power cycle (the rig can't
# switch USB VBUS). No effect unless the env var is set at build time; never
# enable in production.
test-fault-inject = []
# Export the `#[panic_handler]` symbol from the BSP (body = io::console::on_panic
# — RTC breadcrumb + best-effort print + halt). Off by default so a consumer can
# provide its own; a binary opts in instead of hand-rolling the one-line wrapper.
panic-handler = []
# Multicore app-core harness (board::run_app_core): parks + starts the APP core
# on an esp-rtos InterruptExecutor with the waiti idle loop, encapsulating the
# park_core JTAG-reset workaround. Pulls esp-rtos (its embassy InterruptExecutor).
multicore = ["dep:esp-rtos"]
# Console serial transport (UART0 / USB-Serial-JTAG): the TX drain + RX half +
# `console::install`'s `Some(serial)` path + the panic transport print. With it
# OFF (R9 production backstop) none of those symbols link: `log!` is a no-op into
# the ring, `install` can only register the backend, and `on_panic` still writes
# the RTC breadcrumb and halts (RWDT recovers) — just with no serial surface.
console-serial = []
# esp-idf application descriptor (`app_desc!`, `app_elf_sha256()`): a fixed,
# ELF-mapped struct (project name/version/build time/ELF content hash) that a
# host can read straight off flash without booting the board. Decoupled from
# `heap` — reading/emitting the descriptor touches no allocator — so a board
# that wants identity reporting but no global heap doesn't have to pull in
# esp-alloc just to get it.
app-desc = ["dep:esp-bootloader-esp-idf"]
# Enforced firmware build identity: `app_desc!()`'s version field becomes the
# consumer's own build-time git descriptor (`M5STACK_CORE_BUILD_MARK`, set by
# the consumer's own `build.rs` — see the `m5stack-core-build` crate) instead
# of plain `CARGO_PKG_VERSION`. The call site never changes; forgetting the
# `build.rs` wiring is a compile error (a missing `env!()`), not a silent gap.
# Off by default — `app_desc!()` keeps today's plain-version behavior.
identity = ["app-desc"]
# Global-heap ownership (the `mem` module): `mem::init_heap(profile, psram)`
# declares the esp-alloc DRAM regions (HIL-proven per-board sizes) so a binary
# never calls `esp_alloc::heap_allocator!` itself. PSRAM-free, so a board with
# no external RAM (or that just doesn't want it) enables only this.
heap = ["dep:esp-alloc", "dep:allocator-api2", "app-desc"]
# External PSRAM heap support (the PSRAM region + the `psram_box`/`psram_vec`
# checked allocators). Implies `heap`. Enabling it activates a build-time guard
# requiring opt-level > 0 (build.rs) and the compile-time `PsramSafe` atomic
# check (uses the `esp` nightly auto-trait features).
psram = ["heap"]
# On-board ILI9342C panel bring-up (board::display) and the display/SD-card
# device construction on the shared SPI2 bus (board::spi2::Spi2Parts::finish).
display = ["dep:lcd-async", "dep:embassy-embedded-hal"]
# Debounced front-panel button driver (io::buttons::Buttons, Fire27 hardware).
# The unified ButtonEvent types and the CoreS3 touch emulation need no feature.
buttons = ["dep:async-button", "dep:embassy-time-04"]

# --- Radio (driver::radio) — orthogonal to the chip features; combine per app.
# The radio is shared, so `coex` is required to run BLE and WiFi at once.
ble      = ["esp-radio/ble"]                                  # driver::radio::ble (BleRadio → BleConnector)
wifi     = ["esp-radio/wifi"]                                 # driver::radio::wifi (controller + scan)
wifi-sta = ["wifi", "dep:embassy-net"] # STA + DHCP embassy_net::Stack
wifi-ap  = ["wifi", "dep:embassy-net"] # reserved for AP mode (not yet implemented)
coex     = ["esp-radio/coex", "wifi", "ble"]                  # software WiFi/BLE coexistence (extra RAM)

# --- Example-only (`ex-*`) — never enable these in an application ------------
# They exist because `required-features` can only *gate* an example, never turn
# anything on: the examples in `examples/` need library features (and chip
# features on the dev-dependencies) that no application should inherit. `ex-*`
# forces `panic-handler` and `console-serial` on, which a real application
# provides itself — enabling them downstream is a duplicate-symbol error, not a
# preference.
#
# They gate *code*, not dependencies: Cargo forbids optional dev-dependencies,
# so oxivgl/sdspi/trouble-host are built for any example target regardless.
# That is why building even a light example pays the LVGL C build once.
# `esp-rtos/esp-radio` is what registers the `esp_rtos_semaphore_*` symbols that
# oxivgl's blocking flush wait links against — without it every example fails to
# link, not just the LVGL ones, because oxivgl is an unconditional dev-dep.
ex-common = [
    "display", "psram", "wifi-sta", "console-serial", "panic-handler", "app-desc",
    "dep:esp-rtos", "esp-rtos/embassy", "esp-rtos/esp-radio",
    "esp-alloc/internal-heap-stats",
]
ex-fire27 = [
    "ex-common", "fire27", "buttons",
    "esp-rtos/esp32", "esp-sync/esp32", "esp-bootloader-esp-idf/esp32",
]
ex-cores3 = [
    "ex-common", "cores3",
    "esp-rtos/esp32s3", "esp-rtos/log-04",
    "esp-sync/esp32s3", "esp-sync/log-04",
    "esp-bootloader-esp-idf/esp32s3",
    "embassy-executor/log", "embassy-time/log",
]
# Per-example extras, named by `required-features` on the [[example]] entries.
ex-lvgl      = []
ex-sd        = []
ex-coex      = ["coex"]
ex-multicore = ["multicore"]
ex-probes    = []
# Scheduling variants of the lvgl_sched harness (#63) — see docs/lvgl-ui-performance.md.
ex-ui-thread       = []
ex-ui-flush-thread = ["ex-ui-thread"]
ex-ui-app-core     = ["ex-ui-flush-thread"]

[dependencies]
# esp-hal family — stock crates.io versions so the crate publishes. The whole
# family is version-locked together, so they are pinned exactly; local and
# example builds are redirected to the emobotics fork (a coherent snapshot of
# the same versions, plus SPI/DMA patches the examples need) via the rev-pinned
# [patch.crates-io] below, which `cargo publish` ignores.
esp-alloc           = { version = "=0.10.0", optional = true }
esp-hal             = { version = "=1.1.2", features = ["unstable"] }
esp-radio           = { version = "=0.18.0", features = ["esp-alloc", "unstable"] }
esp-sync            = { version = "=0.2.1" }
# Bootloader integration — needed only by the `heap` feature: `init_heap`'s
# `#[ram(reclaimed)]` region requires the esp-idf bootloader crate in the graph
# (it also backs the future `app_desc!`). Stock for publish; patched to the fork
# below for local/example builds so it unifies with the examples' copy (a
# `links` crate must resolve to a single version).
esp-bootloader-esp-idf = { version = "=0.5.0", optional = true }
# Multicore harness only (board::run_app_core): esp-rtos's embassy
# InterruptExecutor. Stock for publish, patched to the fork below for local
# builds so it unifies with the examples' copy.
esp-rtos             = { version = "=0.3.0", optional = true, features = ["embassy"] }
# Pinned (and referenced via `use esp_rom_sys as _` in lib.rs so it survives
# `cargo package`): esp-hal 1.1.0 calls esp_rom_sys::init_syscall_table, added
# in 0.1.4, but only constrains it to ~0.1 — without this pin a stock resolve
# drifts to 0.1.1 (which lacks the function) and esp-hal fails to compile.
esp-rom-sys         = { version = "=0.1.4" }

# embedded-hal family
embedded-hal        = "1.0.0"
# Async SPI traits. Already an implicit dependency — `SpiDeviceWithConfig`
# implements them — but `board::spi2`'s fair device wrapper names them directly,
# so the edge has to be explicit rather than borrowed from a dev-dependency.
embedded-hal-async  = "1"
embedded-io-async   = "0.7.0"

# Embassy
embassy-executor    = { version = "0.10.0", features = ["nightly"] }
embassy-futures     = "0.1"
embassy-net         = { version = "0.9.1", optional = true, default-features = false, features = ["dhcpv4", "proto-ipv4", "medium-ethernet", "tcp", "udp", "dns"] }
embassy-sync        = "0.8"
embassy-time        = "0.5.1"

# misc
# Held at 0.3: esp-alloc 0.10 implements allocator-api2 0.3's `Allocator` for its
# Internal/ExternalMemory; 0.4 is a different trait version → tied to the esp stack.
allocator-api2      = { version = "0.3.0", default-features = false, features = ["alloc"], optional = true }
async-button        = { version = "0.2.0", optional = true }
# async-button 0.2 pins embassy-time 0.4; alias it so we can name that `Duration`
# to build `ButtonConfig` timings from milliseconds (the BSP itself is on 0.5).
embassy-time-04     = { package = "embassy-time", version = "0.4", optional = true }
embassy-embedded-hal = { version = "0.6.0", optional = true, features = ["time"] }
# Held at 1.29: 1.30+ requires `az ~1.3`, conflicting with embedded-graphics 0.8's
# `az ~1.2` pin.
fixed               = "1.29.0"
lcd-async           = { version = "0.1.3", optional = true }
heapless            = { version = "0.9.3", features = ["nightly"] }
log                 = "0.4"
static_cell         = { version = "2.1.1", features = ["nightly"] }
thiserror-no-std    = "2.0.2"

# Local/example builds only: redirect the esp-hal family the library declares
# (stock, above) to the emobotics fork at a pinned rev — a coherent snapshot of
# those versions with the SPI/DMA patches the examples need. Pinned to a rev,
# not the floating `local` branch, so builds are reproducible. `cargo publish`
# ignores [patch], so downstream consumers resolve the stock crates.io versions.
[patch.crates-io]
esp-hal     = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-radio   = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-sync    = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-alloc   = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-rom-sys = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-bootloader-esp-idf = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-rtos    = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
# oxivgl's `rtos-sem` asks for the crates.io release; the examples use the fork.
# Without this they resolve to two crates and the semaphore handle oxivgl returns
# is a different type from the one esp-rtos registers.
esp-radio-rtos-driver = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }

[workspace]
# `m5stack-core-build` is a HOST crate, and a member — including an implicit one,
# which a path dependency otherwise becomes — is built for the workspace's
# target. So every `--workspace` command carrying a board target compiled it for
# Xtensa and died on missing `std`; rust-analyzer's build-script pass is one such
# command, and reported it only as "failed to run build scripts". Excluding it
# costs nothing: this crate still uses it as an optional build-dependency, and
# build dependencies are compiled for the host regardless.
exclude = ["m5stack-core-build"]

# Shared example dependencies — referenced by the example crates via
# `<dep>.workspace = true` so the esp-hal fork rev (and the rest) is stated
# once. Chip features (esp32/esp32s3) and `optional` are applied per-member.
# The library itself (above) does NOT use these — it depends on stock crates.io
# esp-hal redirected by [patch.crates-io]; the examples pull fork crates that
# are not on the patch list (esp-rtos, esp-bootloader-esp-idf, esp-backtrace,
# esp-println), so they declare the fork explicitly.
# --- Example targets ---------------------------------------------------------
# Auto-discovery finds every `examples/*.rs` and `examples/*/main.rs`;
# `examples/common/` has no `main.rs`, so cargo ignores it and it serves as the
# shared framework (each example pulls it in with `#[path] mod common;`).
# These entries exist only to add `required-features` — the paths are the ones
# cargo would infer anyway.
#
# Every example additionally needs a board aggregate on the command line:
#   cargo build --examples --features ex-fire27
#   cargo build --examples --no-default-features --features ex-cores3 \
#       --target xtensa-esp32s3-none-elf

[[example]]
name = "display"
path = "examples/display.rs"

[[example]]
name = "i2c_scan"
path = "examples/i2c_scan.rs"

[[example]]
name = "m5go"
path = "examples/m5go.rs"

[[example]]
name = "wifi_sta"
path = "examples/wifi_sta.rs"

[[example]]
name = "psram_split"
path = "examples/psram_split.rs"

[[example]]
name = "onewire"
path = "examples/onewire.rs"
required-features = ["fire27"]

[[example]]
name = "lvgl"
path = "examples/lvgl/main.rs"
required-features = ["ex-lvgl"]

[[example]]
name = "lvgl_threads"
path = "examples/lvgl_threads.rs"
required-features = ["ex-lvgl"]

[[example]]
name = "lvgl_sched"
path = "examples/lvgl_sched/main.rs"
required-features = ["ex-lvgl"]

[[example]]
name = "sd"
path = "examples/sd.rs"
required-features = ["ex-sd"]

[[example]]
name = "coex"
path = "examples/coex.rs"
required-features = ["ex-coex"]

[[example]]
name = "multicore"
path = "examples/multicore.rs"
required-features = ["ex-multicore"]

[[example]]
name = "probe_sd_read"
path = "examples/probe_sd_read.rs"
required-features = ["ex-probes", "ex-sd"]

[[example]]
name = "probe_spi_cmd"
path = "examples/probe_spi_cmd.rs"
required-features = ["ex-probes"]

[[example]]
name = "probe_pps"
path = "examples/probe_pps.rs"
required-features = ["ex-probes"]

[[example]]
name = "probe_gdma_eof"
path = "examples/probe_gdma_eof.rs"
required-features = ["ex-probes", "cores3"]

[[example]]
name = "probe_spi2_gdma_fault"
path = "examples/probe_spi2_gdma_fault.rs"
required-features = ["ex-probes", "cores3"]

[[example]]
name = "probe_dma_int"
path = "examples/probe_dma_int.rs"
required-features = ["ex-probes", "cores3"]

[[example]]
name = "probe_nack"
path = "examples/probe_nack.rs"
required-features = ["ex-probes", "ex-coex"]

# --- Examples ---------------------------------------------------------------
# Everything under `examples/`. These are stripped from the published manifest
# (cargo drops dev-dependencies that carry no `version` key), so the git forks
# here never reach a consumer — verified with `cargo package`.
#
# Cargo forbids `optional = true` on a dev-dependency, so these cannot be
# feature-gated: any example target builds all of them. See the `ex-*` features.
[dev-dependencies]
# Only what the library does not already depend on — a name may not resolve to
# two different sources, and examples can use the package's own [dependencies].
esp-radio-rtos-driver = { workspace = true }
embedded-graphics    = { workspace = true }
trouble-host         = { workspace = true }
# SD: the sdspi/embedded-fatfs fork is git-only (not on crates.io). Examples
# only — it must never reach [dependencies] or the crate stops publishing.
sdspi                 = { git = "https://github.com/emobotics-dev/embedded-fatfs.git", rev = "4565a3e3358e1b03c12b7f1b8c04483facbc45b9", features = ["log"] }
embedded-fatfs        = { git = "https://github.com/emobotics-dev/embedded-fatfs.git", rev = "4565a3e3358e1b03c12b7f1b8c04483facbc45b9", default-features = false, features = ["alloc", "lfn", "log"] }
block-device-adapters = { git = "https://github.com/emobotics-dev/embedded-fatfs.git", rev = "4565a3e3358e1b03c12b7f1b8c04483facbc45b9" }
block-device-driver   = { git = "https://github.com/emobotics-dev/embedded-fatfs.git", rev = "4565a3e3358e1b03c12b7f1b8c04483facbc45b9" }
aligned               = "0.4.2"
embedded-hal-async    = "1"
oxivgl               = { workspace = true }
oxivgl-sys           = { workspace = true }


[workspace.dependencies]
# esp-hal family (emobotics fork, pinned rev)
esp-alloc            = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0", features = ["internal-heap-stats"] }
esp-backtrace        = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0", features = ["panic-handler", "custom-halt", "colors", "println"] }
esp-bootloader-esp-idf = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-hal              = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0", features = ["unstable"] }
esp-println          = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0", features = ["log-04", "colors", "timestamp"], default-features = false }
esp-rtos             = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0", features = ["embassy", "esp-radio"] }
# Native threads and semaphores. esp-rtos exposes neither on its own surface —
# these are the primitives esp-radio's WiFi/BT internals use, registered by
# `esp_rtos::start()`. Examples only: the library must stay crates.io-resolvable.
esp-radio-rtos-driver = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
esp-sync             = { git = "https://github.com/emobotics-dev/esp-hal.git", rev = "04646b65e3ef94d60f5e08cb24fed9e3cd77f9d0" }
# CoreS3 logging/panic (USB-Serial-JTAG)
panic-halt           = "1.0.0"
rtt-target           = { version = "0.6.2", features = ["log"] }
# Embassy
embassy-embedded-hal = { version = "0.6.0", features = ["time"] }
embassy-executor     = { version = "0.10.0", features = ["nightly"] }
embassy-futures      = "0.1"
embassy-net          = { version = "0.9.1", default-features = false, features = ["dhcpv4", "proto-ipv4", "medium-ethernet", "tcp", "udp", "dns"] }
embassy-sync         = "0.8"
embassy-time         = "0.5.1"
# Display
embedded-graphics    = "0.8.2"
lcd-async            = "0.1.3"
# BLE (coex). Held at 0.6 because esp-radio 0.18's BleConnector implements the
# bt-hci **0.8** traits while trouble-host 0.7 requires **0.9**. Verified by
# attempting the bump AND porting the demo, rather than by reading:
#
#   - cargo resolves 0.7 happily and compiles bt-hci 0.8.1 and 0.9.0 side by
#     side (semver-incompatible, so coexisting is legal). It is NOT a
#     resolution failure, which is what makes this worth writing down.
#   - the first errors are trouble-host 0.7's own API changes, and they are a
#     red herring: `HostResources` gained the controller as its FIRST generic
#     (`<C, P, CONNS, CHANNELS, ADV_SETS = 1, BONDS = 10>`), so the old
#     `HostResources<DefaultPacketPool, 1, 1>` put the pool in the controller
#     slot and produced a bogus `StaticPacketPool: ControllerCmdSync` error.
#   - with the port applied (`HostResources<_, DefaultPacketPool, 1, 1>`,
#     `.build()` → `Stack`, then `stack.runner()` / `stack.central()` instead
#     of destructuring a `Host`), the REAL blocker appears and is unambiguous:
#         BleConnector<'_>: bt_hci::transport::Transport is not satisfied
#         BleConnectorError: From<bt_hci::FromHciBytesError> is not satisfied
#           help: expected `bt_hci::FromHciBytesError`,
#                    found `bt_hci::FromHciBytesError`
#     Identical paths on both sides is the two-versions-of-one-crate signature.
#
# So the bump is gated on esp-radio moving to bt-hci 0.9 — nothing on our side
# unblocks it, and the ble.rs port above is the whole of the other half.
#
# And it is esp-RADIO that gates it, not esp-hal: esp-radio 0.18.0 asks for
# `esp-hal ~1.1.0-rc.0`, which 1.1.2 already satisfies. Re-checked 2026-08-22,
# **no published esp-radio uses bt-hci 0.9** — 0.18.0 is the newest stable and
# even the 1.0.0-beta.0 prerelease still requires `bt-hci ^0.8.0` (and
# `esp-hal ~1.1.0`). There is nothing newer to move to yet; re-check esp-radio,
# not esp-hal, when revisiting this.
trouble-host         = { version = "0.6.0", features = ["default-packet-pool-mtu-255", "scan", "derive"] }
# LVGL (lvgl feature, demos only). Taken as a matched pair from one source:
# oxivgl-sys emits `oxivgl_render_scratch_*` C→Rust hooks whose Rust side lives in
# oxivgl, so resolving the two halves separately drifts them apart and the lvgl
# example fails to link (Cargo.lock is gitignored → every fresh resolve).
#
# On crates.io now that 0.8.0 carries `Ui`/`RenderConfig`/`FlushSync` — the git
# pin was only ever a bridge until that release existed. Pinned exactly and as a
# pair: 0.8.0 asks for oxivgl-sys 0.2.4, and the two halves must come from one
# source or the `oxivgl_render_scratch_*` hooks drift apart and the lvgl example
# fails to link.
oxivgl               = { version = "=0.8.0", features = ["esp-hal", "log-04", "rtos-sem"] }
oxivgl-sys           = { version = "=0.2.4", default-features = false }
# misc
embedded-hal         = "1.0.0"
heapless             = "0.9.3"
log                  = "0.4"
static_cell          = { version = "2.1.1", features = ["nightly"] }

[profile.dev]
opt-level = "s"

[profile.release]
codegen-units = 1
debug = 2
debug-assertions = false
incremental = false
lto = "fat"
opt-level = "s"
overflow-checks = true