1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

//! Board Support Crate for Arduino Leonardo
//! ========================================
//!
//! Reexports with the naming scheme from leonardo's
//! labels.
//!
//! Also contains a panic handler that rapidly blinks RX and TX leds.
//!
//! ## Example
//! ```rust
//! #![no_std]
//! #![no_main]
//! extern crate arduino_leonardo;
//!
//! use arduino_leonardo::prelude::*;
//!
//! #[no_mangle]
//! pub extern fn main() {
//!     let dp = arduino_leonardo::Peripherals::take().unwrap();
//!
//!     let mut delay = arduino_leonardo::Delay::new();
//!     let mut pins = arduino_leonardo::Pins::new(dp.PORTB, dp.PORTC, dp.PORTD, dp.PORTE);
//!
//!     let mut led0 = pins.led_rx.into_output(&mut pins.ddr);
//!     let mut led1 = pins.led_tx.into_output(&mut pins.ddr);
//!     let mut led2 = pins.d13.into_output(&mut pins.ddr);
//!
//!     led0.set_high();
//!     led1.set_high();
//!     led2.set_high();
//!
//!     let mut leds = [
//!         led0.downgrade(),
//!         led1.downgrade(),
//!         led2.downgrade(),
//!     ];
//!
//!     loop {
//!         for i in 0..3 {
//!             leds[i].toggle();
//!             leds[(i+2)%3].toggle();
//!             delay.delay_ms(200);
//!         }
//!     }
//! }
//! ```
#![no_std]
#![cfg_attr(not(feature = "docs"), feature(lang_items, unwind_attributes))]
#![cfg_attr(feature = "docs", feature(extern_prelude))]

extern crate atmega32u4;
#[macro_use]
extern crate atmega32u4_hal;

use atmega32u4_hal::delay;
/// Delay type that is fixed to the leonardo's 16 MHz clock
pub type Delay = delay::Delay<delay::MHz16>;

pub mod pins;
pub use pins::{Pins, DDR};

/// ATmega32U4 peripherals
pub use atmega32u4::Peripherals;

/// Prelude from `atmega32u4-hal`
pub mod prelude {
    pub use atmega32u4_hal::prelude::*;
}

#[cfg(not(feature = "docs"))]
pub mod std {
    use super::atmega32u4;

    #[lang = "eh_personality"]
    #[no_mangle]
    pub unsafe extern "C" fn rust_eh_personality(
        _state: (),
        _exception_object: *mut (),
        _context: *mut (),
    ) -> () {
    }

    #[lang = "panic_fmt"]
    #[unwind]
    #[no_mangle]
    pub unsafe extern "C" fn rust_begin_panic(_msg: (), _file: &'static str, _line: u32) -> ! {
        use atmega32u4_hal::prelude::*;

        let mut delay = super::Delay::new();

        let mut portb = ::core::mem::uninitialized::<atmega32u4::PORTB>().split();
        let mut portd = ::core::mem::uninitialized::<atmega32u4::PORTD>().split();

        let mut led0 = portb.pb0.into_output(&mut portb.ddr);
        let mut led1 = portd.pd5.into_output(&mut portd.ddr);

        loop {
            led0.set_high();
            delay.delay_ms(100);
            led0.set_low();

            led1.set_high();
            delay.delay_ms(100);
            led1.set_low();
        }
    }
}