Home / Rust / Embedded

ruduino ^`^t Reusable components for the Arduino Uno.

Ruduino This library provides a set of reusable components for the Arduino Uno. Overview Register and bit definitions use ruduino::PORTB; // Register
Information
Category: Rust / Embedded
Watchers: 28
Star: 629
Fork: 45
Last update: Jun 7, 2023
Resource links
https://github.com/avr-rust/ruduino

Ruduino

This library provides a set of reusable components for the Arduino Uno.

Overview

Register and bit definitions

use ruduino::PORTB; // Register
use ruduino::PORTB7; // Pin

Prelude

Disable interrupts.

without_interrupts(|| {
    unsafe { write_volatile(DDRB, 0xFF) }
})

Timers

Configure a timer.

const CPU_FREQUENCY_HZ: u64 = 16_000_000;
const DESIRED_HZ_TIM1: f64 = 2.0;
const TIM1_PRESCALER: u64 = 1024;
const INTERRUPT_EVERY_1_HZ_1024_PRESCALER: u16 =
    ((CPU_FREQUENCY_HZ as f64 / (DESIRED_HZ_TIM1 * TIM1_PRESCALER as f64)) as u64 - 1) as u16;

timer1::Timer::new()
    .waveform_generation_mode(timer1::WaveformGenerationMode::ClearOnTimerMatchOutputCompare)
    .clock_source(timer1::ClockSource::Prescale1024)
    .output_compare_1(Some(INTERRUPT_EVERY_1_HZ_1024_PRESCALER))
    .configure();

Set up an interrupt handler that will be called when the timer fires.

#[no_mangle]
pub unsafe extern "avr-interrupt" fn _ivr_timer1_compare_a() {
    let prev_value = read_volatile(PORTB);
    write_volatile(PORTB, prev_value ^ PINB5);
}

Hardware Serial Port

Configure the serial port.

const CPU_FREQUENCY_HZ: u64 = 16_000_000;
const BAUD: u64 = 9600;
const UBRR: u16 = (CPU_FREQUENCY_HZ / 16 / BAUD - 1) as u16;

serial::Serial::new(UBRR)
    .character_size(serial::CharacterSize::EightBits)
    .mode(serial::Mode::Asynchronous)
    .parity(serial::Parity::Disabled)
    .stop_bits(serial::StopBits::OneBit)
    .configure();

Transmit a sequence of bytes.

for &b in b"OK" {
    serial::transmit(b);
}

Read a byte if there's something available.

if let Some(b) = serial::try_receive() {
    serial::transmit(b);
    serial::transmit(b);
}
19 Open More issues
Closed

Write trait doesn't work for serial

Hello,

I have tried to implement the Write trait for the Serial struct and I haven't succeed making the write_fmt work.
Both write_str and write_char works well and I can't seem to understand why the write_fmt doesn't work. I don't have many experience with rust so maybe you can figure out what is not working. I though since write_str is working well and as write_fmt is implemented in Write trait, it should be working.

Here is the simple implementation I did :

impl Write for Serial {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        for &b in s.as_bytes() {
            transmit(b);
        }
        Ok(())
    }
}

Thanks in advance

opened Nov 23, 2017 by clebi 7
Closed

Rust on an arduino Leonardo

I recently got a shiny new keyboard from https://shop.keyboard.io/ :)

I am truly loving the hardware, but given that all of the configuration is done in arduino c it makes me a bit sad. I have been spending some time looking into rust and enjoying the zero cost abstractions and the convenient type systems. This all got me thinking that I would really love to be able to program for my keyboard in rust. The existing firmware for it is highly plugin based which would be a great fit for rusts crate system and is currently pretty annoying to get working in arduino c/c++.

All of this lead me to this repo and organization. I am pretty new to arduino/avr programming however so I have a couple of questions.

First: How likely is using something like avr-rust on an arduino leonardo to be successful? Will I need to be extra careful with progmem when compared to a c version? Does rust have a large standard library which will take up too much space or is it relatively bare bones? My guess is that this is entirely up to me as I will have to recompile core anyways, but I'm not sure.

Second: What is the status of rust on avr. I saw a couple of threads in the main repo indicating that rust was updated to the correct version of LLVM, but I also saw that there are some outstanding bugs with LLVM which makes things difficult including i128 types not working. Are these insurmountable at the moment or is there a happy path for ignoring them?

Third: I saw a separate issue and pull request related to adding support for different boards, I think, this would be necessary for building firmware for my keyboard as it is based on the leonardo instead of the uno. Is this still something for which progress is being made or am I left in the dark?

I'm not sure if this is the correct place to ask these questions. Sorry if not. Clearly I am not super experienced with microcontroller programming, so any assistance in this project would be greatly appreciated!

opened Feb 24, 2018 by Kethku 7
Closed

WIP: Support for autogenerated mcu cores

It should be possible to do something like this

extern crate arduino;
use arduino::{Pin, HardwareSpi};
use arduino::cores::atmega328p;

trait Netlist {
    type PushButton: Pin;
    type Led: Pin;
    type Spi: HardwareSpi;
}

struct ATmega328p;

impl Netlist for ATmega328p {
    type PushButton = atmega328p::PORTB3;
    type Led = atmega328p::PORTB4;
    type Spi = atmega328p::SPI;
}

fn start<N: Netlist>() {
    N::PushButton::set_input();
    N::Led::set_output();
    N::Spi::setup_master();

   loop {
        // delay
        M::Led::set_high();
        // delay
        M::Led::set_low();
    }
}

This would allow users to easily mix-and-match supported microcontrollers, provided the microcontroller has enough GPIOs, etc.

opened Aug 29, 2017 by dylanmckay 6
Closed

How do I read/write analog values

I don't seem to find a way to read analog input using this library. I suppose that it is either not currently supported or considered too high level for this library.

Is there an example on to achieve this (read and possibly write analog values) using Rust?

opened Jun 23, 2019 by Altaflux 3
Closed

Pin support

opened Feb 15, 2018 by CallumJHays 2
Open

Is the project dead?

No activity on this project for far too long. Is the project dead?

opened Apr 11, 2020 by thekalinga 1
Open

Relationship with Embedded-HAL

What is the logical relationship between this project and Embedded-HAL? Would it make sense to modify this code (or fork a portion of the code) and make into an Embedded-HAL implementation for ATMega328p? It seems like that would enable the usage of all the available drivers on the Arduino Uno. But maybe there's more complexity here of which I'm unaware.

opened Jun 22, 2019 by jonahbron 11
Open

Unified interrupt handler interface

CC #9

Our interrupt handler story isn't super great; we require users to write their own interrupt vector table (IVT) in assembly, and then they define a set of pub unsafe extern "avr-interrupt" fn <interrupt handler symbol name>() { } that the IVT points to.

Here's an example program that installs interrupt handlers.

We should come up with a single, unified method of defining interrupt handlers. All AVR-Rust programs should use the same interrupt handler function names, by convention. This is similar to AVR-GCC, which always uses the same function names, although GCC has much more abbreviated, hard-to-understand names. Let's be more descriptive.

opened Nov 6, 2018 by dylanmckay 4
Open

Enable all cores when building documentation

Currently, the build script has a special case when not targeting AVR; default to atmega328 so that docs.rs can build it.

We should build all cores when generating documentation, so that the documentation is applicable to more than one device.

enhancement help wanted 
opened Nov 5, 2018 by dylanmckay 0
Open

without_interrupts(): Restore previous interrupt state rather than always re-enabling interrupts

The without_interrupts() in PR #4 always enables interrupts when the closure finishes executing.

This could be problematic in libraries; a library using this function assumes that the program it is included in actually wants interrupts to be disabled, or even if interrupts were already disabled before the call to without_interrupts

We should make a copy of the the interrupt flag in the status register, and then restore the interrupt flag back to its previous state, not just re-enabled it.

bug help wanted 
opened Nov 4, 2018 by dylanmckay 2
Open

Interrupt handler symbol name incorrect?

The README shows

pub unsafe extern "avr-interrupt" fn _ivr_timer1_compare_a() {

as interrupt handler for timer1 but that didn't work for me on the Arduino Uno Rev3.

Every time the interrupt arrived, the board did a full reset because no interrupt handler was correctly defined.

This worked:

pub unsafe extern "C" fn __vector_11() {

as that is what ISR(TIMER1_COMPA_vect) (see e.g. here) expands to when used from the Arduino IDE.

opened Aug 6, 2018 by nh2 5

Contents

    akhil218 A Fingerprint Door Lock using a microprocessor named Arduino UNO and programming through Arduino IDE
    lucasfloriani Project using rescript to create the UNO card game
    GyverLibs Библиотека программного USB клавиатуры и мыши для Arduino Nano/UNO/Mega и прочих
    ZaidaTek Oscilloscope PC-Software for Arduino Uno/Nano/AT328P
    MCJack123 ADB to USB keyboard converter using an Arduino Uno or compatible clone
    dinau Nim language test program for Arduino UNO/Nano or its compatibles
    simplesmiler vue-clickaway - Reusable clickaway directive for reusable Vue.js components.
    simplesmiler vue-focus - A reusable focus directive for reusable Vue.js components.
    francoiscampbell A plugin for CLion that enables arduino-cmake integration.
    earlephilhower Raspberry Pi Pico Arduino core, for all RP2040 boards
    arduino Arduino command line interface
    Akif9748 See your system information on LCD with Arduino!
    unoplatform Build Mobile, Desktop and WebAssembly apps with C# and XAML. Today. Open source and professionally supported.
    dataminr A collection of reusable React components with their own Flux lifecycle.
    Gusabary Hooray! Card Game UNO!
    Flutterando Future based HTTP client for the Dart and Flutter
    lmuffato Obtain the ambient temperature by Arduino and transmit the information via APi to a React component.
    Zfinix A bunch of Flutter with Arduino Projects
    relativty ⚡️ Super fast communication beetwen Unity3D and Arduino. Create Interactive experiences in a minute ⏱
    AngeloCasi An open source Arduino ESP32 MPPT Charger firmware equipped with charging algorithms, WiFi, LCD menus & more!
    todbot Arduino sketches for Oskitone Scout using Mozzi synthesis library
    Share this repo

    Related Repos


    Embedded
    629
    ruduino ^`^t Reusable components for the Arduino Uno.
    avr-rust Ruduino This library provides a set of reusable components for the Arduino Uno. Overview Register and bit definitions use ruduino::PORTB; // Register
     
    Embedded
    296
    rust-on-raspberry-piRaspberry Pi — instructions for how to cross compile Rust projects fo...
    Ogeon Cross Compiling for Raspberry Pi This guide will show how Rust programs can be cross compiled for the Raspberry Pi using Cargo. These instructions may
     
    Embedded
    1k
    The sysroot manager that lets you build and customize `std`
    japaric PSA: Xargo is in maintenance mode xargo The sysroot manager that lets you build and customize std Cross compiling `std` for i686-unknown-linux-gnu Xar
     
    Embedded
    2.4k
    Everything you need to know about cross compiling Rust programs!
    japaric rust-cross Everything you need to know about cross compiling Rust programs! If you want to set up your Rust toolchain as a cross compiler, you have co