#include "Backend.h"

PixelRing ring(CRGB(255, 0, 0), STATIC);

// Left side - mode ctrl (static, random, running cw, running ccw)
Led ledSTA(4);
Led ledRND(3);
Led ledCW(2);
Led ledCCW(1);
Button buttonSTA(12, STATIC);
Button buttonRND(8, RANDOM);
Button buttonCW(7, RUNNING_CW);
Button buttonCCW(5, RUNNING_CCW);

// Right side - color / tempo ctrl (red, green, blue, tempo)
Led ledRed(11);
Led ledGreen(10);
Led ledBlue(9);
Led ledWhite(6);
ColorController ctrlRed(A0, &ledRed);
ColorController ctrlGreen(A1, &ledGreen);
ColorController ctrlBlue(A2, &ledBlue);
Controller ctrlTempo(A3);

AnimationSelector aSel(STATIC, {{&buttonSTA, &buttonRND, &buttonCW, &buttonCCW}, {&ledSTA, &ledRND, &ledCW, &ledCCW}});

void setup() {
  randomSeed(analogRead(A4));

  ring.init();

  ledRed.init();
  ledGreen.init();
  ledBlue.init();
  ledWhite.init();

  aSel.init();
}

void loop() {
  // Global time
  sysTime = millis();
  ring.animation(ledWhite);

  // Polling potentiometers and calling color setter of pixel ring
  ctrlRed.update(&PixelRing::setRed, ring);
  ctrlGreen.update(&PixelRing::setGreen, ring);
  ctrlBlue.update(&PixelRing::setBlue, ring);
  ctrlTempo.update(&PixelRing::setAnimationInterval, ring);

  // Polling buttons, calling animation setter of pixel ring and turning on the led
  aSel.update(&PixelRing::setAnimation, ring);
}

Around.ino

diagram.json

#include <FastLED.h>

typedef unsigned long time_t;

#define RING_PIN 13
#define NUM_LEDS 32

time_t sysTime;

unsigned int gamma(unsigned int input) {
  input = constrain(input, 0, 255);
  float wert = (float)input / 255.0;    // Mapping auf Wert zwischen 0.0 & 1.0 (float)
  wert = pow(wert, 2.2);               // Verrechnen mit Gammakurve (wert^2.35)
  return (unsigned int)(wert * 255);    // Return mit Mapping von 0 bis 255 als int
}

enum Animation {
  STATIC,
  RANDOM,
  RUNNING_CW,
  RUNNING_CCW
};

enum Method {
  ANALOG_WRITE,
  ON,
  OFF,
  BLINK
};

class Led {
  private:
    byte _pin;
    byte _value;
    bool _state = false;

  public:
    Led(byte pin) {
      setPin(pin);
    }
    // Setter
    void setPin(byte pin) {
      _pin = pin;
    }
    void setValue(byte value) {
      _value = value;
    }
    void setState(bool state) {
      _state = state;
    }
    // Getter
    byte getPin() {
      return _pin;
    }
    uint16_t getValue() {
      return _value;
    }
    bool getState() {
      return _state;
    }
    // Main methods
    void init() {
      pinMode(getPin(), OUTPUT);
    }
    void show(Method method) {
      switch (method) {
        case ANALOG_WRITE:
          analogWrite(getPin(), gamma(getValue()));
          break;
        case ON:
          setState(true);
          digitalWrite(getPin(), getState());
          break;
        case OFF:
          setState(false);
          digitalWrite(getPin(), getState());
          break;
        case BLINK:
          digitalWrite(getPin(), getState() ? HIGH : LOW);
          setState(!getState());
      }
    }
};

class PixelRing {
  private:
    uint16_t _animationMax = 200;
    uint16_t _animationMin = 20;
    byte _fadeAmount = 10;
    CRGB _leds[NUM_LEDS];
    int _red, _green, _blue;
    uint16_t _animationInterval = _animationMax;
    time_t _timeStamp;
    Animation _animation;

  public:
    PixelRing(CRGB color, Animation animation) {
      setRed(color.red);
      setGreen(color.green);
      setBlue(color.blue);
      setAnimation(animation);
    }
    // Setter
    void setRed(int red) {
      red = constrain(red, 0, 255);
      _red = red;
    }
    void setGreen(int green) {
      green = constrain(green, 0, 255);
      _green = green;
    }
    void setBlue(int blue) {
      blue = constrain(blue, 0, 255);
      _blue = blue;
    }
    void setAnimationInterval(int animationInterval) {
      _animationInterval = map(animationInterval, 0, 255, _animationMax, _animationMin);
    }
    void setTimeStamp(time_t timeStamp) {
      _timeStamp = timeStamp;
    }
    void setAnimation(Animation animation) {
      _animation = animation;
    }
    // Getter
    int getRed() {
      return _red;
    }
    int getGreen() {
      return _green;
    }
    int getBlue() {
      return _blue;
    }
    uint16_t getAnimationInterval() {
      return _animationInterval;
    }
    time_t getTimeStamp() {
      return _timeStamp;
    }
    Animation getAnimation() {
      return _animation;
    }
    // Main methods
    void init() {
      FastLED.addLeds<WS2812B, RING_PIN, GRB>(_leds, NUM_LEDS).setCorrection(TypicalSMD5050);
    }
    void animation(Led & led) {
      Animation anim = getAnimation();

      if (anim == RANDOM || anim == RUNNING_CW || anim == RUNNING_CCW) {
        if (sysTime - getTimeStamp() >= getAnimationInterval()) {
          setTimeStamp(sysTime);
          static int pixel = 0;
          led.show(BLINK);
          fade();
          switch (getAnimation()) {
            case RANDOM:
              pixel = random(0, NUM_LEDS);
            case RUNNING_CW:
              pixel++;
              if (pixel >= NUM_LEDS) pixel = 0;
              break;
            case RUNNING_CCW:
              pixel--;
              if (pixel < 0) pixel = NUM_LEDS - 1;
              break;
          }
          _leds[pixel] = CRGB(getRed(), getGreen(), getBlue());
          update();
        }
      } else {
        if (!led.getState()) {
          led.show(OFF);
        }
        for (int i = 0; i < NUM_LEDS; i++) {
          _leds[i] = CRGB(getRed(), getGreen(), getBlue());
        }
        update();
      }
    }
    void fade() {
      for (int i = 0; i < NUM_LEDS; i++) {
        _leds[i].red = constrain(_leds[i].red - _fadeAmount, 0, 255);
        _leds[i].green = constrain(_leds[i].green - _fadeAmount, 0, 255);
        _leds[i].blue = constrain(_leds[i].blue - _fadeAmount, 0, 255);
      }
    }
    void update() {
      FastLED.show();
    }
};

class Controller {
  private:
    byte _potPin;
    uint16_t _potValue;
    uint16_t _potValueOld;

  public:
    Controller(byte potPin) {
      setPotPin(potPin);
    }
    // Setter
    void setPotPin(byte potPin) {
      _potPin = potPin;
    }
    void setPotValue(uint16_t potValue) {
      _potValue = potValue;
    }
    void setPotValueOld(uint16_t potValueOld) {
      _potValueOld = potValueOld;
    }
    // Getter
    byte getPotPin() {
      return _potPin;
    }
    uint16_t getPotValue() {
      return _potValue;
    }
    uint16_t getPotValueOld() {
      return _potValueOld;
    }
    // Main methods
    void update(void (PixelRing::*function)(int), PixelRing & ring) {
      uint16_t potValueCurrent = analogRead(getPotPin());

      if (potValueCurrent != getPotValueOld()) {
        setPotValue(potValueCurrent);
        potValueCurrent = map(potValueCurrent, 0, 1023, 0, 255);
        (ring.*function)(potValueCurrent);
      }
      setPotValueOld(getPotValue());
    }
};

class ColorController : public Controller {
  private:
    Led * _led;

  public:
    ColorController(byte potPin, Led * led) : Controller(potPin) {
      setLed(led);
    }
    // Setter
    void setLed(Led * led) {
      _led = led;
    }
    // Getter
    Led * getLed() {
      return _led;
    }
    // Main methods
    void update(void (PixelRing::*function)(int), PixelRing & ring) {
      uint16_t potValueCurrent = analogRead(getPotPin());

      if (potValueCurrent != getPotValueOld()) {
        setPotValue(potValueCurrent);
        potValueCurrent = map(potValueCurrent, 0, 1023, 0, 255);

        (ring.*function)(potValueCurrent);
        getLed()->setValue(potValueCurrent);
        getLed()->show(ANALOG_WRITE);
      }
      setPotValueOld(getPotValue());
    }
};

class Button {
  private:
    byte _pin;
    bool _state;
    bool _stateOld;
    Animation _animation;

  public:
    Button(byte pin, Animation animation) {
      setPin(pin);
      setAnimation(animation);
    }
    // Setter
    void setPin(byte pin) {
      _pin = pin;
    }
    void setState(bool state) {
      _state = state;
    }
    void setAnimation(Animation animation) {
      _animation = animation;
    }
    // Getter
    byte getPin() {
      return _pin;
    }
    bool getState() {
      return _state;
    }
    Animation getAnimation() {
      return _animation;
    }
    // Main methods
    void init() {
      pinMode(getPin(), INPUT_PULLUP);
      setState(!digitalRead(getPin()));
    }
    void update() {
      setState(!digitalRead(getPin()));
    }
};

class AnimationSelector {
  private:
    struct ButtonsLeds {
      Button * buttons[4];
      Led * leds[4];
    };
    ButtonsLeds _bL;
    Animation _animation;

  public:
    AnimationSelector(Animation animation, ButtonsLeds bL) {
      _bL = bL;
      setAnimation(animation);
    }
    // Setter
    void setAnimation(Animation animation) {
      _animation = animation;
    }
    // Getter
    Animation getAnimation() {
      return _animation;
    }
    // Main methods
    void init() {
      for (int i = 0; i < 4; i++) {
        _bL.leds[i]->init();
        _bL.buttons[i]->init();
      }
      setLed(getAnimation());
    }
    void setLed(byte led) {
      for (int i = 0; i < 4; i++) {
        _bL.leds[i]->show(OFF);
      }
      _bL.leds[led]->show(ON);
    }
    void update(void (PixelRing::*function)(Animation), PixelRing & ring) {
      for (int i = 0; i < 4; i++) {
        _bL.buttons[i]->update();
        Animation anim = _bL.buttons[i]->getAnimation();
        if (_bL.buttons[i]->getState() && getAnimation() != anim) {
          setAnimation(anim);
          setLed(anim);
          (ring.*function)(anim);
        }
      }
    }
};

Backend.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
FastLED
# ---
