Google Git
Sign in
opensecura / 3p / tock / libtock-rs / 6271253867a783ed6f2fe7d66c0ae62614515b1b
commit6271253867a783ed6f2fe7d66c0ae62614515b1b[log] [tgz]
authorbors[bot] <26634292+bors[bot]@users.noreply.github.com>Wed Feb 26 22:33:17 2020 +0000
committerGitHub <noreply@github.com>Wed Feb 26 22:33:17 2020 +0000
treee9852a213a5c690e38095e230d202f883e28c77f
parent12dc3d50514a4973cd9a198e7c6fd2686fba3b8c [diff]
parentdc326a4071cf8ffd6ff118102a7447ff16b48826 [diff]
Merge #125

125: Create stream to stream events from ble scanning functionality merge after #122 r=Woyten a=torfmaster

# Summary
In this PR I migrate the ble scanning funtionality from callbacks to `futures::stream::Streams`. 
Only merge after #122 

# Questions/Help needed

 * I decided to make the `BleScanningDriverScanning::stream_values` method to consume `&self` instead of `&mut self`. While I think this is correct it may lead to unexpected behavior when two parallel Tasks consume this stream, i.e. the events are split between the consumers
 * I only implemented infinite streams as the stream of ble events will be either be stopped at runtime (to a point of time predictable at compile time) or continue to produce values forever.
 * I removed the possibilty of registering callbacks to the ble driver directly as for me it seemed to be only feasible for trivial business logic.

Co-authored-by: torfmaster <briefe@kebes.de>
tree: e9852a213a5c690e38095e230d202f883e28c77f
  1. .cargo/
  2. .vscode/
  3. async-support/
  4. codegen/
  5. doc/
  6. examples/
  7. examples-alloc/
  8. src/
  9. .gitignore
  10. .travis.yml
  11. bors.toml
  12. build.rs
  13. build_examples.sh
  14. Cargo.toml
  15. CHANGELOG.md
  16. CONTRIBUTING.md
  17. flash.sh
  18. layout_generic.ld
  19. layout_hail.ld
  20. layout_nrf52.ld
  21. layout_nrf52840.ld
  22. layout_opentitan.ld
  23. layout_riscv32.ld
  24. LICENSE-APACHE
  25. LICENSE-MIT
  26. README.md
  27. run_all_checks.sh
  28. rust-toolchain
  29. rustfmt.toml
README.md

Build Status

libtock-rs

Rust userland library for Tock (WIP)

Tested with tock Release 1.4.1.

The library works in principle on most boards, but there is currently the showstopper bug #28 that prevents the generation of relocatable code. This means that all applications must be installed at the flash address they are compiled with, which usually means that they must be compiled especially for your board and that there can only be one application written in rust at a time and it must be installed as the first application on the board, unless you want to play games with linker scripts. There are some layout_*.ld files provided that allow to run the examples on common boards. Due to MPU region alignment issues they may not work for applications that use a lot of RAM, in that case you may have to change the SRAM start address to fit your application.

Getting Started

This project is nascent and still under heavy development, but first steps:

  1. Ensure you have rustup installed.

  2. Clone the repository:

    git clone https://github.com/tock/libtock-rs
cd libtock-rs

  3. Install elf2tab:

    cargo install -f elf2tab --version 0.4.0

  4. Add dependencies for cross-compilation. Currently, only few platforms have been configured, e.g.:

    rustup target add thumbv7em-none-eabi # For an nRF52 DK board

    rustup target add riscv32imc-unknown-none-elf # For an OpenTitan board

  5. Use cargo r<arch> to compile and run an example app. The full command is platform dependent and looks as follows for the blink example:

    PLATFORM=nrf52 cargo rthumbv7em blink # For an nRF52 DK board

    PLATFORM=opentitan cargo rriscv32imc blink # For an OpenTitan board

    For an unknown platform, you may have to create your own memory layout definition. Place the layout definition file at layout_<platform>.ld and do not forget to enhance the tockloader_flags dispatching section in flash.sh. You are welcome to create a PR, s.t. the number of supported platforms grows.

Using libtock-rs

The easiest way to start using libtock-rs is adding an example to the examples folder. The boiler plate code you would write is

#![no_std]

use libtock::result::TockResult;

#[libtock::main]
async fn main() -> TockResult<()> {
  // Your code
}

If you want to use heap based allocation you will have to add

extern crate alloc;

to the preamble and store your example in the examples-alloc folder.

To run on the code on your board you can use

PLATFORM=<platform> cargo r<arch> <your_app> [--features=alloc]

This script does the following steps for you:

  • cross-compile your program
  • create a TAB (tock application bundle)
  • if you have a J-Link compatible board connected: flash this TAB to your board (using tockloader)

Instead of specifying an environment variable each time you can permanently configure your platform by writing its name into a file named platform, e.g.

echo nrf52 > platform

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

The contribution guidelines can be found here: contribution guidelines