Replace PRNG with hardware RNG

wled00/colors.cpp

@@ -103,93 +103,93 @@ 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_approximate(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_approximate(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) { 
-      palettecolors[i].saturation -= 160; //desaturate all four colors
-    }    
-    RGBpalettecolors[i] = (CRGB)palettecolors[i]; //convert to RGB
-    RGBpalettecolors[i] = gamma32(((uint32_t)RGBpalettecolors[i]) & 0x00FFFFFFU); //strip alpha from CRGB
+    if (makepastelpalette && palettecolors[i].saturation > 180) {
+      palettecolors[i].saturation -= 160; // desaturate all four colors
+    }
+    RGBpalettecolors[i] = (CRGB)palettecolors[i]; // convert to RGB
+    RGBpalettecolors[i] = gamma32(((uint32_t)RGBpalettecolors[i]) & 0x00FFFFFFU); // strip alpha from CRGB
   }
 
   return CRGBPalette16(RGBpalettecolors[0],
@@ -198,12 +198,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 colorHStoRGB(uint16_t hue, byte sat, byte* rgb) //hue, sat to rgb

wled00/fcn_declare.h

@@ -371,6 +371,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);
@@ -395,6 +401,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] == '~') {
@@ -437,29 +437,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;
@@ -479,7 +479,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
@@ -545,7 +545,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);
@@ -557,3 +557,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

@@ -540,14 +540,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();