update pin alternate function mapping

Author: dotcypress

.vscode/settings.json

@@ -1,9 +1,6 @@
 {
-  "rust-analyzer.checkOnSave.allTargets": false,
-  "rust-analyzer.checkOnSave.extraArgs": [
-      "--target",
-      "thumbv6m-none-eabi"
-  ],
+  "rust-analyzer.check.allTargets": false,
+  "rust-analyzer.cargo.target": "thumbv6m-none-eabi",
   "rust-analyzer.cargo.features": [
     "rt",
     "stm32c031"

LICENSE-MIT

@@ -1,6 +1,6 @@
 MIT LICENSE
 
-Copyright (c) 2022 Vitaly Domnikov <[email protected]>
+Copyright (c) 2022-2023 Vitaly Domnikov <[email protected]>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

examples/blinky.rs

@@ -15,7 +15,7 @@ fn main() -> ! {
     let dp = stm32::Peripherals::take().expect("cannot take peripherals");
     let mut rcc = dp.RCC.constrain();
     let port_a = dp.GPIOA.split(&mut rcc);
-    let mut led = port_a.pa0.into_push_pull_output();
+    let mut led = port_a.pa5.into_push_pull_output();
     loop {
         led.toggle().unwrap();
         for _ in 0..1_000_000 {

examples/button.rs

@@ -15,9 +15,10 @@ fn main() -> ! {
     let dp = stm32::Peripherals::take().expect("cannot take peripherals");
     let mut rcc = dp.RCC.constrain();
     let port_a = dp.GPIOA.split(&mut rcc);
+    let port_c = dp.GPIOC.split(&mut rcc);
 
-    let button = port_a.pa1.into_pull_up_input();
-    let mut led = port_a.pa0.into_push_pull_output();
+    let button = port_c.pc13.into_pull_up_input();
+    let mut led = port_a.pa5.into_push_pull_output();
 
     loop {
         if button.is_high().unwrap() {

src/analog/adc.rs

@@ -432,8 +432,11 @@ macro_rules! int_adc {
 }
 
 int_adc! {
-    VTemp: (12, tsen),
-    VRef: (13, vrefen),
+    //TODO; check channel ids
+    VTemp: (9, tsen),
+    VRef: (10, vrefen),
+    // Vdda: (15, --),
+    // Vssa: (16, --),
 }
 
 macro_rules! adc_pin {
@@ -457,13 +460,18 @@ adc_pin! {
     Channel5: (PA5<Analog>, 5u8),
     Channel6: (PA6<Analog>, 6u8),
     Channel7: (PA7<Analog>, 7u8),
-    Channel8: (PB0<Analog>, 8u8),
-    Channel9: (PB1<Analog>, 9u8),
-    Channel10: (PB2<Analog>, 10u8),
-    Channel11: (PB10<Analog>, 11u8),
-    Channel11: (PB7<Analog>, 11u8),
-    Channel15: (PB11<Analog>, 15u8),
-    Channel16: (PB12<Analog>, 16u8),
-    Channel17: (PC4<Analog>, 17u8),
-    Channel18: (PC5<Analog>, 18u8),
+    Channel8: (PA8<Analog>, 8u8),
+    // Channel9: (<Analog>, 9u8),
+    // Channel10: (<Analog>, 10u8),
+    Channel11: (PA11<Analog>, 11u8),
+    Channel12: (PA12<Analog>, 12u8),
+    Channel13: (PA13<Analog>, 13u8),
+    Channel14: (PA14<Analog>, 14u8),
+    //TODO check sequecer
+    Channel17: (PB0<Analog>, 17u8),
+    Channel18: (PB1<Analog>, 18u8),
+    Channel19: (PB2<Analog>, 19u8),
+    Channel20: (PB10<Analog>, 20u8),
+    Channel21: (PB11<Analog>, 21u8),
+    Channel22: (PB12<Analog>, 22u8),
 }

src/gpio.rs

@@ -180,6 +180,14 @@ pub(crate) enum AltFunction {
     AF5 = 5,
     AF6 = 6,
     AF7 = 7,
+    AF8 = 8,
+    AF9 = 9,
+    AF10 = 10,
+    AF11 = 11,
+    AF12 = 12,
+    AF13 = 13,
+    AF14 = 14,
+    AF15 = 15,
 }
 
 macro_rules! gpio {

src/serial/usart.rs

@@ -298,7 +298,6 @@ macro_rules! uart_shared {
         }
 
         // impl Tx<$USARTX> {
-
         //     /// Starts listening for an interrupt event
         //     pub fn listen(&mut self) {
         //         let usart = unsafe { &(*$USARTX::ptr()) };
@@ -316,7 +315,6 @@ macro_rules! uart_shared {
         //         let usart = unsafe { &(*$USARTX::ptr()) };
         //         usart.isr.read().txe().bit_is_set()
         //     }
-
         // }
 
         // impl hal::serial::Write<u8> for Tx<$USARTX> {
@@ -354,7 +352,6 @@ macro_rules! uart_shared {
         //     }
         // }
 
-
         impl Serial<$USARTX> {
 
             /// Separates the serial struct into separate channel objects for sending (Tx) and
@@ -533,35 +530,45 @@ macro_rules! uart {
 
 uart_shared!(USART1, USART1_RX, USART1_TX,
     tx: [
+        (PA0, AltFunction::AF4),
         (PA9, AltFunction::AF1),
         (PB6, AltFunction::AF0),
-        (PC4, AltFunction::AF1),
+        (PC14, AltFunction::AF0),
     ],
     rx: [
+        (PA1, AltFunction::AF4),
+        (PA8, AltFunction::AF14),
         (PA10, AltFunction::AF1),
+        (PB2, AltFunction::AF0),
         (PB7, AltFunction::AF0),
-        (PC5, AltFunction::AF1),
     ],
     de: [
         (PA12, AltFunction::AF1),
+        (PA14, AltFunction::AF12),
+        (PA15, AltFunction::AF4),
         (PB3, AltFunction::AF4),
+        (PB6, AltFunction::AF4),
     ]
 );
 
 uart_shared!(USART2, USART2_RX, USART2_TX,
     tx: [
         (PA2, AltFunction::AF1),
+        (PA4, AltFunction::AF1),
+        (PA8, AltFunction::AF1),
         (PA14, AltFunction::AF1),
-        (PD5, AltFunction::AF0),
     ],
     rx: [
         (PA3, AltFunction::AF1),
-        (PA15, AltFunction::AF1),
-        (PD6, AltFunction::AF0),
+        (PA5, AltFunction::AF1),
+        (PA13, AltFunction::AF4),
+        (PA14, AltFunction::AF9),
+        (PA15, AltFunction::AF1), 
     ],
     de: [
         (PA1, AltFunction::AF1),
-        (PD4, AltFunction::AF0),
+        (PB9, AltFunction::AF1),
+        (PC14, AltFunction::AF9),
     ]
 );
 

src/spi.rs

@@ -277,26 +277,27 @@ macro_rules! spi {
     }
 }
 
+
 spi!(
     SPI,
     spi1,
     sck: [
         (PA1<DefaultMode>, AltFunction::AF0),
         (PA5<DefaultMode>, AltFunction::AF0),
         (PB3<DefaultMode>, AltFunction::AF0),
-        (PD8<DefaultMode>, AltFunction::AF1),
+        (PB6<DefaultMode>, AltFunction::AF10),
     ],
     miso: [
         (PA6<DefaultMode>, AltFunction::AF0),
         (PA11<DefaultMode>, AltFunction::AF0),
         (PB4<DefaultMode>, AltFunction::AF0),
-        (PD5<DefaultMode>, AltFunction::AF1),
+        (PB6<DefaultMode>, AltFunction::AF9),
     ],
     mosi: [
         (PA2<DefaultMode>, AltFunction::AF0),
         (PA7<DefaultMode>, AltFunction::AF0),
         (PA12<DefaultMode>, AltFunction::AF0),
         (PB5<DefaultMode>, AltFunction::AF0),
-        (PD6<DefaultMode>, AltFunction::AF1),
+        (PB6<DefaultMode>, AltFunction::AF8),
     ],
 );

src/watchdog.rs

@@ -14,6 +14,7 @@ impl IndependedWatchdog {
     }
 
     pub fn start(&mut self, period: MicroSecond) {
+        //TODO: check IndependedWatchdog clocks
         let mut cycles = crate::time::cycles(period, 16_384.Hz());
         let mut psc = 0;
         let mut reload = 0;
@@ -147,6 +148,7 @@ pub trait WWDGExt {
 impl WWDGExt for WWDG {
     fn constrain(self, rcc: &mut Rcc) -> WindowWatchdog {
         WWDG::enable(rcc);
+        //TODO: check WWDG clock prescaler
         let clk = rcc.clocks.apb_clk.raw() / 4096;
         WindowWatchdog {
             wwdg: self,