Replace PRNG with hardware RNG (#4225)

Both ESP8266 and ESP32 have a hardware random register. This update makes use of that. It is slightly faster than the fastled variants but mostly it is truly random, even when the timing limitations stated in the datasheet are disregarded. Also saves a bit on code size.

- Replaced all random8() and random16() calls with new hw_random() versions
- Not replaced in FX where PRNG is required

wled00/colors.cpp

@@ -124,86 +124,86 @@ void setRandomColor(byte* rgb)
  */
 CRGBPalette16 generateHarmonicRandomPalette(CRGBPalette16 &basepalette)
 {
-  CHSV palettecolors[4]; //array of colors for the new palette
-  uint8_t keepcolorposition = random8(4); //color position of current random palette to keep
-  palettecolors[keepcolorposition] = rgb2hsv(basepalette.entries[keepcolorposition*5]); //read one of the base colors of the current palette
-  palettecolors[keepcolorposition].hue += random8(10)-5; // +/- 5 randomness of base color
-  //generate 4 saturation and brightness value numbers
-  //only one saturation is allowed to be below 200 creating mostly vibrant colors
-  //only one brightness value number is allowed below 200, creating mostly bright palettes
-
-  for (int i = 0; i < 3; i++) { //generate three high values
-    palettecolors[i].saturation = random8(200,255);
-    palettecolors[i].value = random8(220,255);
+  CHSV palettecolors[4]; // array of colors for the new palette
+  uint8_t keepcolorposition = hw_random8(4); // color position of current random palette to keep
+  palettecolors[keepcolorposition] = rgb2hsv(basepalette.entries[keepcolorposition*5]); // read one of the base colors of the current palette
+  palettecolors[keepcolorposition].hue += hw_random8(10)-5; // +/- 5 randomness of base color
+  // generate 4 saturation and brightness value numbers
+  // only one saturation is allowed to be below 200 creating mostly vibrant colors
+  // only one brightness value number is allowed below 200, creating mostly bright palettes
+
+  for (int i = 0; i < 3; i++) { // generate three high values
+    palettecolors[i].saturation = hw_random8(200,255);
+    palettecolors[i].value = hw_random8(220,255);
   }
-  //allow one to be lower
-  palettecolors[3].saturation = random8(20,255);
-  palettecolors[3].value = random8(80,255);
+  // allow one to be lower
+  palettecolors[3].saturation = hw_random8(20,255);
+  palettecolors[3].value = hw_random8(80,255);
 
-  //shuffle the arrays
+  // shuffle the arrays
   for (int i = 3; i > 0; i--) {
-    std::swap(palettecolors[i].saturation, palettecolors[random8(i + 1)].saturation);
-    std::swap(palettecolors[i].value, palettecolors[random8(i + 1)].value);
+    std::swap(palettecolors[i].saturation, palettecolors[hw_random8(i + 1)].saturation);
+    std::swap(palettecolors[i].value, palettecolors[hw_random8(i + 1)].value);
   }
 
-  //now generate three new hues based off of the hue of the chosen current color
+  // now generate three new hues based off of the hue of the chosen current color
   uint8_t basehue = palettecolors[keepcolorposition].hue;
-  uint8_t harmonics[3]; //hues that are harmonic but still a little random
-  uint8_t type = random8(5); //choose a harmony type
+  uint8_t harmonics[3]; // hues that are harmonic but still a little random
+  uint8_t type = hw_random8(5); // choose a harmony type
 
   switch (type) {
     case 0: // analogous
-      harmonics[0] = basehue + random8(30, 50);
-      harmonics[1] = basehue + random8(10, 30);
-      harmonics[2] = basehue - random8(10, 30);
+      harmonics[0] = basehue + hw_random8(30, 50);
+      harmonics[1] = basehue + hw_random8(10, 30);
+      harmonics[2] = basehue - hw_random8(10, 30);
       break;
 
     case 1: // triadic
-      harmonics[0] = basehue + 113 + random8(15);
-      harmonics[1] = basehue + 233 + random8(15);
-      harmonics[2] = basehue -   7 + random8(15);
+      harmonics[0] = basehue + 113 + hw_random8(15);
+      harmonics[1] = basehue + 233 + hw_random8(15);
+      harmonics[2] = basehue -   7 + hw_random8(15);
       break;
 
     case 2: // split-complementary
-      harmonics[0] = basehue + 145 + random8(10);
-      harmonics[1] = basehue + 205 + random8(10);
-      harmonics[2] = basehue -   5 + random8(10);
+      harmonics[0] = basehue + 145 + hw_random8(10);
+      harmonics[1] = basehue + 205 + hw_random8(10);
+      harmonics[2] = basehue -   5 + hw_random8(10);
       break;
 
     case 3: // square
-      harmonics[0] = basehue +  85 + random8(10);
-      harmonics[1] = basehue + 175 + random8(10);
-      harmonics[2] = basehue + 265 + random8(10);
+      harmonics[0] = basehue +  85 + hw_random8(10);
+      harmonics[1] = basehue + 175 + hw_random8(10);
+      harmonics[2] = basehue + 265 + hw_random8(10);
      break;
 
     case 4: // tetradic
-      harmonics[0] = basehue +  80 + random8(20);
-      harmonics[1] = basehue + 170 + random8(20);
-      harmonics[2] = basehue -  15 + random8(30);
+      harmonics[0] = basehue +  80 + hw_random8(20);
+      harmonics[1] = basehue + 170 + hw_random8(20);
+      harmonics[2] = basehue -  15 + hw_random8(30);
      break;
   }
 
-  if (random8() < 128) {
-    //50:50 chance of shuffling hues or keep the color order
+  if (hw_random8() < 128) {
+    // 50:50 chance of shuffling hues or keep the color order
     for (int i = 2; i > 0; i--) {
-      std::swap(harmonics[i], harmonics[random8(i + 1)]);
+      std::swap(harmonics[i], harmonics[hw_random8(i + 1)]);
     }
   }
 
-  //now set the hues
+  // now set the hues
   int j = 0;
   for (int i = 0; i < 4; i++) {
-    if (i==keepcolorposition) continue; //skip the base color
+    if (i==keepcolorposition) continue; // skip the base color
     palettecolors[i].hue = harmonics[j];
     j++;
   }
 
   bool makepastelpalette = false;
-  if (random8() < 25) { //~10% chance of desaturated 'pastel' colors
+  if (hw_random8() < 25) { // ~10% chance of desaturated 'pastel' colors
     makepastelpalette = true;
   }
 
-  //apply saturation & gamma correction
+  // apply saturation & gamma correction
   CRGB RGBpalettecolors[4];
   for (int i = 0; i < 4; i++) {
     if (makepastelpalette && palettecolors[i].saturation > 180) {
@@ -219,12 +219,12 @@ CRGBPalette16 generateHarmonicRandomPalette(CRGBPalette16 &basepalette)
                        RGBpalettecolors[3]);
 }
 
-CRGBPalette16 generateRandomPalette()  //generate fully random palette
+CRGBPalette16 generateRandomPalette()  // generate fully random palette
 {
-  return CRGBPalette16(CHSV(random8(), random8(160, 255), random8(128, 255)),
-                       CHSV(random8(), random8(160, 255), random8(128, 255)),
-                       CHSV(random8(), random8(160, 255), random8(128, 255)),
-                       CHSV(random8(), random8(160, 255), random8(128, 255)));
+  return CRGBPalette16(CHSV(hw_random8(), hw_random8(160, 255), hw_random8(128, 255)),
+                       CHSV(hw_random8(), hw_random8(160, 255), hw_random8(128, 255)),
+                       CHSV(hw_random8(), hw_random8(160, 255), hw_random8(128, 255)),
+                       CHSV(hw_random8(), hw_random8(160, 255), hw_random8(128, 255)));
 }
 
 void hsv2rgb(const CHSV32& hsv, uint32_t& rgb) // convert HSV (16bit hue) to RGB (32bit with white = 0)

wled00/fcn_declare.h

@@ -458,6 +458,12 @@ void userConnected();
 void userLoop();
 
 //util.cpp
+#ifdef ESP8266
+#define HW_RND_REGISTER RANDOM_REG32
+#else // ESP32 family
+#include "soc/wdev_reg.h"
+#define HW_RND_REGISTER REG_READ(WDEV_RND_REG)
+#endif
 int getNumVal(const String* req, uint16_t pos);
 void parseNumber(const char* str, byte* val, byte minv=0, byte maxv=255);
 bool getVal(JsonVariant elem, byte* val, byte minv=0, byte maxv=255); // getVal supports inc/decrementing and random ("X~Y(r|~[w][-][Z])" form)
@@ -485,6 +491,23 @@ void enumerateLedmaps();
 uint8_t get_random_wheel_index(uint8_t pos);
 float mapf(float x, float in_min, float in_max, float out_min, float out_max);
 
+// fast (true) random numbers using hardware RNG, all functions return values in the range lowerlimit to upperlimit-1
+// note: for true random numbers with high entropy, do not call faster than every 200ns (5MHz)
+// tests show it is still highly random reading it quickly in a loop (better than fastled PRNG)
+// for 8bit and 16bit random functions: no limit check is done for best speed
+// 32bit inputs are used for speed and code size, limits don't work if inverted or out of range
+// inlining does save code size except for random(a,b) and 32bit random with limits
+#define random hw_random // replace arduino random()
+inline uint32_t hw_random() { return HW_RND_REGISTER; };
+uint32_t hw_random(uint32_t upperlimit); // not inlined for code size
+int32_t hw_random(int32_t lowerlimit, int32_t upperlimit);
+inline uint16_t hw_random16() { return HW_RND_REGISTER; };
+inline uint16_t hw_random16(uint32_t upperlimit) { return (hw_random16() * upperlimit) >> 16; }; // input range 0-65535 (uint16_t)
+inline int16_t hw_random16(int32_t lowerlimit, int32_t upperlimit) { int32_t range = upperlimit - lowerlimit; return lowerlimit + hw_random16(range); }; // signed limits, use int16_t ranges
+inline uint8_t hw_random8() { return HW_RND_REGISTER; };
+inline uint8_t hw_random8(uint32_t upperlimit) { return (hw_random8() * upperlimit) >> 8; }; // input range 0-255
+inline uint8_t hw_random8(uint32_t lowerlimit, uint32_t upperlimit) { uint32_t range = upperlimit - lowerlimit; return lowerlimit + hw_random8(range); }; // input range 0-255
+
 // RAII guard class for the JSON Buffer lock
 // Modeled after std::lock_guard
 class JSONBufferGuard {

wled00/ir.cpp

@@ -593,7 +593,7 @@ static void decodeIRJson(uint32_t code)
         decBrightness();
       } else if (cmdStr.startsWith(F("!presetF"))) { //!presetFallback
         uint8_t p1 = fdo["PL"] | 1;
-        uint8_t p2 = fdo["FX"] | random8(strip.getModeCount() -1);
+        uint8_t p2 = fdo["FX"] | hw_random8(strip.getModeCount() -1);
         uint8_t p3 = fdo["FP"] | 0;
         presetFallback(p1, p2, p3);
       }

wled00/remote.cpp

@@ -146,7 +146,7 @@ static bool remoteJson(int button)
         parsed = true;
       } else if (cmdStr.startsWith(F("!presetF"))) { //!presetFallback
         uint8_t p1 = fdo["PL"] | 1;
-        uint8_t p2 = fdo["FX"] | random8(strip.getModeCount() -1);
+        uint8_t p2 = fdo["FX"] | hw_random8(strip.getModeCount() -1);
         uint8_t p3 = fdo["FP"] | 0;
         presetWithFallback(p1, p2, p3);
         parsed = true;

wled00/util.cpp

@@ -14,7 +14,7 @@ int getNumVal(const String* req, uint16_t pos)
 void parseNumber(const char* str, byte* val, byte minv, byte maxv)
 {
   if (str == nullptr || str[0] == '\0') return;
-  if (str[0] == 'r') {*val = random8(minv,maxv?maxv:255); return;} // maxv for random cannot be 0
+  if (str[0] == 'r') {*val = hw_random8(minv,maxv?maxv:255); return;} // maxv for random cannot be 0
   bool wrap = false;
   if (str[0] == 'w' && strlen(str) > 1) {str++; wrap = true;}
   if (str[0] == '~') {
@@ -474,29 +474,29 @@ um_data_t* simulateSound(uint8_t simulationId)
       break;
     case UMS_WeWillRockYou:
       if (ms%2000 < 200) {
-        volumeSmth = random8(255);
+        volumeSmth = hw_random8();
         for (int i = 0; i<5; i++)
-          fftResult[i] = random8(255);
+          fftResult[i] = hw_random8();
       }
       else if (ms%2000 < 400) {
         volumeSmth = 0;
         for (int i = 0; i<16; i++)
           fftResult[i] = 0;
       }
       else if (ms%2000 < 600) {
-        volumeSmth = random8(255);
+        volumeSmth = hw_random8();
         for (int i = 5; i<11; i++)
-          fftResult[i] = random8(255);
+          fftResult[i] = hw_random8();
       }
       else if (ms%2000 < 800) {
         volumeSmth = 0;
         for (int i = 0; i<16; i++)
           fftResult[i] = 0;
       }
       else if (ms%2000 < 1000) {
-        volumeSmth = random8(255);
+        volumeSmth = hw_random8();
         for (int i = 11; i<16; i++)
-          fftResult[i] = random8(255);
+          fftResult[i] = hw_random8();
       }
       else {
         volumeSmth = 0;
@@ -516,7 +516,7 @@ um_data_t* simulateSound(uint8_t simulationId)
       break;
   }
 
-  samplePeak    = random8() > 250;
+  samplePeak    = hw_random8() > 250;
   FFT_MajorPeak = 21 + (volumeSmth*volumeSmth) / 8.0f; // walk thru full range of 21hz...8200hz
   maxVol        = 31;  // this gets feedback fro UI
   binNum        = 8;   // this gets feedback fro UI
@@ -582,7 +582,7 @@ void enumerateLedmaps() {
 uint8_t get_random_wheel_index(uint8_t pos) {
   uint8_t r = 0, x = 0, y = 0, d = 0;
   while (d < 42) {
-    r = random8();
+    r = hw_random8();
     x = abs(pos - r);
     y = 255 - x;
     d = MIN(x, y);
@@ -594,3 +594,18 @@ uint8_t get_random_wheel_index(uint8_t pos) {
 float mapf(float x, float in_min, float in_max, float out_min, float out_max) {
   return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
 }
+
+// 32 bit random number generator, inlining uses more code, use hw_random16() if speed is critical (see fcn_declare.h)
+uint32_t hw_random(uint32_t upperlimit) {
+  uint32_t rnd = hw_random();
+  uint64_t scaled = uint64_t(rnd) * uint64_t(upperlimit);
+  return scaled >> 32;
+}
+
+int32_t hw_random(int32_t lowerlimit, int32_t upperlimit) {
+  if(lowerlimit >= upperlimit) {
+    return lowerlimit;
+  }
+  uint32_t diff = upperlimit - lowerlimit;
+  return hw_random(diff) + lowerlimit;
+}

wled00/wled.cpp

@@ -544,14 +544,8 @@ void WLED::setup()
 #endif
 
   // Seed FastLED random functions with an esp random value, which already works properly at this point.
-#if defined(ARDUINO_ARCH_ESP32)
-  const uint32_t seed32 = esp_random();
-#elif defined(ARDUINO_ARCH_ESP8266)
-  const uint32_t seed32 = RANDOM_REG32;
-#else
-  const uint32_t seed32 = random(std::numeric_limits<long>::max());
-#endif
-  random16_set_seed((uint16_t)((seed32 & 0xFFFF) ^ (seed32 >> 16)));
+  const uint32_t seed32 = hw_random();
+  random16_set_seed((uint16_t)seed32);
 
   #if WLED_WATCHDOG_TIMEOUT > 0
   enableWatchdog();