Rename Random impl to Rng.

Create Random struct providing next_x(range) for all T:Rng.

embassy-stm32/src/rng.rs

@@ -19,11 +19,11 @@ pub enum Error {
     ClockError,
 }
 
-pub struct Random<T: Instance> {
+pub struct Rng<T: Instance> {
     _inner: T,
 }
 
-impl<T: Instance> Random<T> {
+impl<T: Instance> Rng<T> {
     pub fn new(inner: impl Unborrow<Target = T>) -> Self {
         T::enable();
         T::reset();
@@ -49,7 +49,7 @@ impl<T: Instance> Random<T> {
     }
 }
 
-impl<T: Instance> RngCore for Random<T> {
+impl<T: Instance> RngCore for Rng<T> {
     fn next_u32(&mut self) -> u32 {
         loop {
             let bits = unsafe { T::regs().sr().read() };
@@ -80,9 +80,9 @@ impl<T: Instance> RngCore for Random<T> {
     }
 }
 
-impl<T: Instance> CryptoRng for Random<T> {}
+impl<T: Instance> CryptoRng for Rng<T> {}
 
-impl<T: Instance> traits::rng::Rng for Random<T> {
+impl<T: Instance> traits::rng::Rng for Rng<T> {
     type Error = Error;
     #[rustfmt::skip]
     type RngFuture<'a> where Self: 'a = impl Future<Output=Result<(), Self::Error>> + 'a;
@@ -128,28 +128,6 @@ impl<T: Instance> traits::rng::Rng for Random<T> {
     }
 }
 
-impl<T: Instance> traits::rng::Random for Random<T> {
-    #[rustfmt::skip]
-    type NextFuture<'a> where Self: 'a = impl Future<Output=Result<u32, Self::Error>> + 'a;
-
-    fn next<'a>(&'a mut self, range: u32) -> Self::NextFuture<'a> {
-        async move {
-            let t = (-(range as i32) % (range as i32)) as u32;
-            loop {
-                let mut buf = [0; 4];
-                traits::rng::Rng::fill_bytes(self, &mut buf).await?;
-                let x = u32::from_le_bytes(buf);
-                let m = x as u64 * range as u64;
-                let l = m as u32;
-                if l < t {
-                    continue;
-                }
-                return Ok((m >> 32) as u32);
-            }
-        }
-    }
-}
-
 pub(crate) mod sealed {
     use super::*;
 

embassy-traits/src/rng.rs

@@ -17,11 +17,60 @@ pub trait Rng {
     fn fill_bytes<'a>(&'a mut self, dest: &'a mut [u8]) -> Self::RngFuture<'a>;
 }
 
-pub trait Random: Rng {
+pub struct Random<T: Rng> {
-    #[rustfmt::skip]
+    rng: T,
-    type NextFuture<'a>: Future<Output = Result<u32, <Self as Rng>::Error>> + 'a
+}
-    where
+
-        Self: 'a;
+impl<T: Rng> Random<T> {
-
+    pub fn new(rng: T) -> Self {
-    fn next<'a>(&'a mut self, range: u32) -> Self::NextFuture<'a>;
+        Self { rng }
+    }
+
+    pub async fn next_u8<'a>(&'a mut self, range: u8) -> Result<u8, T::Error> {
+        // Lemire's method
+        let t = (-(range as i8) % (range as i8)) as u8;
+        loop {
+            let mut buf = [0; 1];
+            self.rng.fill_bytes(&mut buf).await?;
+            let x = u8::from_le_bytes(buf);
+            let m = x as u16 * range as u16;
+            let l = m as u8;
+            if l < t {
+                continue;
+            }
+            return Ok((m >> 8) as u8);
+        }
+    }
+
+    pub async fn next_u16<'a>(&'a mut self, range: u16) -> Result<u16, T::Error> {
+        // Lemire's method
+        let t = (-(range as i16) % (range as i16)) as u16;
+        loop {
+            let mut buf = [0; 2];
+            self.rng.fill_bytes(&mut buf).await?;
+            let x = u16::from_le_bytes(buf);
+            let m = x as u32 * range as u32;
+            let l = m as u16;
+            if l < t {
+                continue;
+            }
+            return Ok((m >> 16) as u16);
+        }
+    }
+
+    pub async fn next_u32<'a>(&'a mut self, range: u32) -> Result<u32, T::Error> {
+        // Lemire's method
+        let t = (-(range as i32) % (range as i32)) as u32;
+        loop {
+            let mut buf = [0; 4];
+            self.rng.fill_bytes(&mut buf).await?;
+            let x = u32::from_le_bytes(buf);
+            let m = x as u64 * range as u64;
+            let l = m as u32;
+            if l < t {
+                continue;
+            }
+            return Ok((m >> 32) as u32);
+        }
+    }
 }

examples/stm32h7/src/bin/eth.rs

@@ -21,7 +21,7 @@ use embassy_net::{
 };
 use embassy_stm32::eth::lan8742a::LAN8742A;
 use embassy_stm32::eth::{Ethernet, State};
-use embassy_stm32::rng::Random;
+use embassy_stm32::rng::Rng;
 use embassy_stm32::{interrupt, peripherals};
 use heapless::Vec;
 use panic_probe as _;
@@ -81,7 +81,7 @@ fn _embassy_rand(buf: &mut [u8]) {
     });
 }
 
-static mut RNG_INST: Option<Random<RNG>> = None;
+static mut RNG_INST: Option<Rng<RNG>> = None;
 
 static EXECUTOR: Forever<Executor> = Forever::new();
 static STATE: Forever<State<'static, 4, 4>> = Forever::new();
@@ -97,7 +97,7 @@ fn main() -> ! {
 
     let p = embassy_stm32::init(config());
 
-    let rng = Random::new(p.RNG);
+    let rng = Rng::new(p.RNG);
     unsafe {
         RNG_INST.replace(rng);
     }

examples/stm32h7/src/bin/rng.rs

@@ -8,9 +8,9 @@
 mod example_common;
 use embassy::executor::Spawner;
 use embassy::time::{Duration, Timer};
-use embassy::traits::rng::Random as _;
 use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::rng::Random;
+use embassy_stm32::rng::Rng;
+use embassy::traits::rng::Random;
 use embassy_stm32::Peripherals;
 use embedded_hal::digital::v2::OutputPin;
 use example_common::*;
@@ -21,14 +21,14 @@ async fn main(_spawner: Spawner, p: Peripherals) {
 
     let mut led = Output::new(p.PB14, Level::High, Speed::Low);
 
-    let mut rng = Random::new(p.RNG);
+    let mut rng = Random::new(Rng::new(p.RNG));
 
     loop {
-        info!("high {}", unwrap!(rng.next(16).await));
+        info!("high {}", unwrap!(rng.next_u8(16).await));
         unwrap!(led.set_high());
         Timer::after(Duration::from_millis(500)).await;
 
-        info!("low {}", unwrap!(rng.next(16).await));
+        info!("low {}", unwrap!(rng.next_u8(16).await));
         unwrap!(led.set_low());
         Timer::after(Duration::from_millis(500)).await;
     }