i2c + spi + serial + can

Author: burrbull

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+ - Use `enum`s for alternate peripheral pins
  - Added missing U(S)ART DMA traits for HAL serial types [#593]
  - Improve SPI::new* docs [#587]
  - Add advanced timer dead time insertion example [#585]

examples/rtic-usart-shell-ssd1306.rs

@@ -21,10 +21,7 @@ mod usart_shell {
     use ssd1306::{mode::BufferedGraphicsMode, prelude::*, I2CDisplayInterface, Ssd1306};
 
     use stm32f4xx_hal::{
-        gpio::{
-            gpioa::PA0, gpioa::PA10, gpioa::PA9, gpiob::PB8, gpiob::PB9, gpioc::PC13, Alternate,
-            Edge, Input, OpenDrain, Output, PushPull,
-        },
+        gpio::{gpioa::PA0, gpioc::PC13, Edge, Input, Output, PushPull},
         i2c::I2c,
         pac::I2C1,
         pac::USART1,
@@ -40,14 +37,9 @@ mod usart_shell {
 
     type LedType = PC13<Output<PushPull>>;
     type ButtonType = PA0<Input>;
-    type ShellType = UShell<
-        Serial<USART1, (PA9<Alternate<7>>, PA10<Alternate<7>>)>,
-        StaticAutocomplete<5>,
-        LRUHistory<32, 4>,
-        32,
-    >;
+    type ShellType = UShell<Serial<USART1>, StaticAutocomplete<5>, LRUHistory<32, 4>, 32>;
     type DisplayType = Ssd1306<
-        I2CInterface<I2c<I2C1, (PB8<Alternate<4, OpenDrain>>, PB9<Alternate<4, OpenDrain>>)>>,
+        I2CInterface<I2c<I2C1>>,
         DisplaySize128x64,
         BufferedGraphicsMode<DisplaySize128x64>,
     >;

examples/rtic-usart-shell.rs

@@ -10,10 +10,7 @@ mod usart_shell {
     use core::fmt::Write;
     use dwt_systick_monotonic::DwtSystick;
     use stm32f4xx_hal::{
-        gpio::{
-            gpioa::PA0, gpioa::PA10, gpioa::PA9, gpioc::PC13, Alternate, Edge, Input, Output,
-            PushPull,
-        },
+        gpio::{gpioa::PA0, gpioc::PC13, Edge, Input, Output, PushPull},
         pac::USART1,
         prelude::*,
         serial::{config::Config, Event::Rxne, Serial},
@@ -26,12 +23,7 @@ mod usart_shell {
 
     type LedType = PC13<Output<PushPull>>;
     type ButtonType = PA0<Input>;
-    type ShellType = UShell<
-        Serial<USART1, (PA9<Alternate<7>>, PA10<Alternate<7>>)>,
-        StaticAutocomplete<5>,
-        LRUHistory<32, 4>,
-        32,
-    >;
+    type ShellType = UShell<Serial<USART1>, StaticAutocomplete<5>, LRUHistory<32, 4>, 32>;
 
     const SHELL_PROMPT: &str = "#> ";
     const CR: &str = "\r\n";

examples/stopwatch-with-ssd1306-and-interrupts-and-dma-i2c.rs

@@ -52,12 +52,11 @@ use heapless::String;
 use ssd1306::{prelude::*, Ssd1306};
 
 pub type I2c1Handle = I2CMasterDma<
-    I2C1,                                       // Instance of I2C
-    (PB8<AF4<OpenDrain>>, PB9<AF4<OpenDrain>>), // Pins
-    Stream1<DMA1>,                              // Stream used for Tx
-    0,                                          // Channel for Tx
-    Stream0<DMA1>,                              // Stream used for Rx (Not used in example)
-    1,                                          // Channel for Rx (Not used in example)
+    I2C1,          // Instance of I2C
+    Stream1<DMA1>, // Stream used for Tx
+    0,             // Channel for Tx
+    Stream0<DMA1>, // Stream used for Rx (Not used in example)
+    1,             // Channel for Rx (Not used in example)
 >;
 
 // Set up global state. It's all mutexed up for concurrency safety.

src/can.rs

@@ -1,157 +1,142 @@
 //! # Controller Area Network (CAN) Interface
 //!
 
-use crate::gpio::{Const, NoPin, PinA, PushPull, SetAlternate};
+use crate::gpio::{self, NoPin};
 use crate::pac::{CAN1, CAN2};
 use crate::rcc;
 
-pub trait Instance: crate::Sealed + rcc::Enable + rcc::Reset {}
+pub trait Instance: crate::Sealed + rcc::Enable + rcc::Reset {
+    type Tx;
+    type Rx;
+}
+
+macro_rules! can {
+    ($CAN:ty: $Can:ident, $can:ident) => {
+        pub type $Can = Can<$CAN>;
+
+        impl Instance for $CAN {
+            type Tx = gpio::alt::$can::Tx;
+            type Rx = gpio::alt::$can::Rx;
+        }
+    };
+}
 
 // Implemented by all SPI instances
-impl Instance for CAN1 {}
-pub type Can1<PINS> = Can<CAN1, PINS>;
-impl Instance for CAN2 {}
-pub type Can2<PINS> = Can<CAN2, PINS>;
+can! { CAN1: Can1, can1 }
+can! { CAN2: Can2, can2 }
 #[cfg(feature = "can3")]
-pub type Can3<PINS> = Can<crate::pac::CAN3, PINS>;
+can! { crate::pac::CAN3: Can3, can3 }
 
 pub struct Tx;
 impl crate::Sealed for Tx {}
 pub struct Rx;
 impl crate::Sealed for Rx {}
 
-pub trait Pins<CAN> {
-    fn set_alt_mode(&mut self);
-    fn restore_mode(&mut self);
-}
-
-impl<CAN, TX, RX, const TXA: u8, const RXA: u8> Pins<CAN> for (TX, RX)
-where
-    TX: PinA<Tx, CAN, A = Const<TXA>> + SetAlternate<TXA, PushPull>,
-    RX: PinA<Rx, CAN, A = Const<RXA>> + SetAlternate<RXA, PushPull>,
-{
-    fn set_alt_mode(&mut self) {
-        self.0.set_alt_mode();
-        self.1.set_alt_mode();
-    }
-    fn restore_mode(&mut self) {
-        self.0.restore_mode();
-        self.1.restore_mode();
-    }
-}
-
 /// Pins and definitions for models with a third CAN peripheral
 #[cfg(feature = "can3")]
 mod can3 {
     use super::*;
     use crate::pac::CAN3;
 
-    impl Instance for CAN3 {}
-
-    unsafe impl<PINS> bxcan::Instance for Can<CAN3, PINS> {
+    unsafe impl bxcan::Instance for Can<CAN3> {
         const REGISTERS: *mut bxcan::RegisterBlock = CAN3::ptr() as *mut _;
     }
 
-    unsafe impl<PINS> bxcan::FilterOwner for Can<CAN3, PINS> {
+    unsafe impl bxcan::FilterOwner for Can<CAN3> {
         const NUM_FILTER_BANKS: u8 = 14;
     }
 }
 
 pub trait CanExt: Sized + Instance {
-    fn can<TX, RX>(self, pins: (TX, RX)) -> Can<Self, (TX, RX)>
-    where
-        (TX, RX): Pins<Self>;
-    fn tx<TX>(self, tx_pin: TX) -> Can<Self, (TX, NoPin)>
+    fn can(self, pins: (impl Into<Self::Tx>, impl Into<Self::Rx>)) -> Can<Self>;
+
+    fn tx(self, tx_pin: impl Into<Self::Tx>) -> Can<Self>
     where
-        (TX, NoPin): Pins<Self>;
-    fn rx<RX>(self, rx_pin: RX) -> Can<Self, (NoPin, RX)>
+        NoPin: Into<Self::Rx>;
+
+    fn rx(self, rx_pin: impl Into<Self::Rx>) -> Can<Self>
     where
-        (NoPin, RX): Pins<Self>;
+        NoPin: Into<Self::Tx>;
 }
 
 impl<CAN: Instance> CanExt for CAN {
-    fn can<TX, RX>(self, pins: (TX, RX)) -> Can<Self, (TX, RX)>
-    where
-        (TX, RX): Pins<Self>,
-    {
+    fn can(self, pins: (impl Into<Self::Tx>, impl Into<Self::Rx>)) -> Can<Self> {
         Can::new(self, pins)
     }
-    fn tx<TX>(self, tx_pin: TX) -> Can<Self, (TX, NoPin)>
+
+    fn tx(self, tx_pin: impl Into<Self::Tx>) -> Can<Self>
     where
-        (TX, NoPin): Pins<Self>,
+        NoPin: Into<Self::Rx>,
     {
         Can::tx(self, tx_pin)
     }
-    fn rx<RX>(self, rx_pin: RX) -> Can<Self, (NoPin, RX)>
+
+    fn rx(self, rx_pin: impl Into<Self::Rx>) -> Can<Self>
     where
-        (NoPin, RX): Pins<Self>,
+        NoPin: Into<Self::Tx>,
     {
         Can::rx(self, rx_pin)
     }
 }
 
 /// Interface to the CAN peripheral.
-pub struct Can<CAN, PINS> {
+pub struct Can<CAN: Instance> {
     can: CAN,
-    pins: PINS,
+    pins: (CAN::Tx, CAN::Rx),
 }
 
-impl<CAN, TX, RX> Can<CAN, (TX, RX)>
-where
-    CAN: Instance,
-    (TX, RX): Pins<CAN>,
-{
+impl<CAN: Instance> Can<CAN> {
     /// Creates a CAN interface.
-    pub fn new(can: CAN, mut pins: (TX, RX)) -> Self {
+    pub fn new(can: CAN, pins: (impl Into<CAN::Tx>, impl Into<CAN::Rx>)) -> Self {
         unsafe {
             // NOTE(unsafe) this reference will only be used for atomic writes with no side effects.
             let rcc = &(*crate::pac::RCC::ptr());
             CAN::enable(rcc);
             CAN::reset(rcc);
         }
 
-        pins.set_alt_mode();
+        let pins = (pins.0.into(), pins.1.into());
 
         Can { can, pins }
     }
 
-    pub fn release(mut self) -> (CAN, (TX, RX)) {
-        self.pins.restore_mode();
-
-        (self.can, (self.pins.0, self.pins.1))
+    pub fn release<TX, RX, E>(self) -> Result<(CAN, (TX, RX)), E>
+    where
+        TX: TryFrom<CAN::Tx, Error = E>,
+        RX: TryFrom<CAN::Rx, Error = E>,
+    {
+        Ok((self.can, (self.pins.0.try_into()?, self.pins.1.try_into()?)))
     }
 }
 
-impl<CAN, TX> Can<CAN, (TX, NoPin)>
-where
-    CAN: Instance,
-    (TX, NoPin): Pins<CAN>,
-{
-    pub fn tx(usart: CAN, tx_pin: TX) -> Self {
+impl<CAN: Instance> Can<CAN> {
+    pub fn tx(usart: CAN, tx_pin: impl Into<CAN::Tx>) -> Self
+    where
+        NoPin: Into<CAN::Rx>,
+    {
         Self::new(usart, (tx_pin, NoPin))
     }
 }
 
-impl<CAN, RX> Can<CAN, (NoPin, RX)>
-where
-    CAN: Instance,
-    (NoPin, RX): Pins<CAN>,
-{
-    pub fn rx(usart: CAN, rx_pin: RX) -> Self {
+impl<CAN: Instance> Can<CAN> {
+    pub fn rx(usart: CAN, rx_pin: impl Into<CAN::Rx>) -> Self
+    where
+        NoPin: Into<CAN::Tx>,
+    {
         Self::new(usart, (NoPin, rx_pin))
     }
 }
 
-unsafe impl<PINS> bxcan::Instance for Can<CAN1, PINS> {
+unsafe impl bxcan::Instance for Can<CAN1> {
     const REGISTERS: *mut bxcan::RegisterBlock = CAN1::ptr() as *mut _;
 }
 
-unsafe impl<PINS> bxcan::Instance for Can<CAN2, PINS> {
+unsafe impl bxcan::Instance for Can<CAN2> {
     const REGISTERS: *mut bxcan::RegisterBlock = CAN2::ptr() as *mut _;
 }
 
-unsafe impl<PINS> bxcan::FilterOwner for Can<CAN1, PINS> {
+unsafe impl bxcan::FilterOwner for Can<CAN1> {
     const NUM_FILTER_BANKS: u8 = 28;
 }
 
-unsafe impl<PINS> bxcan::MasterInstance for Can<CAN1, PINS> {}
+unsafe impl bxcan::MasterInstance for Can<CAN1> {}