Skip to content

Latest commit

 

History

History
153 lines (131 loc) · 6.2 KB

README.md

File metadata and controls

153 lines (131 loc) · 6.2 KB
Raw

avr-hal Build Status

embedded-hal implementations for AVR microcontrollers. Based on the register definitions from avr-device.

Quickstart

You need nightly rust for compiling rust code for AVR. Go into ./boards/arduino-leonardo (or the directory for whatever board you want), and run the following commands:

# Now you are ready to build your first avr blink example!
cargo +nightly build --example leonardo-blink

# Finally, convert it into a .hex file that you can flash using avr-dude
../../mkhex.sh --debug leonardo-blink

ls -l ../../target/leonardo-blink.hex

Starting your own project

This is a step-by-step guide for creating a new project targeting Arduino Leonardo (ATmega32U4). You can of course apply the same steps for any other microcontroller.

  1. Start by creating a new project: 
    cargo new --bin avr-example
cd avr-example
  2. If you're using rustup, you probably want to set an override for this directory, to use the nightly toolchain: 
    rustup override set nightly
  3. Copy the target description for your MCU (e.g. boards/arduino-leonardo/avr-atmega32u4.json) into your project.
  4. Create a file .cargo/config.toml with the following content: 
    [build]
target = "avr-atmega32u4.json"

[unstable]
build-std = ["core"]
  5. Fill Cargo.toml with these additional directives: 
    [dependencies]
# A panic handler is needed.  This is a crate with the most basic one.
# The `leonardo-panic` example shows a more elaborate version.
panic-halt = "0.2.0"

[dependencies.arduino-leonardo]
git = "https://github.com/Rahix/avr-hal"

# Configure the build for minimal size
[profile.dev]
panic = "abort"
lto = true
opt-level = "s"

[profile.release]
panic = "abort"
codegen-units = 1
debug = true
lto = true
opt-level = "s"
  6. Start your project with this basic template: 
    #![no_std]
#![no_main]

// Pull in the panic handler from panic-halt
extern crate panic_halt;

use arduino_leonardo::prelude::*;

#[arduino_leonardo::entry]
fn main() -> ! {
    let dp = arduino_leonardo::Peripherals::take().unwrap();

    unimplemented!()
}
  7. Build with these commands (make sure you're using nightly rust!): 
    cargo build
# or
cargo build --release
    and find your binary in target/avr-atmega32u4/debug/ (or target/avr-atmega32u4/release).

Structure

This repository contains the following components:

  • A generic crate containing implementations that can be used chip-independently and macros to create chip-dependent instances of peripheral abstractions. This crate is named avr-hal-generic.
  • HAL crates for each chip in chips/. These make use of avr-hal-generic to create chip-specific definitions.
  • Board Support Crates for popular hardware in boards/. They, for the most part, just re-export functionality from the chip-HAL, with the names that are printed on the PCB.

Status

The following peripherals are supported in avr-hal-generic:

  • A spinning delay implementation
  • PORTx peripherals as digital IO (v2)
  • A TWI based I2C implementation
  • SPI primary-mode implementation

HAL Status

The chip-HAL crates currently support the following peripherals:

Supported Hardware

In boards/ there are crates for the following hardware. Please note that this project is in no way affiliated with any of the vendors.

Disclaimer

This project is not affiliated with either Microchip (former Atmel) nor any of the Vendors that created the boards supported in this repository.

License

avr-hal is licensed under either of

at your option.