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 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
//! # HAL for the STM32F1 family of microcontrollers //! //! This is an implementation of the [`embedded-hal`] traits for the STM32F1 family of //! microcontrollers. //! //! [`embedded-hal`]: https://crates.io/crates/embedded-hal //! //! # Usage //! //! ## Building an application (binary crate) //! //! Follow the [cortex-m-quickstart] instructions, add this crate as a dependency //! and make sure you enable the "rt" Cargo feature of this crate. Also select which //! microcontroller you will be using by using the corresponding feature. The currently //! supported microcontrollers are: //! //! - stm32f103 //! - stm32f100 //! //! ```toml //! [dependencies.stm32f1xx-hal] //! version = "0.2.1" //! features = ["stm32f103", "rt"] //! ``` //! //! [cortex-m-quickstart]: https://docs.rs/cortex-m-quickstart/0.3.1 //! //! ## Usage example //! //! The following example blinks an LED connected to PC13 which is where the LED is connected on the //! [blue_pill] board. If you are testing on a different breakout board, you may need //! to change the pin accordingly. //! //! //! ```rust //! #![no_std] //! #![no_main] //! //! extern crate panic_halt; //! //! use nb::block; //! //! use stm32f1xx_hal::{ //! prelude::*, //! pac, //! timer::Timer, //! }; //! use cortex_m_rt::entry; //! //! #[entry] //! fn main() -> ! { //! // Get access to the core peripherals from the cortex-m crate //! let cp = cortex_m::Peripherals::take().unwrap(); //! // Get access to the device specific peripherals from the peripheral access crate //! let dp = pac::Peripherals::take().unwrap(); //! //! // Take ownership over the raw flash and rcc devices and convert them //! // into the corresponding HAL structs //! let mut flash = dp.FLASH.constrain(); //! let mut rcc = dp.RCC.constrain(); //! //! // Freeze the configuration of all the clocks in the system and store //! // the frozen frequencies in `clocks` //! let clocks = rcc.cfgr.freeze(&mut flash.acr); //! //! // Acquire the GPIOC peripheral //! let mut gpioc = dp.GPIOC.split(&mut rcc.apb2); //! //! // Configure gpio C pin 13 as a push-pull output. The `crh` register is //! // passed to the function in order to configure the port. For pins 0-7, //! // crl should be passed instead. //! let mut led = gpioc.pc13.into_push_pull_output(&mut gpioc.crh); //! // Configure the syst timer to trigger an update every second //! let mut timer = Timer::syst(cp.SYST, 1.hz(), clocks); //! //! // Wait for the timer to trigger an update and change the state of the LED //! loop { //! block!(timer.wait()).unwrap(); //! led.set_high(); //! block!(timer.wait()).unwrap(); //! led.set_low(); //! } //! } //! ``` //! //! [blue_pill]: http://wiki.stm32duino.com/index.php?title=Blue_Pill //! //! # More examples //! //! See the [examples] folder. //! //! [examples]: https://github.com/stm32-rs/stm32f1xx-hal/tree/master/examples #![no_std] use embedded_hal as hal; #[cfg(feature = "stm32f100")] pub use stm32f1::stm32f100 as pac; #[cfg(feature = "stm32f103")] pub use stm32f1::stm32f103 as pac; pub use crate::pac as device; pub use crate::pac as stm32; pub mod afio; pub mod backup_domain; pub mod bb; pub mod delay; pub mod dma; pub mod flash; pub mod gpio; pub mod i2c; pub mod prelude; #[cfg(not(feature = "stm32f100"))] pub mod pwm; pub mod pwm_input; pub mod qei; pub mod rcc; pub mod rtc; pub mod serial; pub mod spi; pub mod time; pub mod timer;