Test of RGBW Branch

config/ci_exclude.json

@@ -1 +1 @@
-["heltecv3demo"]
+[]

config/partitions_custom.csv

@@ -1,12 +1,8 @@
-# ESP-IDF Partition Table
-# This gives us some additional space for code. 
-# It should also fix the OTA regression.  
-# Name,   Type, SubType,     Offset,      Size, Flags
-
-# Note that our NVS code assumes name 'storage' for the NVS partition
+# Standard 4M partition layout with OTA (Over the air updates)
 
+# Name,   Type, SubType,     Offset,      Size, Flags
 nvs,        data,   nvs,     0x00b000,    0x002000,
 otadata,    data,   ota,     0x00d000,    0x002000,
-app0,       app,    ota_0,   0x010000,    0x190000,
-app1,       app,    ota_1,   0x1A0000,    0x190000,
-storage,    data,   spiffs,  0x330000,    0x0D0000 
+app0,       app,    ota_0,   0x010000,    0x1A0000,
+app1,       app,    ota_1,   0x1B0000,    0x1A0000,
+storage,    data,   spiffs,  0x350000,    0x0B0000

include/deviceconfig.h

@@ -94,7 +94,9 @@
 
 #define DEVICE_CONFIG_FILE          "/device.cfg"
 #define NTP_SERVER_DEFAULT          "0.pool.ntp.org"
-#define BRIGHTNESS_MIN              uint8_t(10)
+#ifndef BRIGHTNESS_MIN
+    #define BRIGHTNESS_MIN          uint8_t(10)
+#endif
 #define BRIGHTNESS_MAX              uint8_t(255)
 #define POWER_LIMIT_MIN             1000
 #define POWER_LIMIT_DEFAULT         4500

include/effectmanager.h

@@ -153,9 +153,19 @@ class  EffectManager : public IJSONSerializable
         ClearEffects();
     }
 
-    std::shared_ptr<GFXBase> GetBaseGraphics()
+    // SetTempEffect - Sets a temporary effect to be played until remote changes it.
+    //                 The effect must have already had its Init() function called.
+
+    void SetTempEffect(std::shared_ptr<LEDStripEffect> effect)
+    {
+        _tempEffect = effect;
+    }
+
+    // GetBaseGraphics - Returns the vector of GFXBase objects that the effects use to draw
+
+    std::vector<std::shared_ptr<GFXBase>> & GetBaseGraphics()
     {
-        return _gfx[0];
+        return _gfx;
     }
 
     bool IsNewFrameAvailable() const

include/effects.h

@@ -83,6 +83,7 @@
 #define EFFECT_STRIP_FAN_BEAT                           37
 #define EFFECT_STRIP_SPLASH_LOGO                        38
 #define EFFECT_STRIP_VUMETER                            39
+#define EFFECT_STRIP_VUMETER_VERTICAL                   40
 
 // Matrix effects
 #define EFFECT_MATRIX_ALIEN_TEXT                       101
@@ -147,6 +148,7 @@
 #define EFFECT_MATRIX_STOCKS                           159
 #define EFFECT_MATRIX_SILON                            160
 #define EFFECT_MATRIX_PDPGRID                          161
+#define EFFECT_MATRIX_AUDIOSPIKE                       162
 
 // Hexagon Effects
 #define EFFECT_HEXAGON_OUTER_RING                      201
@@ -183,6 +185,7 @@
 #define PTY_SPARKS          "spc"
 #define PTY_SPARKING        "spg"
 #define PTY_SPARKHEIGHT     "sph"
+#define PTY_SPARKTEMP       "spt"
 #define PTY_COOLING         "clg"
 #define PTY_PALETTE         "plt"
 #define PTY_ORDER           "ord"
@@ -194,6 +197,7 @@
 #define PTY_MAXSPEED        "mxs"
 #define PTY_SPEEDDIVISOR    "sdd"
 #define PTY_DELTAHUE        "dth"
+#define PTY_MIRRORED        "mrd"
 #define PTY_EVERYNTH        "ent"
 #define PTY_COLOR           "clr"
 #define PTY_BLEND           "bld"

include/effects/matrix/spectrumeffects.h

@@ -120,14 +120,14 @@ class VUMeter
     //
     // Draw i-th pixel in row y
 
-    void DrawVUPixels(std::shared_ptr<GFXBase> pGFXChannel, int i, int yVU, int fadeBy = 0, const CRGBPalette16 * pPalette = nullptr)
+    virtual void DrawVUPixels(std::vector<std::shared_ptr<GFXBase>> & GFX, int i, int yVU, int fadeBy = 0, const CRGBPalette16 * pPalette = nullptr)
     {
         if (g_Analyzer.MicMode() == PeakData::PCREMOTE)
             pPalette = &vuPaletteBlue;
 
-        int xHalf = pGFXChannel->width()/2;
-        pGFXChannel->setPixel(xHalf-i-1, yVU, ColorFromPalette(pPalette ? *pPalette : vu_gpGreen,  i*(256/xHalf)).fadeToBlackBy(fadeBy));
-        pGFXChannel->setPixel(xHalf+i,   yVU, ColorFromPalette(pPalette ? *pPalette : vu_gpGreen, i*(256/xHalf)).fadeToBlackBy(fadeBy));
+        int xHalf = GFX[0]->width()/2;
+        GFX[0]->setPixel(xHalf-i-1, yVU, ColorFromPalette(pPalette ? *pPalette : vu_gpGreen,  i*(256/xHalf)).fadeToBlackBy(fadeBy));
+        GFX[0]->setPixel(xHalf+i,   yVU, ColorFromPalette(pPalette ? *pPalette : vu_gpGreen, i*(256/xHalf)).fadeToBlackBy(fadeBy));
     }
 
 
@@ -140,25 +140,25 @@ class VUMeter
 
   public:
 
-    inline void EraseVUMeter(std::shared_ptr<GFXBase> pGFXChannel, int start, int yVU) const
+    virtual inline void EraseVUMeter(std::vector<std::shared_ptr<GFXBase>> & GFX, int start, int yVU) const
     {
-        int xHalf = pGFXChannel->width()/2;
+        int xHalf = GFX[0]->width()/2;
         for (int i = start; i <= xHalf; i++)
         {
-            pGFXChannel->setPixel(xHalf-i,   yVU, CRGB::Black);
-            pGFXChannel->setPixel(xHalf-1+i,   yVU, CRGB::Black);
+            GFX[0]->setPixel(xHalf-i, yVU, CRGB::Black);
+            GFX[0]->setPixel(xHalf-1+i, yVU, CRGB::Black);
         }
     }
 
-    void DrawVUMeter(std::shared_ptr<GFXBase> pGFXChannel, int yVU, const CRGBPalette16 * pPalette = nullptr)
+    virtual void DrawVUMeter(std::vector<std::shared_ptr<GFXBase>> & GFX, int yVU = 0, const CRGBPalette16 * pPalette = nullptr)
     {
         const int MAX_FADE = 256;
 
-        int xHalf = pGFXChannel->width()/2-1;
+        int xHalf = GFX[0]->width()/2-1;
         int bars  = g_Analyzer._VURatioFade / 2.0 * xHalf; 
         bars = min(bars, xHalf);
 
-        EraseVUMeter(pGFXChannel, bars, yVU);
+        EraseVUMeter(GFX, bars, yVU);
 
         if (bars >= iPeakVUy)
         {
@@ -173,21 +173,74 @@ class VUMeter
         if (iPeakVUy > 1)
         {
             int fade = MAX_FADE * (millis() - msPeakVU) / (float) MS_PER_SECOND * 2;
-            DrawVUPixels(pGFXChannel, iPeakVUy,   yVU, fade);
-            DrawVUPixels(pGFXChannel, iPeakVUy-1, yVU, fade);
+            DrawVUPixels(GFX, iPeakVUy,   yVU, fade);
+            DrawVUPixels(GFX, iPeakVUy-1, yVU, fade);
         }
 
         for (int i = 0; i < bars; i++)
-            DrawVUPixels(pGFXChannel, i, yVU, i > bars ? 255 : 0, pPalette);
+            DrawVUPixels(GFX, i, yVU, i > bars ? 255 : 0, pPalette);
     }
 };
 
+class VUMeterVertical : public VUMeter
+{
+private:    
+    virtual inline void EraseVUMeter(std::vector<std::shared_ptr<GFXBase>> & GFX, int start, int yVU) const
+    {
+        for (int i = start; i <= GFX[0]->width(); i++)
+            for (auto& device : GFX)
+                device->setPixel(i, yVU, CRGB::Black);
+    }
+
+    // DrawVUPixels
+    //
+    // Draw i-th pixel in row y
+
+    virtual void DrawVUPixels(std::vector<std::shared_ptr<GFXBase>> & GFX, int i, int yVU, int fadeBy = 0, const CRGBPalette16 * pPalette = nullptr) override
+    {
+        for (auto& device : GFX)
+            device->setPixel(i, yVU, ColorFromPalette(pPalette ? *pPalette : vu_gpGreen,  i*256/GFX[0]->width()).fadeToBlackBy(fadeBy));
+    }
+
+public:
+    void DrawVUMeter(std::vector<std::shared_ptr<GFXBase>> & GFX, int yVU = 0, const CRGBPalette16 * pPalette = nullptr)
+    {
+        const int MAX_FADE = 256;
+
+        int size = GFX[0]->width();
+        int bars  = g_Analyzer._VURatioFade / 2.0 * size; 
+        bars = min(bars, size);
+
+        EraseVUMeter(GFX, bars, yVU);
+
+        if (bars >= iPeakVUy)
+        {
+            msPeakVU = millis();
+            iPeakVUy = bars;
+        }
+        else if (millis() - msPeakVU > MS_PER_SECOND / 2)
+        {
+            iPeakVUy = 0;
+        }
+
+        if (iPeakVUy > 1)
+        {
+            int fade = MAX_FADE * (millis() - msPeakVU) / (float) MS_PER_SECOND * 2;
+            DrawVUPixels(GFX, iPeakVUy,   yVU, fade);
+            DrawVUPixels(GFX, iPeakVUy-1, yVU, fade);
+        }
+
+        for (int i = 0; i < bars; i++)
+            DrawVUPixels(GFX, i, yVU, i > bars ? 255 : 0, pPalette);
+    }    
+};
+
 class VUMeterEffect : virtual public VUMeter, public LEDStripEffect
 {
 public:
     virtual void Draw() override
     {
-        DrawVUMeter(g(), 0);
+        DrawVUMeter(g_ptrSystem->EffectManager().GetBaseGraphics(), 0);
     }
 
     VUMeterEffect() : LEDStripEffect(EFFECT_STRIP_VUMETER, "VUMeter")
@@ -205,6 +258,28 @@ class VUMeterEffect : virtual public VUMeter, public LEDStripEffect
     }
 };
 
+class VUMeterVerticalEffect : virtual public VUMeterVertical, public LEDStripEffect
+{
+public:
+    virtual void Draw() override
+    {
+        DrawVUMeter(g_ptrSystem->EffectManager().GetBaseGraphics(), 0);
+    }
+
+    VUMeterVerticalEffect() : LEDStripEffect(EFFECT_STRIP_VUMETER_VERTICAL, "Vertical VUMeter")
+    {
+    }
+
+    VUMeterVerticalEffect(const JsonObjectConst& jsonObject)
+      : LEDStripEffect(jsonObject)
+    {
+    }
+
+    bool SerializeToJSON(JsonObject& jsonObject) override
+    {
+        return true;
+    }
+};
 // SpectrumAnalyzerEffect
 //
 // An effect that draws an audio spectrum analyzer on a matrix.  It is assumed that the
@@ -779,4 +854,64 @@ class SpectrumBarEffect : public LEDStripEffect, public BeatEffectBase
     }
 };
 
+// AudioSpikeEffect [MATRIX EFFECT]
+//
+// Simply displays the raw audio sample buffer as a waveform
+
+class AudioSpikeEffect : public LEDStripEffect
+{
+  protected:
+
+  public:
+
+    AudioSpikeEffect(const String & pszFriendlyName)
+        : LEDStripEffect(EFFECT_MATRIX_AUDIOSPIKE, pszFriendlyName)
+    {
+    }
+
+    AudioSpikeEffect(const JsonObjectConst& jsonObject)
+        : LEDStripEffect(jsonObject)
+    {
+    }
+
+    virtual bool SerializeToJSON(JsonObject& jsonObject) override
+    {
+        StaticJsonDocument<LEDStripEffect::_jsonSize> jsonDoc;
+
+        JsonObject root = jsonDoc.to<JsonObject>();
+        LEDStripEffect::SerializeToJSON(root);
+
+        assert(!jsonDoc.overflowed());
+        return jsonObject.set(jsonDoc.as<JsonObjectConst>());
+    }
+
+    virtual size_t DesiredFramesPerSecond() const override
+    {
+        return 60;
+    }
+
+    virtual void Draw() override
+    {
+        fadeAllChannelsToBlackBy(50);
+
+        static int colorOffset = 0;
+        colorOffset+= 4;
+
+        static int offset = 2; 
+
+        const int16_t * data = g_Analyzer.GetSampleBuffer();
+        int lastY = map(data[offset], 0, 2500, 0, MATRIX_HEIGHT);
+        for (int32_t x = 0; x < MATRIX_WIDTH; ++x)
+        {
+            byte y1 = map(data[offset+x], 0, 2500, 0, MATRIX_HEIGHT);
+            CRGB color = ColorFromPalette(spectrumBasicColors, (y1 * 4) + colorOffset, 255, NOBLEND);
+            g()->drawLine(x, lastY, x+1, y1, color);
+            lastY = y1;
+        }    
+        offset += MATRIX_WIDTH;
+        if (offset + MATRIX_WIDTH > g_Analyzer.GetSampleBufferSize())
+            offset = 2;
+    }
+};
+
 #endif