Merge #224

224: Correct Serial Baudrate calculation r=therealprof a=jamesmunns

I think the baudrate calculation before was... ~~really wrong~~ slightly misunderstood.

As far as I can tell, this new method is correct according to the stm32F411 datasheet, I'm not sure if the calculation is consistent across all stm32f4xx devices.

This was validated with an stm32f411, a pclk2 of 96MHz, and a baudrate of 12mbps.

Co-authored-by: James Munns <james.munns@ferrous-systems.com>

Author: bors[bot]

src/serial.rs

@@ -1424,10 +1424,61 @@ macro_rules! halUsartImpl {
                         bb::set(&rcc.$apbXenr, $rcc_bit);
                     }
 
+                    let pclk_freq = clocks.$pclkX().0;
+                    let baud = config.baudrate.0;
+
+                    // The frequency to calculate USARTDIV is this:
+                    //
+                    // (Taken from STM32F411xC/E Reference Manual,
+                    // Section 19.3.4, Equation 1)
+                    //
+                    // 16 bit oversample: OVER8 = 0
+                    // 8 bit oversample:  OVER8 = 1
+                    //
+                    // USARTDIV =          (pclk)
+                    //            ------------------------
+                    //            8 x (2 - OVER8) x (baud)
+                    //
+                    // BUT, the USARTDIV has 4 "fractional" bits, which effectively
+                    // means that we need to "correct" the equation as follows:
+                    //
+                    // USARTDIV =      (pclk) * 16
+                    //            ------------------------
+                    //            8 x (2 - OVER8) x (baud)
+                    //
+                    // When OVER8 is enabled, we can only use the lowest three
+                    // fractional bits, so we'll need to shift those last four bits
+                    // right one bit
+
                     // Calculate correct baudrate divisor on the fly
-                    let div = (clocks.$pclkX().0 + config.baudrate.0 / 2)
-                        / config.baudrate.0;
-                    usart.brr.write(|w| unsafe { w.bits(div) });
+                    let (over8, div) = if (pclk_freq / 16) >= baud {
+                        // We have the ability to oversample to 16 bits, take
+                        // advantage of it.
+                        //
+                        // We also add `baud / 2` to the `pclk_freq` to ensure
+                        // rounding of values to the closest scale, rather than the
+                        // floored behavior of normal integer division.
+                        let div = (pclk_freq + (baud / 2)) / baud;
+                        (false, div)
+                    } else if (pclk_freq / 8) >= baud {
+                        // We are close enough to pclk where we can only
+                        // oversample 8.
+                        //
+                        // See note above regarding `baud` and rounding.
+                        let div = ((pclk_freq * 2) + (baud / 2)) / baud;
+
+                        // Ensure the the fractional bits (only 3) are
+                        // right-aligned.
+                        let frac = (div & 0xF);
+                        let div = (div & !0xF) | (frac >> 1);
+                        (true, div)
+                    } else {
+                        return Err(config::InvalidConfig)
+                    };
+
+                    usart.brr.write(|w| unsafe {
+                        w.bits(div)
+                    });
 
                     // Reset other registers to disable advanced USART features
                     usart.cr2.reset();
@@ -1438,6 +1489,8 @@ macro_rules! halUsartImpl {
                     usart.cr1.write(|w| {
                         w.ue()
                             .set_bit()
+                            .over8()
+                            .bit(over8)
                             .te()
                             .set_bit()
                             .re()