[ci skip][skip ci][skip netlify]

CHANGELOG.md

@@ -7,18 +7,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-## [v0.17.1] - 2020-08-30
-
-### Changed
-
-- Simplify USB PA11/12 remapping for STM32F042x via `usb_bus.usb_remap()` function.
-
-### Added
-
-- Complete the `TscPin` trait implementation for all touch pins in the f0 family
-
-## [v0.17.0] - 2020-06-27
-
 ### Changed
 
 - Remove duplicate error bits clearing in serial `read()` implementation
@@ -214,9 +202,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Updated stm32f0 dependency to v0.5.0.
 - Interrupt handler to new #[interrupt] attribute
 
-[Unreleased]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.17.1...HEAD
-[v0.17.1]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.17.0...v0.17.1
-[v0.17.0]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.16.0...v0.17.0
+[Unreleased]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.16.0...HEAD
 [v0.16.0]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.15.2...v0.16.0
 [v0.15.2]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.15.1...v0.15.2
 [v0.15.1]: https://github.com/stm32-rs/stm32f0xx-hal/compare/v0.15.0...v0.15.1

Cargo.toml

@@ -23,27 +23,27 @@ license = "0BSD"
 name = "stm32f0xx-hal"
 readme = "README.md"
 repository = "https://github.com/stm32-rs/stm32f0xx-hal"
-version = "0.17.1"
+version = "0.16.0"
 
 [package.metadata.docs.rs]
 features = ["stm32f042", "rt", "stm32-usbd"]
 targets = ["thumbv6m-none-eabi"]
 
 [dependencies]
-bare-metal = { version = "1.0.0" }
+bare-metal = { version = "0.2", features = ["const-fn"] }
 cast = { version = "0.2", default-features = false }
 cortex-m = "0.6"
 embedded-hal = { version = "0.2", features = ["unproven"] }
-stm32f0 = "0.12.1"
-nb = "1.0"
+stm32f0 = "0.11"
+nb = "0.1"
 void = { version = "1.0", default-features = false }
-stm32-usbd = { version = "0.5.1", features = ["ram_access_2x16"], optional = true }
+stm32-usbd = { version = "0.5.0", features = ["ram_access_2x16"], optional = true }
 
 [dev-dependencies]
 cortex-m-rt = "0.6"
 panic-halt = "0.2"
-usb-device = "0.2.7"
-usbd-serial = "0.1.1"
+usb-device = "0.2.3"
+usbd-serial = "0.1.0"
 
 [features]
 device-selected = []

examples/blinky.rs

@@ -12,12 +12,14 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let Some(mut p) = pac::Peripherals::take() {
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
+        let mut led = cortex_m::interrupt::free(|cs| {
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        // (Re-)configure PA1 as output
-        let mut led = cortex_m::interrupt::free(|cs| gpioa.pa1.into_push_pull_output(cs));
+            // (Re-)configure PA1 as output
+            gpioa.pa1.into_push_pull_output(cs)
+        });
 
         loop {
             // Turn PA1 on a million times in a row

examples/blinky_adc.rs

@@ -13,38 +13,37 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let (Some(mut p), Some(cp)) = (pac::Peripherals::take(), Peripherals::take()) {
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
+        cortex_m::interrupt::free(move |cs| {
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        let (mut led, mut an_in) = cortex_m::interrupt::free(move |cs| {
-            (
-                // (Re-)configure PA1 as output
-                gpioa.pa1.into_push_pull_output(cs),
-                // (Re-)configure PA0 as analog input
-                gpioa.pa0.into_analog(cs),
-            )
-        });
+            // (Re-)configure PA1 as output
+            let mut led = gpioa.pa1.into_push_pull_output(cs);
+
+            // (Re-)configure PA0 as analog input
+            let mut an_in = gpioa.pa0.into_analog(cs);
 
-        // Get delay provider
-        let mut delay = Delay::new(cp.SYST, &rcc);
+            // Get delay provider
+            let mut delay = Delay::new(cp.SYST, &rcc);
 
-        // Get access to the ADC
-        let mut adc = Adc::new(p.ADC, &mut rcc);
+            // Get access to the ADC
+            let mut adc = Adc::new(p.ADC, &mut rcc);
 
-        loop {
-            led.toggle().ok();
+            loop {
+                led.toggle().ok();
 
-            let time: u16 = if let Ok(val) = adc.read(&mut an_in) as Result<u16, _> {
-                /* shift the value right by 3, same as divide by 8, reduces
-                the 0-4095 range into something approximating 1-512 */
-                (val >> 3) + 1
-            } else {
-                1000
-            };
+                let time: u16 = if let Ok(val) = adc.read(&mut an_in) as Result<u16, _> {
+                    /* shift the value right by 3, same as divide by 8, reduces
+                    the 0-4095 range into something approximating 1-512 */
+                    (val >> 3) + 1
+                } else {
+                    1000
+                };
 
-            delay.delay_ms(time);
-        }
+                delay.delay_ms(time);
+            }
+        });
     }
 
     loop {

examples/blinky_delay.rs

@@ -13,20 +13,22 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let (Some(mut p), Some(cp)) = (pac::Peripherals::take(), Peripherals::take()) {
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
+        cortex_m::interrupt::free(move |cs| {
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        // (Re-)configure PA1 as output
-        let mut led = cortex_m::interrupt::free(move |cs| gpioa.pa1.into_push_pull_output(cs));
+            // (Re-)configure PA1 as output
+            let mut led = gpioa.pa1.into_push_pull_output(cs);
 
-        // Get delay provider
-        let mut delay = Delay::new(cp.SYST, &rcc);
+            // Get delay provider
+            let mut delay = Delay::new(cp.SYST, &rcc);
 
-        loop {
-            led.toggle().ok();
-            delay.delay_ms(1_000_u16);
-        }
+            loop {
+                led.toggle().ok();
+                delay.delay_ms(1_000_u16);
+            }
+        });
     }
 
     loop {

examples/blinky_multiple.rs

@@ -13,36 +13,35 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let (Some(mut p), Some(cp)) = (pac::Peripherals::take(), Peripherals::take()) {
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
-
-        let gpioa = p.GPIOA.split(&mut rcc);
-        let gpiob = p.GPIOB.split(&mut rcc);
-
-        let (led1, led2) = cortex_m::interrupt::free(move |cs| {
-            (
-                // (Re-)configure PA1 as output
-                gpioa.pa1.into_push_pull_output(cs),
-                // (Re-)configure PB1 as output
-                gpiob.pb1.into_push_pull_output(cs),
-            )
-        });
+        cortex_m::interrupt::free(move |cs| {
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
 
-        // Get delay provider
-        let mut delay = Delay::new(cp.SYST, &rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
+            let gpiob = p.GPIOB.split(&mut rcc);
 
-        // Store them together after erasing the type
-        let mut leds = [led1.downgrade(), led2.downgrade()];
-        loop {
-            for l in &mut leds {
-                l.set_high().ok();
-            }
-            delay.delay_ms(1_000_u16);
+            // (Re-)configure PA1 as output
+            let led1 = gpioa.pa1.into_push_pull_output(cs);
+
+            // (Re-)configure PB1 as output
+            let led2 = gpiob.pb1.into_push_pull_output(cs);
 
-            for l in &mut leds {
-                l.set_low().ok();
+            // Get delay provider
+            let mut delay = Delay::new(cp.SYST, &rcc);
+
+            // Store them together after erasing the type
+            let mut leds = [led1.downgrade(), led2.downgrade()];
+            loop {
+                for l in &mut leds {
+                    l.set_high().ok();
+                }
+                delay.delay_ms(1_000_u16);
+
+                for l in &mut leds {
+                    l.set_low().ok();
+                }
+                delay.delay_ms(1_000_u16);
             }
-            delay.delay_ms(1_000_u16);
-        }
+        });
     }
 
     loop {

examples/blinky_timer.rs

@@ -12,22 +12,24 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let Some(mut p) = pac::Peripherals::take() {
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
+        cortex_m::interrupt::free(move |cs| {
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut p.FLASH);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        // (Re-)configure PA1 as output
-        let mut led = cortex_m::interrupt::free(move |cs| gpioa.pa1.into_push_pull_output(cs));
+            // (Re-)configure PA1 as output
+            let mut led = gpioa.pa1.into_push_pull_output(cs);
 
-        // Set up a timer expiring after 1s
-        let mut timer = Timer::tim1(p.TIM1, Hertz(1), &mut rcc);
+            // Set up a timer expiring after 1s
+            let mut timer = Timer::tim1(p.TIM1, Hertz(1), &mut rcc);
 
-        loop {
-            led.toggle().ok();
+            loop {
+                led.toggle().ok();
 
-            // Wait for the timer to expire
-            nb::block!(timer.wait()).ok();
-        }
+                // Wait for the timer to expire
+                nb::block!(timer.wait()).ok();
+            }
+        });
     }
 
     loop {

examples/dac.rs

@@ -22,37 +22,37 @@ enum Direction {
 #[entry]
 fn main() -> ! {
     if let (Some(mut dp), Some(_cp)) = (pac::Peripherals::take(), cortex_m::Peripherals::take()) {
-        let mut rcc = dp.RCC.configure().sysclk(8.mhz()).freeze(&mut dp.FLASH);
-        let gpioa = dp.GPIOA.split(&mut rcc);
+        cortex_m::interrupt::free(move |cs| {
+            let mut rcc = dp.RCC.configure().sysclk(8.mhz()).freeze(&mut dp.FLASH);
 
-        let pa4 = cortex_m::interrupt::free(move |cs| gpioa.pa4.into_analog(cs));
+            let gpioa = dp.GPIOA.split(&mut rcc);
+            let mut dac = dac(dp.DAC, gpioa.pa4.into_analog(cs), &mut rcc);
 
-        let mut dac = dac(dp.DAC, pa4, &mut rcc);
+            dac.enable();
 
-        dac.enable();
+            let mut dir = Direction::Upcounting;
+            let mut val = 0;
 
-        let mut dir = Direction::Upcounting;
-        let mut val = 0;
+            dac.set_value(2058);
+            cortex_m::asm::bkpt();
 
-        dac.set_value(2058);
-        cortex_m::asm::bkpt();
+            dac.set_value(4095);
+            cortex_m::asm::bkpt();
 
-        dac.set_value(4095);
-        cortex_m::asm::bkpt();
+            loop {
+                dac.set_value(val);
+                match val {
+                    0 => dir = Direction::Upcounting,
+                    4095 => dir = Direction::Downcounting,
+                    _ => (),
+                };
 
-        loop {
-            dac.set_value(val);
-            match val {
-                0 => dir = Direction::Upcounting,
-                4095 => dir = Direction::Downcounting,
-                _ => (),
-            };
-
-            match dir {
-                Direction::Upcounting => val += 1,
-                Direction::Downcounting => val -= 1,
+                match dir {
+                    Direction::Upcounting => val += 1,
+                    Direction::Downcounting => val -= 1,
+                }
             }
-        }
+        });
     }
 
     loop {

examples/serial_echo.rs

@@ -12,27 +12,25 @@ use cortex_m_rt::entry;
 #[entry]
 fn main() -> ! {
     if let Some(p) = pac::Peripherals::take() {
-        let mut flash = p.FLASH;
-        let mut rcc = p.RCC.configure().sysclk(48.mhz()).freeze(&mut flash);
+        cortex_m::interrupt::free(move |cs| {
+            let mut flash = p.FLASH;
+            let mut rcc = p.RCC.configure().sysclk(48.mhz()).freeze(&mut flash);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        let (tx, rx) = cortex_m::interrupt::free(move |cs| {
-            (
-                gpioa.pa9.into_alternate_af1(cs),
-                gpioa.pa10.into_alternate_af1(cs),
-            )
-        });
+            let tx = gpioa.pa9.into_alternate_af1(cs);
+            let rx = gpioa.pa10.into_alternate_af1(cs);
 
-        let mut serial = Serial::usart1(p.USART1, (tx, rx), 115_200.bps(), &mut rcc);
+            let mut serial = Serial::usart1(p.USART1, (tx, rx), 115_200.bps(), &mut rcc);
 
-        loop {
-            // Wait for reception of a single byte
-            let received = nb::block!(serial.read()).unwrap();
+            loop {
+                // Wait for reception of a single byte
+                let received = nb::block!(serial.read()).unwrap();
 
-            // Send back previously received byte and wait for completion
-            nb::block!(serial.write(received)).ok();
-        }
+                // Send back previously received byte and wait for completion
+                nb::block!(serial.write(received)).ok();
+            }
+        });
     }
 
     loop {

examples/serial_spi_bridge.rs

@@ -31,37 +31,35 @@ fn main() -> ! {
     };
 
     if let Some(p) = pac::Peripherals::take() {
-        let mut flash = p.FLASH;
-        let mut rcc = p.RCC.configure().freeze(&mut flash);
+        cortex_m::interrupt::free(move |cs| {
+            let mut flash = p.FLASH;
+            let mut rcc = p.RCC.configure().freeze(&mut flash);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        let (sck, miso, mosi, tx, rx) = cortex_m::interrupt::free(move |cs| {
-            (
-                // SPI pins
-                gpioa.pa5.into_alternate_af0(cs),
-                gpioa.pa6.into_alternate_af0(cs),
-                gpioa.pa7.into_alternate_af0(cs),
-                // USART pins
-                gpioa.pa9.into_alternate_af1(cs),
-                gpioa.pa10.into_alternate_af1(cs),
-            )
-        });
+            // Configure pins for SPI
+            let sck = gpioa.pa5.into_alternate_af0(cs);
+            let miso = gpioa.pa6.into_alternate_af0(cs);
+            let mosi = gpioa.pa7.into_alternate_af0(cs);
+
+            // Configure SPI with 1MHz rate
+            let mut spi = Spi::spi1(p.SPI1, (sck, miso, mosi), MODE, 1.mhz(), &mut rcc);
 
-        // Configure SPI with 1MHz rate
-        let mut spi = Spi::spi1(p.SPI1, (sck, miso, mosi), MODE, 1.mhz(), &mut rcc);
+            let tx = gpioa.pa9.into_alternate_af1(cs);
+            let rx = gpioa.pa10.into_alternate_af1(cs);
 
-        let serial = Serial::usart1(p.USART1, (tx, rx), 115_200.bps(), &mut rcc);
+            let serial = Serial::usart1(p.USART1, (tx, rx), 115_200.bps(), &mut rcc);
 
-        let (mut tx, mut rx) = serial.split();
+            let (mut tx, mut rx) = serial.split();
 
-        let mut data = [0];
-        loop {
-            let serial_received = block!(rx.read()).unwrap();
-            spi.write(&[serial_received]).ok();
-            let spi_received = spi.transfer(&mut data).unwrap();
-            block!(tx.write(spi_received[0])).ok();
-        }
+            let mut data = [0];
+            loop {
+                let serial_received = block!(rx.read()).unwrap();
+                spi.write(&[serial_received]).ok();
+                let spi_received = spi.transfer(&mut data).unwrap();
+                block!(tx.write(spi_received[0])).ok();
+            }
+        });
     }
 
     loop {

examples/spi_hal_apa102c.rs

@@ -22,47 +22,45 @@ fn main() -> ! {
     };
 
     if let Some(p) = pac::Peripherals::take() {
-        let mut flash = p.FLASH;
-        let mut rcc = p.RCC.configure().freeze(&mut flash);
+        cortex_m::interrupt::free(move |cs| {
+            let mut flash = p.FLASH;
+            let mut rcc = p.RCC.configure().freeze(&mut flash);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
+            let gpioa = p.GPIOA.split(&mut rcc);
 
-        // Configure pins for SPI
-        let (sck, miso, mosi) = cortex_m::interrupt::free(move |cs| {
-            (
-                gpioa.pa5.into_alternate_af0(cs),
-                gpioa.pa6.into_alternate_af0(cs),
-                gpioa.pa7.into_alternate_af0(cs),
-            )
-        });
+            // Configure pins for SPI
+            let sck = gpioa.pa5.into_alternate_af0(cs);
+            let miso = gpioa.pa6.into_alternate_af0(cs);
+            let mosi = gpioa.pa7.into_alternate_af0(cs);
 
-        // Configure SPI with 100kHz rate
-        let mut spi = Spi::spi1(p.SPI1, (sck, miso, mosi), MODE, 100_000.hz(), &mut rcc);
+            // Configure SPI with 100kHz rate
+            let mut spi = Spi::spi1(p.SPI1, (sck, miso, mosi), MODE, 100_000.hz(), &mut rcc);
 
-        // Cycle through colors on 16 chained APA102C LEDs
-        loop {
-            for r in 0..255 {
-                let _ = spi.write(&[0, 0, 0, 0]);
-                for _i in 0..16 {
-                    let _ = spi.write(&[0b1110_0001, 0, 0, r]);
+            // Cycle through colors on 16 chained APA102C LEDs
+            loop {
+                for r in 0..255 {
+                    let _ = spi.write(&[0, 0, 0, 0]);
+                    for _i in 0..16 {
+                        let _ = spi.write(&[0b1110_0001, 0, 0, r]);
+                    }
+                    let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
                 }
-                let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
-            }
-            for b in 0..255 {
-                let _ = spi.write(&[0, 0, 0, 0]);
-                for _i in 0..16 {
-                    let _ = spi.write(&[0b1110_0001, b, 0, 0]);
+                for b in 0..255 {
+                    let _ = spi.write(&[0, 0, 0, 0]);
+                    for _i in 0..16 {
+                        let _ = spi.write(&[0b1110_0001, b, 0, 0]);
+                    }
+                    let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
                 }
-                let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
-            }
-            for g in 0..255 {
-                let _ = spi.write(&[0, 0, 0, 0]);
-                for _i in 0..16 {
-                    let _ = spi.write(&[0b1110_0001, 0, g, 0]);
+                for g in 0..255 {
+                    let _ = spi.write(&[0, 0, 0, 0]);
+                    for _i in 0..16 {
+                        let _ = spi.write(&[0b1110_0001, 0, g, 0]);
+                    }
+                    let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
                 }
-                let _ = spi.write(&[0xFF, 0xFF, 0xFF, 0xFF]);
             }
-        }
+        });
     }
 
     loop {

examples/usb_serial.rs

@@ -15,6 +15,13 @@ use usbd_serial::{SerialPort, USB_CLASS_CDC};
 fn main() -> ! {
     let mut dp = pac::Peripherals::take().unwrap();
 
+    /* Uncomment the following lines if you have a chip in TSSOP20 (STM32F042F)
+       or UFQFPN28 (STM32F042G) package
+       This code enables clock for SYSCFG and remaps USB pins to PA9 and PA10.
+    */
+    //dp.RCC.apb2enr.modify(|_, w| w.syscfgen().set_bit());
+    //dp.SYSCFG.cfgr1.modify(|_, w| w.pa11_pa12_rmp().remapped());
+
     let mut rcc = dp
         .RCC
         .configure()
@@ -36,20 +43,10 @@ fn main() -> ! {
         pin_dm: gpioa.pa11,
         pin_dp: gpioa.pa12,
     };
-
     let usb_bus = UsbBus::new(usb);
 
     let mut serial = SerialPort::new(&usb_bus);
 
-    /*
-     * IMPORTANT: if you have a chip in TSSOP20 (STM32F042F) or UFQFPN28 (STM32F042G) package,
-     * and want to use USB, make sure you call `remap_pins(rcc, syscfg)`, otherwise the device will not enumerate.
-     *
-     * Uncomment the following function if the situation above applies to you.
-     */
-
-    //usb_bus.remap_pins();
-
     let mut usb_dev = UsbDeviceBuilder::new(&usb_bus, UsbVidPid(0x16c0, 0x27dd))
         .manufacturer("Fake company")
         .product("Serial port")

examples/watchdog.rs

@@ -15,40 +15,42 @@ use core::fmt::Write;
 #[entry]
 fn main() -> ! {
     if let (Some(p), Some(cp)) = (pac::Peripherals::take(), Peripherals::take()) {
-        let mut flash = p.FLASH;
-        let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut flash);
+        cortex_m::interrupt::free(move |cs| {
+            let mut flash = p.FLASH;
+            let mut rcc = p.RCC.configure().sysclk(8.mhz()).freeze(&mut flash);
 
-        let gpioa = p.GPIOA.split(&mut rcc);
-        let dbgmcu = p.DBGMCU;
+            let gpioa = p.GPIOA.split(&mut rcc);
+            let dbgmcu = p.DBGMCU;
 
-        // Disable the watchdog when the cpu is stopped under debug
-        dbgmcu.apb1_fz.modify(|_, w| w.dbg_iwdg_stop().set_bit());
+            // Disable the watchdog when the cpu is stopped under debug
+            dbgmcu.apb1_fz.modify(|_, w| w.dbg_iwdg_stop().set_bit());
 
-        let mut watchdog = Watchdog::new(p.IWDG);
+            let mut watchdog = Watchdog::new(p.IWDG);
 
-        // Get delay provider
-        let mut delay = Delay::new(cp.SYST, &rcc);
+            // Get delay provider
+            let mut delay = Delay::new(cp.SYST, &rcc);
 
-        // Configure serial TX pin
-        let tx = cortex_m::interrupt::free(move |cs| gpioa.pa9.into_alternate_af1(cs));
+            // Configure serial TX pin
+            let tx = gpioa.pa9.into_alternate_af1(cs);
 
-        // Obtain a serial peripheral with for unidirectional communication
-        let mut serial = Serial::usart1tx(p.USART1, tx, 115_200.bps(), &mut rcc);
+            // Obtain a serial peripheral with for unidirectional communication
+            let mut serial = Serial::usart1tx(p.USART1, tx, 115_200.bps(), &mut rcc);
 
-        serial.write_str("RESET \r\n").ok();
+            serial.write_str("RESET \r\n").ok();
 
-        watchdog.start(Hertz(1));
-        delay.delay_ms(500_u16);
-        watchdog.feed();
-        delay.delay_ms(500_u16);
-        watchdog.feed();
-        delay.delay_ms(500_u16);
-        serial.write_str("This will get printed \r\n").ok();
-        watchdog.feed();
+            watchdog.start(Hertz(1));
+            delay.delay_ms(500_u16);
+            watchdog.feed();
+            delay.delay_ms(500_u16);
+            watchdog.feed();
+            delay.delay_ms(500_u16);
+            serial.write_str("This will get printed \r\n").ok();
+            watchdog.feed();
 
-        // Now a reset happens while delaying
-        delay.delay_ms(1500_u16);
-        serial.write_str("This won't\r\n").ok();
+            // Now a reset happens while delaying
+            delay.delay_ms(1500_u16);
+            serial.write_str("This won't\r\n").ok();
+        });
     }
 
     loop {

src/dac.rs

@@ -114,7 +114,7 @@ where
     rcc.regs.apb1rstr.modify(|_, w| w.dacrst().set_bit());
     rcc.regs.apb1rstr.modify(|_, w| w.dacrst().clear_bit());
 
-    unsafe { mem::MaybeUninit::uninit().assume_init() }
+    unsafe { mem::uninitialized() }
 }
 
 macro_rules! dac {

src/i2c.rs

@@ -234,7 +234,7 @@ where
             scldel = 3;
         }
 
-        // Enable I2C signal generator, and configure I2C for configured speed
+        // Enable I2C signal generator, and configure I2C for 400KHz full speed
         self.i2c.timingr.write(|w| {
             w.presc()
                 .bits(presc)

src/serial.rs

@@ -324,7 +324,7 @@ macro_rules! usart {
             where
                 RXPIN: RxPin<$USART>,
             {
-                /// Creates a new rx-only serial instance
+                /// Creates a new tx-only serial instance
                 pub fn $usartrx(usart: $USART, rxpin: RXPIN, baud_rate: Bps, rcc: &mut Rcc) -> Self
                 {
                     let txpin = ();

src/spi.rs

@@ -365,27 +365,17 @@ where
     fn check_read(&mut self) -> nb::Result<(), Error> {
         let sr = self.spi.sr.read();
 
-        self.check_errors()?;
-
-        if !sr.rxne().bit_is_set() {
-            Err(nb::Error::WouldBlock)
-        } else {
-            Ok(())
-        }
-    }
-
-    fn check_errors(&mut self) -> Result<(), Error> {
-        let sr = self.spi.sr.read();
-
-        if sr.ovr().bit_is_set() {
-            Err(Error::Overrun)
+        Err(if sr.ovr().bit_is_set() {
+            nb::Error::Other(Error::Overrun)
         } else if sr.modf().bit_is_set() {
-            Err(Error::ModeFault)
+            nb::Error::Other(Error::ModeFault)
         } else if sr.crcerr().bit_is_set() {
-            Err(Error::Crc)
+            nb::Error::Other(Error::Crc)
+        } else if sr.rxne().bit_is_set() {
+            return Ok(());
         } else {
-            Ok(())
-        }
+            nb::Error::WouldBlock
+        })
     }
 
     fn send_buffer_size(&mut self) -> u8 {
@@ -404,13 +394,17 @@ where
     fn check_send(&mut self) -> nb::Result<(), Error> {
         let sr = self.spi.sr.read();
 
-        self.check_errors()?;
-
-        if !sr.txe().bit_is_set() {
-            Err(nb::Error::WouldBlock)
+        Err(if sr.ovr().bit_is_set() {
+            nb::Error::Other(Error::Overrun)
+        } else if sr.modf().bit_is_set() {
+            nb::Error::Other(Error::ModeFault)
+        } else if sr.crcerr().bit_is_set() {
+            nb::Error::Other(Error::Crc)
+        } else if sr.txe().bit_is_set() {
+            return Ok(());
         } else {
-            Ok(())
-        }
+            nb::Error::WouldBlock
+        })
     }
 
     fn read_u8(&mut self) -> u8 {
@@ -460,29 +454,6 @@ where
     }
 }
 
-impl<SPI, SCKPIN, MISOPIN, MOSIPIN> ::embedded_hal::spi::FullDuplex<u8>
-    for Spi<SPI, SCKPIN, MISOPIN, MOSIPIN, EightBit>
-where
-    SPI: Deref<Target = SpiRegisterBlock>,
-{
-    type Error = Error;
-
-    fn read(&mut self) -> nb::Result<u8, Error> {
-        self.check_read()?;
-        Ok(self.read_u8())
-    }
-
-    fn send(&mut self, byte: u8) -> nb::Result<(), Error> {
-        // We want to transfer bidirectionally, make sure we're in the correct mode
-        self.set_bidi();
-
-        self.check_send()?;
-        self.send_u8(byte);
-
-        self.check_errors().map_err(|e| nb::Error::Other(e))
-    }
-}
-
 impl<SPI, SCKPIN, MISOPIN, MOSIPIN> ::embedded_hal::blocking::spi::Write<u8>
     for Spi<SPI, SCKPIN, MISOPIN, MOSIPIN, EightBit>
 where
@@ -511,33 +482,8 @@ where
         }
 
         // Do one last status register check before continuing
-        self.check_errors()
-    }
-}
-
-impl<SPI, SCKPIN, MISOPIN, MOSIPIN> ::embedded_hal::spi::FullDuplex<u16>
-    for Spi<SPI, SCKPIN, MISOPIN, MOSIPIN, SixteenBit>
-where
-    SPI: Deref<Target = SpiRegisterBlock>,
-{
-    type Error = Error;
-
-    fn read(&mut self) -> nb::Result<u16, Error> {
-        self.check_read()?;
-        Ok(self.read_u16())
-    }
-
-    fn send(&mut self, byte: u16) -> nb::Result<(), Error> {
-        // We want to transfer bidirectionally, make sure we're in the correct mode
-        self.set_bidi();
-
-        self.check_send()?;
-        self.send_u16(byte);
-
-        match self.check_errors() {
-            Ok(_) => Ok(()),
-            Err(e) => Err(nb::Error::Other(e)),
-        }
+        self.check_send().ok();
+        Ok(())
     }
 }
 
@@ -580,6 +526,7 @@ where
         }
 
         // Do one last status register check before continuing
-        self.check_errors()
+        self.check_send().ok();
+        Ok(())
     }
 }

src/tsc.rs

@@ -7,7 +7,7 @@
 //! usually comprised between 47nF and 100nF. These values are given as reference for an
 //! electrode fitting a human finger tip size across a few millimeters dielectric panel.
 
-use crate::gpio::*;
+use crate::gpio::{gpioa, gpiob, Alternate, AF3};
 use crate::pac::TSC;
 use crate::rcc::Rcc;
 
@@ -66,34 +66,12 @@ tsc_pins!(
     gpioa::PA7<Alternate<AF3>> => (2_u8, 4_u8),
 );
 
-// all with a TSC minus 42 and 48
-#[cfg(any(
-    feature = "stm32f051",
-    feature = "stm32f058",
-    feature = "stm32f071",
-    feature = "stm32f072",
-    feature = "stm32f078",
-    feature = "stm32f091",
-    feature = "stm32f098"
-))]
-tsc_pins!( gpioc::PC5<Alternate<AF0>> => (3_u8, 1_u8) );
-
 tsc_pins!(
     gpiob::PB0<Alternate<AF3>> => (3_u8, 2_u8),
     gpiob::PB1<Alternate<AF3>> => (3_u8, 3_u8),
+    gpiob::PB2<Alternate<AF3>> => (3_u8, 4_u8),
 );
 
-// all with a TCS minus 58, 78 and 98
-#[cfg(any(
-    feature = "stm32f042",
-    feature = "stm32f048",
-    feature = "stm32f051",
-    feature = "stm32f071",
-    feature = "stm32f072",
-    feature = "stm32f091"
-))]
-tsc_pins!( gpiob::PB2<Alternate<AF3>> => (3_u8, 4_u8) );
-
 tsc_pins!(
     gpioa::PA9<Alternate<AF3>> => (4_u8, 1_u8),
     gpioa::PA10<Alternate<AF3>> => (4_u8, 2_u8),
@@ -108,53 +86,6 @@ tsc_pins!(
     gpiob::PB7<Alternate<AF3>> => (5_u8, 4_u8),
 );
 
-// all with a TSC minus 42 and 48
-#[cfg(any(
-    feature = "stm32f051",
-    feature = "stm32f058",
-    feature = "stm32f071",
-    feature = "stm32f072",
-    feature = "stm32f078",
-    feature = "stm32f091",
-    feature = "stm32f098"
-))]
-tsc_pins!(
-    gpiob::PB11<Alternate<AF3>> => (6_u8, 1_u8),
-    gpiob::PB12<Alternate<AF3>> => (6_u8, 2_u8),
-    gpiob::PB13<Alternate<AF3>> => (6_u8, 3_u8),
-    gpiob::PB14<Alternate<AF3>> => (6_u8, 4_u8),
-);
-
-// all with a TSC and gpioe
-#[cfg(any(
-    feature = "stm32f071",
-    feature = "stm32f072",
-    feature = "stm32f078",
-    feature = "stm32f091",
-    feature = "stm32f098"
-))]
-tsc_pins!(
-    gpioe::PE2<Alternate<AF3>> => (7_u8, 1_u8),
-    gpioe::PE3<Alternate<AF3>> => (7_u8, 2_u8),
-    gpioe::PE4<Alternate<AF3>> => (7_u8, 3_u8),
-    gpioe::PE5<Alternate<AF3>> => (7_u8, 4_u8),
-);
-
-// all with a TSC and gpiod
-#[cfg(any(
-    feature = "stm32f071",
-    feature = "stm32f072",
-    feature = "stm32f078",
-    feature = "stm32f091",
-    feature = "stm32f098"
-))]
-tsc_pins!(
-    gpiod::PD12<Alternate<AF3>> => (8_u8, 1_u8),
-    gpiod::PD13<Alternate<AF3>> => (8_u8, 2_u8),
-    gpiod::PD14<Alternate<AF3>> => (8_u8, 3_u8),
-    gpiod::PD15<Alternate<AF3>> => (8_u8, 4_u8),
-);
-
 pub struct Tsc {
     tsc: TSC,
 }

src/usb.rs

@@ -5,7 +5,7 @@
 //! See <https://github.com/stm32-rs/stm32f0xx-hal/tree/master/examples>
 //! for usage examples.
 
-use crate::pac::{RCC, SYSCFG, USB};
+use crate::pac::{RCC, USB};
 use stm32_usbd::UsbPeripheral;
 
 use crate::gpio::gpioa::{PA11, PA12};
@@ -27,7 +27,7 @@ unsafe impl UsbPeripheral for Peripheral {
     const EP_MEMORY_SIZE: usize = 1024;
 
     fn enable() {
-        let rcc = unsafe { &*RCC::ptr() };
+        let rcc = unsafe { (&*RCC::ptr()) };
 
         cortex_m::interrupt::free(|_| {
             // Enable USB peripheral
@@ -46,13 +46,4 @@ unsafe impl UsbPeripheral for Peripheral {
     }
 }
 
-pub fn remap_pins(rcc: &mut RCC, syscfg: &mut SYSCFG) {
-    cortex_m::interrupt::free(|_| {
-        // Remap PA11/PA12 pins to PA09/PA10 for USB on
-        // TSSOP20 (STM32F042F) or UFQFPN28 (STM32F042G) packages
-        rcc.apb2enr.modify(|_, w| w.syscfgen().set_bit());
-        syscfg.cfgr1.modify(|_, w| w.pa11_pa12_rmp().remapped());
-    });
-}
-
 pub type UsbBusType = UsbBus<Peripheral>;

tools/check.py

@@ -28,7 +28,7 @@ def main():
 
     crate_info = cargo_meta["packages"][0]
 
-    features = [""] + ["{},rt,stm32-usbd".format(x)
+    features = [""] + ["{} rt".format(x)
                        for x in crate_info["features"].keys()
                        if x != "device-selected" and x != "rt" and x != "stm32f030"]