Use unwrap-infallible

After removing `void`, we're still missing a way to explicitly unwrap
infallible results such that it is clear that no panic can occur in this
location.  Because the standard library does not yet provide a solution
to this, let's use the `unwrap-infallible` crate [1] in the meantime.

This topic was also discussed in more detail in the embedded-hal project [2].

[1]: https://crates.io/crates/unwrap-infallible
[2]: rust-embedded/embedded-hal#329

avr-hal-generic/Cargo.toml

@@ -12,6 +12,7 @@ paste = "1.0.0"
 avr-device = "0.5.3"
 embedded-storage = "0.2"
 embedded-hal = "1.0"
+unwrap-infallible = "0.1.5"
 
 [dependencies.embedded-hal-v0]
 version = "0.2.3"

avr-hal-generic/src/adc.rs

@@ -132,7 +132,7 @@ impl<H, ADC: AdcOps<H>> AdcChannel<H, ADC> for Channel<H, ADC> {
 /// let voltage = adc.read_blocking(&a0);
 ///
 /// // alternatively, a non-blocking interface exists
-/// let voltage = nb::block!(adc.read_nonblocking(&a0)).unwrap();
+/// let voltage = nb::block!(adc.read_nonblocking(&a0)).unwrap_infallible();
 /// ```
 pub struct Adc<H, ADC: AdcOps<H>, CLOCK> {
     p: ADC,

avr-hal-generic/src/lib.rs

@@ -28,6 +28,7 @@ pub mod wdt;
 pub mod prelude {
     pub use hal::prelude::*;
     pub use ufmt::uWrite as _ufmt_uWrite;
+    pub use unwrap_infallible::UnwrapInfallible as _unwrap_infallible_UnwrapInfallible;
 }
 
 // For making certain traits unimplementable from outside this crate.

avr-hal-generic/src/usart.rs

@@ -4,6 +4,7 @@
 
 use core::cmp::Ordering;
 use core::marker;
+use crate::prelude::*;
 
 use crate::port;
 
@@ -219,11 +220,11 @@ pub trait UsartOps<H, RX, TX> {
 ///     57600.into_baudrate(),
 /// );
 ///
-/// ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap();
+/// ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap_infallible();
 ///
 /// loop {
-///     let b = nb::block!(serial.read()).unwrap();
-///     ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap();
+///     let b = nb::block!(serial.read()).unwrap_infallible();
+///     ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap_infallible();
 /// }
 /// ```
 pub struct Usart<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> {
@@ -278,22 +279,22 @@ impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> Usart<H, USART, RX, TX, CLOCK
 
     /// Block until all remaining data has been transmitted.
     pub fn flush(&mut self) {
-        nb::block!(self.p.raw_flush()).unwrap()
+        nb::block!(self.p.raw_flush()).unwrap_infallible()
     }
 
     /// Transmit a byte.
     ///
     /// This method will block until the byte has been enqueued for transmission but **not** until
     /// it was entirely sent.
     pub fn write_byte(&mut self, byte: u8) {
-        nb::block!(self.p.raw_write(byte)).unwrap()
+        nb::block!(self.p.raw_write(byte)).unwrap_infallible()
     }
 
     /// Receive a byte.
     ///
     /// This method will block until a byte could be received.
     pub fn read_byte(&mut self) -> u8 {
-        nb::block!(self.p.raw_read()).unwrap()
+        nb::block!(self.p.raw_read()).unwrap_infallible()
     }
 
     /// Enable the interrupt for [`Event`].
@@ -437,7 +438,7 @@ impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> ufmt::uWrite
 
     fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
         for b in s.as_bytes().iter() {
-            nb::block!(self.p.raw_write(*b)).unwrap()
+            nb::block!(self.p.raw_write(*b)).unwrap_infallible()
         }
         Ok(())
     }

examples/arduino-diecimila/src/bin/diecimila-adc.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use arduino_hal::adc;
@@ -17,8 +18,8 @@ fn main() -> ! {
         adc.read_blocking(&adc::channel::Vbg),
         adc.read_blocking(&adc::channel::Gnd),
     );
-    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap();
-    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap();
+    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap_infallible();
 
     // To store multiple channels in an array, we use the `into_channel()` method.
     let channels: [adc::Channel; 6] = [
@@ -33,10 +34,10 @@ fn main() -> ! {
     loop {
         for (i, ch) in channels.iter().enumerate() {
             let v = adc.read_blocking(ch);
-            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap();
+            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap_infallible();
         }
 
-        ufmt::uwriteln!(&mut serial, "").unwrap();
+        ufmt::uwriteln!(&mut serial, "").unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }

examples/arduino-diecimila/src/bin/diecimila-i2cdetect.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 #[arduino_hal::entry]
@@ -16,12 +17,12 @@ fn main() -> ! {
         50000,
     );
 
-    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap();
+    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap_infallible();
     i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Write)
-        .unwrap();
-    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap();
+        .unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap_infallible();
     i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Read)
-        .unwrap();
+        .unwrap_infallible();
 
     loop {}
 }

examples/arduino-diecimila/src/bin/diecimila-spi-feedback.rs

@@ -15,6 +15,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use arduino_hal::spi;
 use embedded_hal_v0::spi::FullDuplex;
 use panic_halt as _;
@@ -39,11 +40,11 @@ fn main() -> ! {
 
     loop {
         // Send a byte
-        nb::block!(spi.send(0b00001111)).unwrap();
+        nb::block!(spi.send(0b00001111)).unwrap_infallible();
         // Because MISO is connected to MOSI, the read data should be the same
-        let data = nb::block!(spi.read()).unwrap();
+        let data = nb::block!(spi.read()).unwrap_infallible();
 
-        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap();
+        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }

examples/arduino-diecimila/src/bin/diecimila-usart.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use embedded_hal_v0::serial::Read;
@@ -11,13 +12,13 @@ fn main() -> ! {
     let pins = arduino_hal::pins!(dp);
     let mut serial = arduino_hal::default_serial!(dp, pins, 57600);
 
-    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap();
+    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap_infallible();
 
     loop {
         // Read a byte from the serial connection default
-        let b = nb::block!(serial.read()).unwrap();
+        let b = nb::block!(serial.read()).unwrap_infallible();
 
         // Answer
-        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap();
+        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap_infallible();
     }
 }

examples/arduino-leonardo/src/bin/leonardo-adc.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use arduino_hal::adc;
@@ -18,9 +19,9 @@ fn main() -> ! {
         adc.read_blocking(&adc::channel::Gnd),
         adc.read_blocking(&adc::channel::Temperature),
     );
-    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap();
-    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap();
-    ufmt::uwriteln!(&mut serial, "Temperature: {}", tmp).unwrap();
+    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "Temperature: {}", tmp).unwrap_infallible();
 
     let a0 = pins.a0.into_analog_input(&mut adc);
     let a1 = pins.a1.into_analog_input(&mut adc);
@@ -40,10 +41,10 @@ fn main() -> ! {
         ];
 
         for (i, v) in values.iter().enumerate() {
-            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap();
+            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap_infallible();
         }
 
-        ufmt::uwriteln!(&mut serial, "").unwrap();
+        ufmt::uwriteln!(&mut serial, "").unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }

examples/arduino-leonardo/src/bin/leonardo-i2cdetect.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 #[arduino_hal::entry]
@@ -16,10 +17,10 @@ fn main() -> ! {
         50000,
     );
 
-    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap();
-    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Write).unwrap();
-    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap();
-    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Read).unwrap();
+    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap_infallible();
+    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Write).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap_infallible();
+    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Read).unwrap_infallible();
 
     loop {}
 }

examples/arduino-leonardo/src/bin/leonardo-spi-feedback.rs

@@ -15,6 +15,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use arduino_hal::spi;
 use embedded_hal_v0::spi::FullDuplex;
 use panic_halt as _;
@@ -39,11 +40,11 @@ fn main() -> ! {
 
     loop {
         // Send a byte
-        nb::block!(spi.send(0b00001111)).unwrap();
+        nb::block!(spi.send(0b00001111)).unwrap_infallible();
         // Because MISO is connected to MOSI, the read data should be the same
-        let data = nb::block!(spi.read()).unwrap();
+        let data = nb::block!(spi.read()).unwrap_infallible();
 
-        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap();
+        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }

examples/arduino-leonardo/src/bin/leonardo-usart.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use embedded_hal_v0::serial::Read;
@@ -11,13 +12,13 @@ fn main() -> ! {
     let pins = arduino_hal::pins!(dp);
     let mut serial = arduino_hal::default_serial!(dp, pins, 57600);
 
-    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap();
+    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap_infallible();
 
     loop {
         // Read a byte from the serial connection
-        let b = nb::block!(serial.read()).unwrap();
+        let b = nb::block!(serial.read()).unwrap_infallible();
 
         // Answer
-        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap();
+        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap_infallible();
     }
 }

examples/arduino-mega1280/src/bin/mega1280-adc.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use arduino_hal::adc;
@@ -17,8 +18,8 @@ fn main() -> ! {
         adc.read_blocking(&adc::channel::Vbg),
         adc.read_blocking(&adc::channel::Gnd),
     );
-    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap();
-    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap();
+    ufmt::uwriteln!(&mut serial, "Vbandgap: {}", vbg).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "Ground: {}", gnd).unwrap_infallible();
 
     // To store multiple channels in an array, we use the `into_channel()` method.
     let channels: [adc::Channel; 16] = [
@@ -43,10 +44,10 @@ fn main() -> ! {
     loop {
         for (i, ch) in channels.iter().enumerate() {
             let v = adc.read_blocking(ch);
-            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap();
+            ufmt::uwrite!(&mut serial, "A{}: {} ", i, v).unwrap_infallible();
         }
 
-        ufmt::uwriteln!(&mut serial, "").unwrap();
+        ufmt::uwriteln!(&mut serial, "").unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }

examples/arduino-mega1280/src/bin/mega1280-i2cdetect.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 #[arduino_hal::entry]
@@ -16,10 +17,10 @@ fn main() -> ! {
         50000,
     );
 
-    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap();
-    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Write).unwrap();
-    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap();
-    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Read).unwrap();
+    ufmt::uwriteln!(&mut serial, "Write direction test:\r").unwrap_infallible();
+    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Write).unwrap_infallible();
+    ufmt::uwriteln!(&mut serial, "\r\nRead direction test:\r").unwrap_infallible();
+    i2c.i2cdetect(&mut serial, arduino_hal::i2c::Direction::Read).unwrap_infallible();
 
     loop {}
 }

examples/arduino-mega1280/src/bin/mega1280-usart.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use panic_halt as _;
 
 use embedded_hal_v0::serial::Read;
@@ -11,13 +12,13 @@ fn main() -> ! {
     let pins = arduino_hal::pins!(dp);
     let mut serial = arduino_hal::default_serial!(dp, pins, 57600);
 
-    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap();
+    ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").unwrap_infallible();
 
     loop {
         // Read a byte from the serial connection
-        let b = nb::block!(serial.read()).unwrap();
+        let b = nb::block!(serial.read()).unwrap_infallible();
 
         // Answer
-        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap();
+        ufmt::uwriteln!(&mut serial, "Got {}!\r", b).unwrap_infallible();
     }
 }

examples/arduino-mega1280/src/bin/mega1280spi-feedback.rs

@@ -15,6 +15,7 @@
 #![no_std]
 #![no_main]
 
+use arduino_hal::prelude::*;
 use arduino_hal::spi;
 use embedded_hal_v0::spi::FullDuplex;
 use panic_halt as _;
@@ -39,11 +40,11 @@ fn main() -> ! {
 
     loop {
         // Send a byte
-        nb::block!(spi.send(0b00001111)).unwrap();
+        nb::block!(spi.send(0b00001111)).unwrap_infallible();
         // Because MISO is connected to MOSI, the read data should be the same
-        let data = nb::block!(spi.read()).unwrap();
+        let data = nb::block!(spi.read()).unwrap_infallible();
 
-        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap();
+        ufmt::uwriteln!(&mut serial, "data: {}\r", data).unwrap_infallible();
         arduino_hal::delay_ms(1000);
     }
 }