Merge pull request #101 from robertlipe/timing-precision

timing precision & adds aurora borealis effect

Author: rbergen

.github/workflows/CI.yml

@@ -49,6 +49,7 @@ jobs:
       # Killing ndscpp is a bit rude and technically unnecessary, but we've been
       # raised to clean up after ourselves, so that's what we do.
       run: |
+        make config.led
         ./ndscpp > /dev/null 2>&1 &
         sleep 1
         LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/lib ./tests/tests

Makefile

@@ -9,11 +9,15 @@ DEPFLAGS=-MT $@ -MMD -MP -MF $(DEPDIR)/$*.d
 
 SOURCES=main.cpp apihelpers.cpp
 EXECUTABLE=ndscpp
-CONFIG_FILES=config.led secrets.h
 DEPDIR=.deps
 OBJECTS:=$(SOURCES:.cpp=.o)
 DEPFILES:=$(SOURCES:%.cpp=$(DEPDIR)/%.d)
 
+# Runtime config files (don't trigger a rebuild)
+RUNTIME_CONFIG=config.led
+# Compile-time header dependencies
+COMPILE_CONFIG=secrets.h
+
 define helptext =
 Makefile for ndscpp
 
@@ -42,11 +46,11 @@ $(EXECUTABLE): $(OBJECTS)
 	@echo Linking $@...
 	@$(CC) $(LDFLAGS) $^ -o $@ $(LIBS)
 
-%.o: %.cpp $(CONFIG_FILES) $(DEPDIR)/%.d | $(DEPDIR)
+%.o: %.cpp $(COMPILE_CONFIG) $(DEPDIR)/%.d | $(DEPDIR)
 	@echo Compiling $<...
 	@$(CC) $(CFLAGS) $(DEPFLAGS) -c $< -o $@
 
-$(CONFIG_FILES): % : %.example
+$(RUNTIME_CONFIG) $(COMPILE_CONFIG): % : %.example
 	@if [ ! -f $@ ]; then \
         echo "Copying $< to $@..."; \
 		cp $< $@; \

effects/auroraeffect.h

@@ -0,0 +1,105 @@
+#pragma once
+using namespace std;
+
+#include "../interfaces.h"
+#include "../ledeffectbase.h"
+#include "../pixeltypes.h"
+#include <cmath>
+
+class AuroraEffect : public LEDEffectBase
+{
+private:
+    double _time;
+    double _speed;
+    double _brightness;
+    
+public:
+    AuroraEffect(const string& name, double speed = 0.2, double brightness = 1.0)
+        : LEDEffectBase(name, "AuroraEffect"), _time(0.0), _speed(speed), _brightness(brightness)
+    {
+    }
+
+    void Start(ICanvas& canvas) override
+    {
+        _time = 0.0;
+    }
+
+    void Update(ICanvas& canvas, microseconds deltaTime) override
+    {
+        _time += _speed * deltaTime.count() / 1000000.0;
+        
+        auto& graphics = canvas.Graphics();
+        int width = graphics.Width();
+        int height = graphics.Height();
+
+        for (int y = 0; y < height; ++y)
+        {
+            for (int x = 0; x < width; ++x)
+            {
+                // Create some "dancing" waves using multiple sine waves
+                double xf = x / static_cast<double>(width);
+                double yf = y / static_cast<double>(height);
+
+                double v1 = sin(xf * 2.0 + _time * 0.7);
+                double v2 = sin(yf * 3.0 + _time * 0.5);
+                double v3 = sin((xf + yf) * 1.5 + _time * 0.3);
+                double v4 = sin(sqrt(xf*xf + yf*yf) * 4.0 + _time * 0.2);
+                
+                double combined = (v1 + v2 + v3 + v4) / 4.0; // range [-1, 1]
+                combined = (combined + 1.0) / 2.0; // range [0, 1]
+                
+                // Aurora colors: green, blue, purple
+                // We want a nice transition between these colors
+                double hue;
+                if (combined < 0.3) {
+                    // Deep Blue to Cyan (240 to 180)
+                    hue = 240.0 - (combined / 0.3) * 60.0;
+                } else if (combined < 0.6) {
+                    // Cyan to Green (180 to 120)
+                    hue = 180.0 - ((combined - 0.3) / 0.3) * 60.0;
+                } else {
+                    // Green to Purple (120 to 280)
+                    double t = (combined - 0.6) / 0.4;
+                    if (t < 0.5) {
+                        hue = 120.0 - (t * 2.0) * 40.0; // Green to Lime (120 to 80)
+                    } else {
+                        hue = 260.0 + (t - 0.5) * 2.0 * 60.0; // Purple to Violet (260 to 320)
+                    }
+                }
+                
+                // Value (brightness) should also pulse
+                // Lift the floor significantly and use a smoother curve
+                double brightness = (0.4 + 0.6 * combined) * _brightness; 
+                
+                // Add some vertical bands to make it look more like aurora curtains
+                double curtain = sin(xf * 15.0 + sin(_time * 0.2) * 5.0) * 0.15 + 0.85;
+                brightness *= curtain;
+
+                // Max saturation for visibility
+                CRGB color = CRGB::HSV2RGB(hue, 1.0, brightness);
+                graphics.SetPixel(x, y, color);
+            }
+        }
+    }
+
+    friend inline void to_json(nlohmann::json& j, const AuroraEffect & effect);
+    friend inline void from_json(const nlohmann::json& j, shared_ptr<AuroraEffect>& effect);
+};
+
+inline void to_json(nlohmann::json& j, const AuroraEffect & effect) 
+{
+    j = {
+        {"name", effect.Name()},
+        {"speed", effect._speed},
+        {"brightness", effect._brightness}
+    };
+}
+
+inline void from_json(const nlohmann::json& j, shared_ptr<AuroraEffect>& effect) 
+{
+    effect =  make_shared<AuroraEffect>(
+        j.at("name").get<string>(),
+        j.value("speed", 0.2),
+        j.value("brightness", 1.0)
+    );
+}

effects/bouncingballeffect.h

@@ -54,14 +54,14 @@ class BouncingBallEffect : public LEDEffectBase
         {
             _height[i] = StartHeight;
             _impactVelocity[i] = ImpactVelocityStart;
-            _clockTimeSinceLastBounce[i] = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+            _clockTimeSinceLastBounce[i] = duration_cast<microseconds>(system_clock::now().time_since_epoch()).count();
             _dampening[i] = 1.0f - static_cast<float>(i) / powf(static_cast<float>(_ballCount), 2.0f);
             _timeSinceLastBounce[i] = 0;
             _colors[i] = BallColors[i % BallColors.size()];
         }
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         auto& graphics = canvas.Graphics();
         size_t length = graphics.Width();
@@ -81,7 +81,7 @@ class BouncingBallEffect : public LEDEffectBase
         // Draw each ball
         for (size_t i = 0; i < _ballCount; ++i)
         {
-            _timeSinceLastBounce[i] += deltaTime.count() / 1000.0; // Convert to seconds
+            _timeSinceLastBounce[i] += deltaTime.count() / 1000000.0; // Convert to seconds
             _height[i] = 0.5f * Gravity * powf(_timeSinceLastBounce[i], 2.0f) + _impactVelocity[i] * _timeSinceLastBounce[i];
 
             if (_height[i] < 0)

effects/colorwaveeffect.h

@@ -24,10 +24,10 @@ class ColorWaveEffect : public LEDEffectBase
         _hue = 0.0;
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         // Increment the hue based on speed and elapsed time
-        _hue += _speed * deltaTime.count() / 1000.0;
+        _hue += _speed * deltaTime.count() / 1000000.0;
         if (_hue >= 1.0) _hue -= 1.0; // Wrap around hue to stay in [0, 1)
 
         auto& graphics = canvas.Graphics();

effects/fireworkseffect.h

@@ -48,10 +48,10 @@ class FireworksEffect : public LEDEffectBase
     private:
         static double GetCurrentTime()
         {
-            return static_cast<double>(chrono::duration_cast<chrono::milliseconds>(
+            return static_cast<double>(chrono::duration_cast<chrono::microseconds>(
                                            chrono::steady_clock::now().time_since_epoch())
                                            .count()) /
-                   1000.0;
+                   1000000.0;
         }
     };
 
@@ -92,7 +92,7 @@ class FireworksEffect : public LEDEffectBase
     {
     }
 
-    void Update(ICanvas &canvas, milliseconds deltaTime) override
+    void Update(ICanvas &canvas, microseconds deltaTime) override
     {
         const auto ledCount = canvas.Graphics().Width() * canvas.Graphics().Height();
 
@@ -133,7 +133,7 @@ class FireworksEffect : public LEDEffectBase
             Particle particle = _particles.front();
             _particles.pop();
 
-            particle.Update(deltaTime.count() / 1000.0);
+            particle.Update(deltaTime.count() / 1000000.0);
             CRGB color = particle._starColor;
 
             double fade = 0.0;

effects/misceffects.h

@@ -25,7 +25,7 @@ class SolidColorFill : public LEDEffectBase
     {
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         canvas.Graphics().Clear(_color);
     }
@@ -58,7 +58,7 @@ class DaveDebugEffect : public LEDEffectBase
     {
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         (void) deltaTime;
 

effects/paletteeffect.h

@@ -59,7 +59,7 @@ class PaletteEffect : public LEDEffectBase
     {
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override 
+    void Update(ICanvas& canvas, microseconds deltaTime) override 
     {
         auto& graphics = canvas.Graphics();
         const auto width = graphics.Width();
@@ -69,7 +69,7 @@ class PaletteEffect : public LEDEffectBase
         graphics.Clear(CRGB::Black);
 
         // Pre-calculate constants
-        const double secondsElapsed = deltaTime.count() / 1000.0;
+        const double secondsElapsed = deltaTime.count() / 1000000.0;
         const double cPixelsToScroll = secondsElapsed * _LEDScrollSpeed;
         const double cColorsToScroll = secondsElapsed * _LEDColorPerSecond;
         const uint32_t cLength = (_Mirrored ? dotcount / 2 : dotcount);

effects/starfield.h

@@ -55,17 +55,17 @@ class StarfieldEffect : public LEDEffectBase
         canvas.Graphics().Clear(CRGB::Black);
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         auto& graphics = canvas.Graphics();
         graphics.FadeFrameBy(32);
 
-        double timeFactor = deltaTime.count() / 1000.0; // Convert delta time to seconds
+        double timeFactor = deltaTime.count() / 1000000.0; // Convert delta time to seconds
 
         for (auto& star : _stars)
         {
             // Update position based on velocity and time
-            const auto xScale = (double) (graphics.Width() / graphics.Height()) / 2.0;
+            const auto xScale = (double)graphics.Width() / (double)max(1u, graphics.Height()) / 2.0;
             star.x += star.dx * timeFactor * xScale;
             star.y += star.dy * timeFactor;
 

effects/videoeffect.h

@@ -142,7 +142,7 @@ class MP4PlaybackEffect : public LEDEffectBase
             SWS_BILINEAR, nullptr, nullptr, nullptr);
     }
 
-    void Update(ICanvas& canvas, milliseconds deltaTime) override
+    void Update(ICanvas& canvas, microseconds deltaTime) override
     {
         if (!_initialized)
             return;