mirror of
https://github.com/embassy-rs/embassy.git
synced 2024-11-22 14:53:03 +00:00
234 lines
11 KiB
Plaintext
234 lines
11 KiB
Plaintext
= Frequently Asked Questions
|
|
|
|
These are a list of unsorted, commonly asked questions and answers.
|
|
|
|
Please feel free to add items to link:https://github.com/embassy-rs/embassy/edit/main/docs/modules/ROOT/pages/faq.adoc[this page], especially if someone in the chat answered a question for you!
|
|
|
|
== How to deploy to RP2040 without a debugging probe.
|
|
|
|
Install link:https://github.com/JoNil/elf2uf2-rs[elf2uf2-rs] for converting the generated elf binary into a uf2 file.
|
|
|
|
Configure the runner to use this tool, add this to `.cargo/config.toml`:
|
|
[source,toml]
|
|
----
|
|
[target.'cfg(all(target_arch = "arm", target_os = "none"))']
|
|
runner = "elf2uf2-rs --deploy --serial --verbose"
|
|
----
|
|
|
|
The command-line parameters `--deploy` will detect your device and upload the binary, `--serial` starts a serial connection. See the documentation for more info.
|
|
|
|
== Missing main macro
|
|
|
|
If you see an error like this:
|
|
|
|
[source,rust]
|
|
----
|
|
#[embassy_executor::main]
|
|
| ^^^^ could not find `main` in `embassy_executor`
|
|
----
|
|
|
|
You are likely missing some features of the `embassy-executor` crate.
|
|
|
|
For Cortex-M targets, check whether ALL of the following features are enabled in your `Cargo.toml` for the `embassy-executor` crate:
|
|
|
|
* `arch-cortex-m`
|
|
* `executor-thread`
|
|
|
|
For ESP32, consider using the executors and `#[main]` macro provided by your appropriate link:https://crates.io/crates/esp-hal-common[HAL crate].
|
|
|
|
== Why is my binary so big?
|
|
|
|
The first step to managing your binary size is to set up your link:https://doc.rust-lang.org/cargo/reference/profiles.html[profiles].
|
|
|
|
[source,toml]
|
|
----
|
|
[profile.release]
|
|
lto = true
|
|
opt-level = "s"
|
|
incremental = false
|
|
codegen-units = 1
|
|
# note: debug = true is okay - debuginfo isn't flashed to the device!
|
|
debug = true
|
|
----
|
|
|
|
All of these flags are elaborated on in the Rust Book page linked above.
|
|
|
|
=== My binary is still big... filled with `std::fmt` stuff!
|
|
|
|
This means your code is sufficiently complex that `panic!` invocation's formatting requirements could not be optimized out, despite your usage of `panic-halt` or `panic-reset`.
|
|
|
|
You can remedy this by adding the following to your `.cargo/config.toml`:
|
|
|
|
[source,toml]
|
|
----
|
|
[unstable]
|
|
build-std = ["core"]
|
|
build-std-features = ["panic_immediate_abort"]
|
|
----
|
|
|
|
This replaces all panics with a `UDF` (undefined) instruction.
|
|
|
|
Depending on your chipset, this will exhibit different behavior.
|
|
|
|
Refer to the spec for your chipset, but for `thumbv6m`, it results in a hardfault. Which can be configured like so:
|
|
|
|
[source,rust]
|
|
----
|
|
#[exception]
|
|
unsafe fn HardFault(_frame: &ExceptionFrame) -> ! {
|
|
SCB::sys_reset() // <- you could do something other than reset
|
|
}
|
|
----
|
|
|
|
Refer to cortex-m's link:https://docs.rs/cortex-m-rt/latest/cortex_m_rt/attr.exception.html[exception handling] for more info.
|
|
|
|
== `embassy-time` throws linker errors
|
|
|
|
If you see linker error like this:
|
|
|
|
[source,text]
|
|
----
|
|
= note: rust-lld: error: undefined symbol: _embassy_time_now
|
|
>>> referenced by driver.rs:127 (src/driver.rs:127)
|
|
>>> embassy_time-846f66f1620ad42c.embassy_time.4f6a638abb75dd4c-cgu.0.rcgu.o:(embassy_time::driver::now::hefb1f99d6e069842) in archive Devel/Embedded/pogodyna/target/thumbv7em-none-eabihf/debug/deps/libembassy_time-846f66f1620ad42c.rlib
|
|
|
|
rust-lld: error: undefined symbol: _embassy_time_allocate_alarm
|
|
>>> referenced by driver.rs:134 (src/driver.rs:134)
|
|
>>> embassy_time-846f66f1620ad42c.embassy_time.4f6a638abb75dd4c-cgu.0.rcgu.o:(embassy_time::driver::allocate_alarm::hf5145b6bd46706b2) in archive Devel/Embedded/pogodyna/target/thumbv7em-none-eabihf/debug/deps/libembassy_time-846f66f1620ad42c.rlib
|
|
|
|
rust-lld: error: undefined symbol: _embassy_time_set_alarm_callback
|
|
>>> referenced by driver.rs:139 (src/driver.rs:139)
|
|
>>> embassy_time-846f66f1620ad42c.embassy_time.4f6a638abb75dd4c-cgu.0.rcgu.o:(embassy_time::driver::set_alarm_callback::h24f92388d96eafd2) in archive Devel/Embedded/pogodyna/target/thumbv7em-none-eabihf/debug/deps/libembassy_time-846f66f1620ad42c.rlib
|
|
|
|
rust-lld: error: undefined symbol: _embassy_time_set_alarm
|
|
>>> referenced by driver.rs:144 (src/driver.rs:144)
|
|
>>> embassy_time-846f66f1620ad42c.embassy_time.4f6a638abb75dd4c-cgu.0.rcgu.o:(embassy_time::driver::set_alarm::h530a5b1f444a6d5b) in archive Devel/Embedded/pogodyna/target/thumbv7em-none-eabihf/debug/deps/libembassy_time-846f66f1620ad42c.rlib
|
|
----
|
|
|
|
You probably need to enable a time driver for your HAL (not in `embassy-time`!). For example with `embassy-stm32`, you might need to enable `time-driver-any`:
|
|
|
|
[source,toml]
|
|
----
|
|
[dependencies.embassy-stm32]
|
|
version = "0.1.0"
|
|
features = [
|
|
# ...
|
|
"time-driver-any", # Add this line!
|
|
# ...
|
|
]
|
|
----
|
|
|
|
If you are in the early project setup phase and not using anything from the HAL, make sure the HAL is explicitly used to prevent the linker removing it as dead code by adding this line to your source:
|
|
|
|
[source,rust]
|
|
----
|
|
use embassy_stm32 as _;
|
|
----
|
|
|
|
== Error: `Only one package in the dependency graph may specify the same links value.`
|
|
|
|
You have multiple versions of the same crate in your dependency tree. This means that some of your
|
|
embassy crates are coming from crates.io, and some from git, each of them pulling in a different set
|
|
of dependencies.
|
|
|
|
To resolve this issue, make sure to only use a single source for all your embassy crates!
|
|
To do this, you should patch your dependencies to use git sources using `[patch.crates.io]`
|
|
and maybe `[patch.'https://github.com/embassy-rs/embassy.git']`.
|
|
|
|
Example:
|
|
|
|
[source,toml]
|
|
----
|
|
[patch.crates-io]
|
|
embassy-time-queue-driver = { git = "https://github.com/embassy-rs/embassy.git", rev = "e5fdd35" }
|
|
embassy-time-driver = { git = "https://github.com/embassy-rs/embassy.git", rev = "e5fdd35" }
|
|
# embassy-time = { git = "https://github.com/embassy-rs/embassy.git", rev = "e5fdd35" }
|
|
----
|
|
|
|
Note that the git revision should match any other embassy patches or git dependencies that you are using!
|
|
|
|
== How can I optimize the speed of my embassy-stm32 program?
|
|
|
|
* Make sure RCC is set up to go as fast as possible
|
|
* Make sure link:https://docs.rs/cortex-m/latest/cortex_m/peripheral/struct.SCB.html[flash cache] is enabled
|
|
* build with `--release`
|
|
* Set the following keys for the release profile in your `Cargo.toml`:
|
|
** `opt-level = "s"`
|
|
** `lto = "fat"`
|
|
* Set the following keys in the `[unstable]` section of your `.cargo/config.toml`
|
|
** `build-std = ["core"]`
|
|
** `build-std-features = ["panic_immediate_abort"]`
|
|
* Enable feature `embassy-time/generic-queue`, disable feature `embassy-executor/integrated-timers`
|
|
* When using `InterruptExecutor`:
|
|
** disable `executor-thread`
|
|
** make `main`` spawn everything, then enable link:https://docs.rs/cortex-m/latest/cortex_m/peripheral/struct.SCB.html#method.set_sleeponexit[SCB.SLEEPONEXIT] and `loop { cortex_m::asm::wfi() }`
|
|
** *Note:* If you need 2 priority levels, using 2 interrupt executors is better than 1 thread executor + 1 interrupt executor.
|
|
|
|
== How do I set up the task arenas on stable?
|
|
|
|
When you aren't using the `nightly` feature of `embassy-executor`, the executor uses a bump allocator, which may require configuration.
|
|
|
|
Something like this error will occur at **compile time** if the task arena is *too large* for the target's RAM:
|
|
|
|
[source,plain]
|
|
----
|
|
rust-lld: error: section '.bss' will not fit in region 'RAM': overflowed by _ bytes
|
|
rust-lld: error: section '.uninit' will not fit in region 'RAM': overflowed by _ bytes
|
|
----
|
|
|
|
And this message will appear at **runtime** if the task arena is *too small* for the tasks running:
|
|
|
|
[source,plain]
|
|
----
|
|
ERROR panicked at 'embassy-executor: task arena is full. You must increase the arena size, see the documentation for details: https://docs.embassy.dev/embassy-executor/'
|
|
----
|
|
|
|
NOTE: If all tasks are spawned at startup, this panic will occur immediately.
|
|
|
|
Check out link:https://docs.embassy.dev/embassy-executor/git/cortex-m/index.html#task-arena[Task Arena Documentation] for more details.
|
|
|
|
== Can I use manual ISRs alongside Embassy?
|
|
|
|
Yes! This can be useful if you need to respond to an event as fast as possible, and the latency caused by the usual “ISR, wake, return from ISR, context switch to woken task” flow is too much for your application. Simply define a `#[interrupt] fn INTERRUPT_NAME() {}` handler as you would link:https://docs.rust-embedded.org/book/start/interrupts.html[in any other embedded rust project].
|
|
|
|
== How can I measure resource usage (CPU, RAM, etc.)?
|
|
|
|
=== For CPU Usage:
|
|
|
|
There are a couple techniques that have been documented, generally you want to measure how long you are spending in the idle or low priority loop.
|
|
|
|
We need to document specifically how to do this in embassy, but link:https://blog.japaric.io/cpu-monitor/[this older post] describes the general process.
|
|
|
|
If you end up doing this, please update this section with more specific examples!
|
|
|
|
=== For Static Memory Usage
|
|
|
|
Tools like `cargo size` and `cargo nm` can tell you the size of any globals or other static usage. Specifically you will want to see the size of the `.data` and `.bss` sections, which together make up the total global/static memory usage.
|
|
|
|
=== For Max Stack Usage
|
|
|
|
Check out link:https://github.com/Dirbaio/cargo-call-stack/[`cargo-call-stack`] for statically calculating worst-case stack usage. There are some caveats and inaccuracies possible with this, but this is a good way to get the general idea. See link:https://github.com/dirbaio/cargo-call-stack#known-limitations[the README] for more details.
|
|
|
|
== The memory definition for my STM chip seems wrong, how do I define a `memory.x` file?
|
|
|
|
It could happen that your project compiles, flashes but fails to run. The following situation can be true for your setup:
|
|
|
|
The `memory.x` is generated automatically when enabling the `memory-x` feature on the `embassy-stm32` crate in the `Cargo.toml` file.
|
|
This, in turn, uses `stm32-metapac` to generate the `memory.x` file for you. Unfortunately, more often than not this memory definition is not correct.
|
|
|
|
You can override this by adding your own `memory.x` file. Such a file could look like this:
|
|
```
|
|
MEMORY
|
|
{
|
|
FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K
|
|
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 320K
|
|
}
|
|
|
|
_stack_start = ORIGIN(RAM) + LENGTH(RAM);
|
|
```
|
|
|
|
Please refer to the STM32 documentation for the specific values suitable for your board and setup. The STM32 Cube examples often contain a linker script `.ld` file.
|
|
Look for the `MEMORY` section and try to determine the FLASH and RAM sizes and section start.
|
|
|
|
If you find a case where the memory.x is wrong, please report it on [this Github issue](https://github.com/embassy-rs/stm32-data/issues/301) so other users are not caught by surprise.
|