Merge branch 'troy-heads'

Author: ewowi

docs/moonbase/module/editor.md

@@ -9,7 +9,7 @@ Each task is defined as a node. A node can be precompiled in the firmware or def
 
 Ultimately the nodes will be displayed in a graphical interface where nodes are connected by 'noodles' to define dependencies between nodes. For the time being nodes will be shown in a list.
 
-Typically a node will define a layout (🚥), or an effect (🔥), or a modifier (💎) or a supporting process (☸️) but can also combine these tasks (experimental at the moment). To avoid duplication it's in most cases recommended to keep them seperated so an effect can run on multiple layouts and a modifier can modify any effect. 
+Typically a node will define a layout (🚥), or an effect (🔥), or a modifier (💎) or a supporting process (☸️) but can also combine these tasks (experimental at the moment). To avoid duplication it's in most cases recommended to keep them separated so an effect can run on multiple layouts and a modifier can modify any effect. 
 
 * **Layout** 🚥: a layout defines what lights are connected to MoonLight. It defines the coordinates of all lights (addLight) and assigns lights to the GPIO pins of the ESP32 (addPin) and how many channels each light has (normal LEDs 3: Red, Green and Blue). 
     * The **coordinates** of each light are defined in a 3D coordinate space where each coordinate range between 1 and 255. Currently a strip until 255 leds is supported, a panel until 128x96 LEDS and a cube max 20x20x20. 
@@ -60,7 +60,7 @@ Precompiled effects can be found in [effects](https://github.com/MoonModules/Moo
 
 * Sends a beatsin to Pan and Tilt which can be sent to Moving Heads (add a Moving head layout node to configure the MHs)
 * Controls: BPM, Middle Pan and Tilt, Range and invert
-* Usage: Add this effect if moving heads are configured. RGB effects can be added seperately e.g. wave to light up the moving heads in wave patterns
+* Usage: Add this effect if moving heads are configured. RGB effects can be added separately e.g. wave to light up the moving heads in wave patterns
 * See [E_PanTilt](https://github.com/MoonModules/MoonLight/blob/main/misc/livescripts/E_PanTilt.sc)
 * Run script see [How to run a live script](https://moonmodules.org/MoonLight/moonbase/module/liveScripts/#how-to-run-a-live-script)
 

docs/moonbase/module/lightsControl.md

@@ -8,7 +8,7 @@ Controls:
 
 * On: lights on or off
 * Brightness: brightness of the LEDs when on
-* RGB Sliders: control each color seperately.
+* RGB Sliders: control each color separately.
 * Palette: Global palette setting. Effects with the palette icon 🎨 use this palette setting.
 * Presets: Control pad style, store or retrieve a set of nodes with their controls. WIP
 * Driver On: sends LED output to ESP32 gpio pins.

src/MoonLight/Effects.h

@@ -748,6 +748,219 @@ class SphereMoveEffect: public Node {
   }
 }; // SphereMove3DEffect
 
+class TroyMovingHeadEffect: public Node {
+  public:
+
+  static const char * name() {return "Troy's Moving Heads 15 CH 🔥♫💫🐺";}
+
+  //set default values here
+  uint8_t bpm = 30;
+  uint8_t pan = 175;
+  uint8_t tilt = 90;
+  uint8_t zoom = 20;
+  uint8_t range = 20;
+  uint8_t colorwheel = 0;
+  uint16_t light_number = 0;
+  uint8_t colorwheelbrightness = 255; // 0-255, 0 = off, 255 = full brightness
+  time_t cooldown = millis();
+  uint16_t start_channel = 0; //start channel for this effect, used to set the DMX map
+  
+  bool autoMove = false;
+  bool audioReactive = false;
+  bool invert = false;
+  int closestColorIndex = -1;
+
+  std::vector<CRGB> colorwheelpalette = {
+      CRGB(255, 255, 255), // White
+      CRGB(255, 0, 0),     // Red
+      CRGB(0, 255, 0),     // Green
+      CRGB(0, 0, 255),     // Blue
+      CRGB(255, 255, 0),   // Yellow
+      CRGB(0, 255, 255),   // Cyan
+      CRGB(255, 165, 0),   // Orange
+      CRGB(128, 0, 128)    // Purple
+  };
+
+  void setup() override {
+    addControl(start_channel, "start_channel", "number", 0, 512); // DMX start channel for this effect
+    addControl(light_number, "light_number", "number", 0, 512); // changed type to number as range (currently only supports 0..255)
+    addControl(bpm, "bpm", "range", 30);
+    addControl(pan, "pan", "range", 175);
+    addControl(tilt, "tilt", "range", 90);
+    addControl(zoom, "zoom", "range", 20);
+    addControl(colorwheel, "colorwheel", "range", 0, 7); // 0-7 for 8 colors in the colorwheel
+    addControl(colorwheelbrightness, "colorwheelbrightness", "range"); // 0-7 for 8 colors in the colorwheel
+    addControl(autoMove, "autoMove", "checkbox");
+    addControl(range, "range", "range");
+    addControl(audioReactive, "audioReactive", "checkbox");
+    addControl(invert, "invert", "checkbox");
+    hasLayout = true; //so the system knows to rebuild the mapping if needed
+    layerV->layerP->lights.header.channelsPerLight = 15; //set channels per light to 15 (RGB + Pan + Tilt + Zoom + Brightness)
+    layerV->layerP->lights.header.offsetRGB = start_channel+10; //set offset for RGB lights in DMX map
+    layerV->layerP->lights.header.offsetPan = start_channel+0;
+    layerV->layerP->lights.header.offsetTilt = start_channel+1;
+    layerV->layerP->lights.header.offsetZoom = start_channel+7;
+    layerV->layerP->lights.header.offsetBrightness = start_channel+8; //set offset for brightness
+    layerV->layerP->lights.header.offsetGobo = start_channel+5; //set offset for color wheel in DMX map
+    layerV->layerP->lights.header.offsetBrightness2 = start_channel+3; //set offset for color wheel brightness in DMX map
+  }
+
+  // Function to compute Euclidean distance between two colors
+  double colorDistance(const CRGB& c1, const CRGB& c2) {
+      return std::sqrt(std::pow(c1.r - c2.r, 2) + std::pow(c1.g - c2.g, 2) + std::pow(c1.b - c2.b, 2));
+  }
+
+  // Function to find the index of the closest color
+  int findClosestColorWheelIndex(const CRGB& inputColor, const std::vector<CRGB>& palette) {
+      int closestIndex = 0;
+      double minDistance = colorDistance(inputColor, palette[0]);
+
+      for (size_t i = 1; i < palette.size(); ++i) {
+          double distance = colorDistance(inputColor, palette[i]);
+          if (distance < minDistance) {
+              minDistance = distance;
+              closestIndex = static_cast<int>(i);
+          }
+      }
+
+      return closestIndex;
+  }
+
+  void loop() override {
+
+    if (audioReactive) {
+      // layerV->layerP->lights.header.offsetRGB = 10;
+      layerV->setRGB(light_number, CRGB(audio.bands[15],audio.bands[7],audio.bands[0]));
+      if (audio.bands[2] > 200 && cooldown + 3000 < millis()) { //cooldown for 3 seconds
+        cooldown = millis();
+        colorwheel = random8(8)*5; //random colorwheel index and convert to 0-35 range
+      } 
+      layerV->setGobo(light_number, colorwheel);
+      layerV->setBrightness2(light_number, (audio.bands[0]>200)?audio.bands[0]:0); // Use the first band for brightness
+      layerV->setZoom(light_number, (audio.bands[0]>200)?0:128);
+      uint8_t mypan = beatsin8(bpm, pan-range, pan+range, 0, audio.bands[0]/2);
+      uint8_t mytilt = beatsin8(bpm, tilt-range, tilt+range, 0, audio.bands[0]/2);
+      if (invert) {
+        mypan = 255 - mypan; // invert pan
+        mytilt = 255 - mytilt; // invert tilt
+      }
+      layerV->setPan(light_number, mypan); 
+      layerV->setTilt(light_number, mytilt);
+      layerV->setBrightness(light_number, (audio.bands[0]>200)?0:layerV->layerP->lights.header.brightness);
+    } else {
+      // layerV->layerP->lights.header.offsetRGB = 10;
+      layerV->setRGB(light_number, CHSV( beatsin8(10), 255, 255));
+      layerV->setGobo(light_number,colorwheel);
+      layerV->setBrightness2(light_number, colorwheelbrightness); // layerV->layerP->lights.header.brightness);
+      layerV->setPan(light_number, autoMove?beatsin8(bpm, pan-range, pan + range, 0,  (invert)?128:0): pan); //if automove, pan the light over a range
+      layerV->setTilt(light_number, autoMove?beatsin8(bpm, tilt - range, tilt + range, 0,  (invert)?128:0): tilt);
+      layerV->setBrightness(light_number, layerV->layerP->lights.header.brightness);
+    }
+  }
+};
+
+class TroyMovingHead32Effect: public Node {
+  public:
+
+  static const char * name() {return "Troy's Moving Heads 32 CH 🔥♫💫🐺";}
+
+  uint8_t bpm = 30;
+  uint8_t pan = 175;
+  uint8_t tilt = 90;
+  uint8_t zoom = 20;
+  uint8_t range = 20;
+  uint8_t cutin = 200;
+  uint16_t light_number;
+  time_t cooldown = millis();
+  uint16_t start_channel = 0; //start channel for this effect, used to set the DMX map
+  
+  bool autoMove = false;
+  bool audioReactive = false;
+  bool invert = false;
+
+  void setup() override {
+    addControl(start_channel, "start_channel", "number", 0, 512); // DMX start channel for this effect
+    addControl(light_number, "light_number", "number", 0, 512); // DMX start channel for this effect
+    addControl(bpm, "bpm", "range");
+    addControl(pan, "pan", "range");
+    addControl(tilt, "tilt", "range");
+    addControl(zoom, "zoom", "range");
+    addControl(cutin, "cutin", "range");
+    addControl(autoMove, "autoMove", "checkbox");
+    addControl(range, "range", "range");
+    addControl(audioReactive, "audioReactive", "checkbox");
+    addControl(invert, "invert", "checkbox");
+
+    hasLayout = true;
+    layerV->layerP->lights.header.channelsPerLight = 32;
+    layerV->layerP->lights.header.offsetRGB = start_channel+9;
+    layerV->layerP->lights.header.offsetPan = start_channel+0;
+    layerV->layerP->lights.header.offsetTilt = start_channel+2;
+    layerV->layerP->lights.header.offsetZoom = start_channel+5;
+    layerV->layerP->lights.header.offsetBrightness = start_channel+6;
+  }
+
+  // Function to compute Euclidean distance between two colors
+  double colorDistance(const CRGB& c1, const CRGB& c2) {
+      return std::sqrt(std::pow(c1.r - c2.r, 2) + std::pow(c1.g - c2.g, 2) + std::pow(c1.b - c2.b, 2));
+  }
+
+  // Function to find the index of the closest color
+  int findClosestColorWheelIndex(const CRGB& inputColor, const std::vector<CRGB>& palette) {
+      int closestIndex = 0;
+      double minDistance = colorDistance(inputColor, palette[0]);
+      for (size_t i = 1; i < palette.size(); ++i) {
+          double distance = colorDistance(inputColor, palette[i]);
+          if (distance < minDistance) {
+              minDistance = distance;
+              closestIndex = static_cast<int>(i);
+          }
+      }
+      return closestIndex;
+  }
+
+  void loop() override {
+
+    if (audioReactive) {
+      layerV->layerP->lights.header.offsetRGB = start_channel+9;
+      layerV->setRGB(light_number, CRGB(audio.bands[15]>cutin?audio.bands[15]:0,audio.bands[7]>cutin?audio.bands[7]:0,audio.bands[0]));
+      layerV->layerP->lights.header.offsetRGB += 4;
+      layerV->setRGB(light_number, CRGB(audio.bands[15],audio.bands[7]>cutin?audio.bands[7]:0,audio.bands[0]>cutin?audio.bands[0]:0));
+      layerV->layerP->lights.header.offsetRGB += 4;
+      layerV->setRGB(light_number, CRGB(audio.bands[15]>cutin?audio.bands[15]:0,audio.bands[7],audio.bands[0]>cutin?audio.bands[0]:0));
+      layerV->layerP->lights.header.offsetRGB += 7;
+      layerV->setRGB(light_number, CRGB(audio.bands[15]>cutin?map(audio.bands[15],cutin-1,255,0,255):0,audio.bands[7]>cutin?map(audio.bands[7],cutin-1,255,0,255):0,audio.bands[0]>cutin?map(audio.bands[0],cutin-1,255,0,255):0));
+      if (audio.bands[0] > cutin) {
+        layerV->setZoom(light_number, 255);
+        cooldown = millis();
+      } else if (cooldown + 5000 < millis()) {
+        layerV->setZoom(light_number, 0);
+        cooldown = millis();
+      }
+      // layerV->setZoom(light_number, (audio.bands[0]>cutin)?255:0);
+      uint8_t mypan = beatsin8(bpm, pan-range, pan+range, 0, audio.bands[0]/2);
+      uint8_t mytilt = beatsin8(bpm, tilt-range, tilt+range, 0, audio.bands[0]/2);
+      if (invert) {
+        mypan = 255 - mypan; // invert pan
+        mytilt = 255 - mytilt; // invert tilt
+      }
+      if (audio.bands[0]+audio.bands[7]+audio.bands[15] > 1) {
+        layerV->setPan(light_number, mypan); 
+        layerV->setTilt(light_number, mytilt);
+        layerV->setBrightness(light_number, 255);
+      } else {
+        layerV->setBrightness(light_number, 0);
+      }
+    } else {
+      // layerV->layerP->lights.header.offsetRGB = 10;
+      layerV->setRGB(light_number, CHSV( beatsin8(10), 255, 255));
+      layerV->setPan(light_number, autoMove?beatsin8(bpm, pan-range, pan + range, 0,  (invert)?128:0): pan); //if automove, pan the light over a range
+      layerV->setTilt(light_number, autoMove?beatsin8(bpm, tilt - range, tilt + range, 0,  (invert)?128:0): tilt);
+      layerV->setBrightness(light_number, layerV->layerP->lights.header.brightness);
+    }
+  }
+};
+
 class WaveEffect: public Node {
 public:
 

src/MoonLight/ModuleEditor.h

@@ -123,6 +123,8 @@ class ModuleEditor : public Module
             values.add(RGBWParEffect::name());
             values.add(SinusEffect::name());
             values.add(SphereMoveEffect::name());
+            values.add(TroyMovingHeadEffect::name());
+            values.add(TroyMovingHead32Effect::name());
             values.add(WaveEffect::name());
 
             values.add(HumanSizedCubeLayout::name());

src/MoonLight/PhysicalLayer.cpp

@@ -165,9 +165,11 @@ PhysicalLayer::PhysicalLayer() {
         else if (equal(name, RandomEffect::name())) node = new RandomEffect();
         else if (equal(name, RipplesEffect::name())) node = new RipplesEffect();
         else if (equal(name, RGBWParEffect::name())) node = new RGBWParEffect();
-        else if (equal(name, WaveEffect::name())) node = new WaveEffect();
         else if (equal(name, SinusEffect::name())) node = new SinusEffect();
         else if (equal(name, SphereMoveEffect::name())) node = new SphereMoveEffect();
+        else if (equal(name, TroyMovingHeadEffect::name())) node = new TroyMovingHeadEffect();
+        else if (equal(name, TroyMovingHead32Effect::name())) node = new TroyMovingHead32Effect();
+        else if (equal(name, WaveEffect::name())) node = new WaveEffect();
 
         else if (equal(name, HumanSizedCubeLayout::name())) node = new HumanSizedCubeLayout();
         else if (equal(name, PanelLayout::name())) node = new PanelLayout();

src/MoonLight/PhysicalLayer.h

@@ -39,22 +39,23 @@ struct LightsHeader {
   uint8_t isPositions = 0; //0is the lights.positions array filled with positions
   Coord3D size = {16,16,1}; //1 max position of light, counted by addLayoutPre/Post and addLight. 12 bytes not 0,0,0 to prevent div0 eg in Octopus2D
   uint16_t nrOfLights = 256; //4 nr of physical lights, counted by addLight
-  uint8_t brightness; //6 brightness set by light control
+  uint8_t brightness; //6 brightness set by light control (sent to LEDs driver normally)
   uint8_t channelsPerLight = 3; //7 RGB default
   uint8_t offsetRGB = 0; //RGB default
   uint8_t offsetWhite = UINT8_MAX;
-  uint8_t offsetBrightness = UINT8_MAX;
+  uint8_t offsetBrightness = UINT8_MAX; //in case the light has a separate brightness channel
   uint8_t offsetPan = UINT8_MAX;
   uint8_t offsetTilt = UINT8_MAX;
   uint8_t offsetZoom = UINT8_MAX;
   uint8_t offsetRotate = UINT8_MAX;
   uint8_t offsetGobo = UINT8_MAX;
   uint8_t offsetRGB1 = UINT8_MAX;
   uint8_t offsetRGB2 = UINT8_MAX;
-  //18 bytes until here
+  uint8_t offsetBrightness2 = UINT8_MAX;
+  //19 bytes until here
   // uint8_t ledFactor = 1; //factor to multiply the positions with 
   // uint8_t ledSize = 4; //mm size of each light, used in monitor ...
-  uint8_t dummy[6];
+  uint8_t dummy[5];
   //24 bytes total
 
   //support for more channels, like white, pan, tilt etc.
@@ -71,6 +72,7 @@ struct LightsHeader {
     offsetGobo = UINT8_MAX;
     offsetRGB1 = UINT8_MAX;
     offsetRGB2 = UINT8_MAX;
+    offsetBrightness2 = UINT8_MAX;
   }
 
 }; // fill with dummies to make size 24, be aware of padding so do not change order of vars

src/MoonLight/VirtualLayer.h

@@ -142,6 +142,13 @@ class VirtualLayer {
   }
   void setRGB2(Coord3D pos, CRGB color) { setRGB2(XYZ(pos), color); }
 
+  void setBrightness2(const uint16_t indexV, const uint8_t value) {
+    if (layerP->lights.header.offsetBrightness2 != UINT8_MAX)
+      setLight(indexV, &value, layerP->lights.header.offsetBrightness2, sizeof(value));
+  }
+  void setBrightness2(Coord3D pos, const uint8_t value) { setBrightness2(XYZ(pos), value); }
+
+
   void setLight(const uint16_t indexV, const uint8_t* channels, uint8_t offset, uint8_t length);
 
   CRGB getRGB(const uint16_t indexV) {