Skip to content

Instantly share code, notes, and snippets.

@skade skade/Oxidize impl days.md Secret
Created May 8, 2019

Embed
What would you like to do?

Oxidize impl days

https://tinyurl.com/oxidizeimpl

Venues

Co.up Adalbertstraße 7 Ferrous Systems Office Ohlauer Straße 43

Tools

Tool Who
Saleae 8ch Logic Anylizer for non-commercial useText Luciano Moretti
JLink-EDU Probe Luciano Moretti
JLink-Ultra+ Michał Fita

Projects

Multi-core support for RISC-V

Trying to use both cores on Kendryte K210.

There are two major problems:

  • K210 openocd does not support any interaction with second core
  • flashing utility behaves in a bad way: firmware is not uploaded consistently, resulting in a mix of old and new code chunks

Additionally, due to inability to start execution on the second core in gdb, the only possible way of using both cores -- starting from the SPI flash. This approach requires a hack in riscv-rt with additional jump from 0x8000_0000 to 0x4000_0000 upon entry (by default, bootrom code starts execution of firmware from 0x8000_0000).

Approach with parking and then waking up via CLINT was implemented. Firmware actually boots on both cores, but crashes in a different ways due to an inconsistency of firmware image.

-Vadim

Running Rust on RIOT on RISC-V

Should work out of the box, shouldn't it?

We've stumbled over some stones on the way, but nothing major -- the largest issues were finding the right toolchain and setting a few flags here and there.

First Rust code was executed on a HiFive1 board running on RIOT-OS at on 2019-05-28 at 11:35 local time! Multi-threaded execution followed soon after.

The riot-examples now all run on the hifive1 board out of the box, assisted by updates to the riot-sys crate. Installation of adaequate GCC and OpenOCD is manual and may require adding lines to the Makefile, but that is explained in the examples' README.

--Christian (chrysn), Vadim (Disasm)

Monotron! (github.com/thejpster, @therealjpster)

An 8-bit style home computer built out of a Cortex-M4 microcontroller. 32 KiB RAM, 256 KiB flash, 400x600 @ 60 Hz VGA.

I have two boards available. You can write applications in C or Rust and load them into RAM over Serial or from the SD card. Or you can hack on the kernel - sprites? better audio synth? Rust code for the Atmel keyboard controller?

See github.com/thejpster/monotron/issues and github.com/thejpster/monotron-apps/issues

SUCCESS - we managed to fix the interrupt routines that control the video and massively reduce the timing jitter when running code in a tight loop (e.g. when running BASIC). I then went on to look at the file system API.

-- Jonathan 'theJPster' Pallant

USB on STM32L432

SoloKeys makes open source security keys (USB + NFC, FIDO2 and soon PGP/PKCS#11), unfortunately in C so far. Also unfortunately, no USB device drivers available so far. https://github.com/solokeys/solo-bsc/issues/1

Want to get the basics (CDC, HID) to run, using

Stretch goal is "via RTFM" :)

I have some keys I can distribute.

-- Nicolas 'nickray' Stalder

ed25519 on Cortex-M4

Cortex-M4 has constant time operations allowing efficient Curve25519 field operations: https://github.com/BjoernMHaase/fe25519 (more links).

The goal would be to get NaCl running with these.

-- Nicolas 'nickray' Stalder

probe-rs (link text)

Rust native ARM (for now) debug support for various probes (ST-Link, JLink, you name it).

We are aiming to have a (near) complete ARM ADIv5.2 lib to flash, debug, inspect, trace ARM chips from any Rust application with future possibility of cargo integration.

Looking for folks interested in the idea, discussing solutions, writing code.

-- Noah 'Yatekii' Hüsser

Standardized Protocol Generation

A lot of protocols such as Zigbee, Bluetooth, etc. require a byte/bit level protocol which needs to be translated into Rust types. Instead of every project implementing its own, I would love to discuss ideas and possibilities and the different implementations that already exist and aim for a proc-macro based library that can automatically generated a protocol specific Rust API to parse, sanitize and build packets.

-- Noah 'Yatekii' Hüsser

Network abstractions in the style of embedded-hal

Now that there are a few network libraries around (smoltcp, jnet, RIOT), maybe it's time to introduce traits at some points. What should those points be? "A truncatable network buffer", possibly with lower-level address data? "A readable and a writable CoAP message"?

(Not particularly followed up on during impl days; from some small chats, next steps would be just to sketch something up for myself and others to toy with, without trying to build the ultimate solution.)

--Christian (chrysn)

Internet of Streams

I've been working on building an open source sensor network based on the DWM1001-DEV board (the one from the workshops on Friday). This work has been streamed online, and aims to be a good example of a growing set of embedded Rust applications.

I'll be working on some things today, including:

  • Updating Internet of Streams to use the new nrf52-hal 0.8.0 release
  • Adding support for the Rubble bluetooth stack to the boards

If you have a DWM1001 from the workshop, come work with me and let's get some boards talking to eachother!

-- James Munns

ATSAMS70Q21

Bringing up board based on Atmel/Microchip ATSAMS70Q21 in preparation for HAL development.

-- Michał Fita

Rust Anywhere

Develop your application logic without being tied down by hardware by creating a hardware simulator using desktop UI widgets. Our project shows a pattern to build application code and integrate it into a desktop simulator, or into a binary to be flashed onto hardware.

https://github.com/junelife/rust-anywhere

Micromath: Embedded arithmetic, vector, and statistics library

https://github.com/NeoBirth/micromath

The accelerometer crate contains the beginnings of an advanced embedded arithmetic library featuring fast, safe floating point approximations for common arithmetic operations, 2D and 3D vector types, and statistical analysis, which is useful for many more things than just accelerometers.

Impl day goal: extract the generally useful math parts out into a new crate: micromath. The goal is to use fast, state-of-the-art approximations which sacrifice precision for performance (as opposed to the libm crate, which is high precision but uses FPU-intensive operations)

RESULT: RELEASED!!! https://crates.io/crates/micromath

-- Tony Arcieri

Rust on the Adafruit PyPortal (ATSAMD51J20)

The PyPortal is a touchscreen SAMD51 device with WiFi (Espressif ESP32). Help us port Rust to it for the first time!

RESULT: SUCCESS!!! https://github.com/atsamd-rs/atsamd/pull/55

-- Tony Arcieri and Shella Stephens

Rust on the Adafruit PyPortal Part II: ILI9341 display controller support

We got Rust ported to the PyPortal yesterday. Today we'd like to attempt to control the ILI9341 TFT LCD chip in order to use the device's built-in display.

There is a Rust crate for it here:

https://github.com/yuri91/ili9341-rs

There is also a WIP branch on the atsamd-rs project which attempts to add ADC support:

https://github.com/sajattack/atsamd/commit/d6e4ed5163846c401ae4feb32694330b4d4e80c2

There's something not quite right though. Via the upstream maintainer:

I'm not getting all zeroes anymore, but I'm not getting good readings either

If there's anyone around with a logic analyzer, we could use help debugging the ADC. (NOTE: we're not quite ready yet. This afternoon?)

-- Tony Arcieri and Shella Stephens

RESULT: Stuck on ILI9341 display bus support. Opened an upstream issue here: https://github.com/yuri91/ili9341-rs/issues/2

esp32spi crate

Goal: Write a crate for communicating with the Espressif ESP32 Wi-Fi coprocessor via the SPI interface. We can port the AdaFruit CircuitPython crate to Rust:

https://github.com/adafruit/Adafruit_CircuitPython_ESP32SPI

-- Tony Arcieri

Try to put Embedded-Hal into Tock

Tock has its own HIL but I'd like to see how quickly we can switch it out for embedded-hal. I'll be first bringing up the CC1352 with embedded-hal but if someone wants to leap ahead with their nrf52 knowledge, I'd be happy to support.

-- Louis Thiery

Bitcoin/Lightning Network Vending Machine

Porting my Snacks Vending Machine Project from Python running on a Raspberry Pi Zero to an Embedded Rust project. Need help choosing appropriate hardware.

Demo Python Code

-- Fabian Jahr

IPv6 SLAAC for smoltcp

IPv6 autoconfiguration shall get your networked device an address so that it can be reached from anywhere in the world.

astro

Serial over BLE

There are a few unoffical implementations of Bluetooth Classic serial ports over BLE. These are Nordic UART Service and connectBlue SSP. The Nordic version seems to be more popular and supported by hardware. Might be worth using as an example for Rubble.

-- Tristan Lostroh

Rust running on an STM32F302R8 Nucleo Board

Managed to get Rust running on the STM32F302R8 Nucleo Board that I have. It only blinks the LED but it does run. (https://github.com/tl8roy/stm32f302r8_rust)

-- Tristan Lostroh

Misc

I have a spare transit ticket if anyone wants it (edit: placed it on the table by the fridge)- Luciano Moretti

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.