Programmierbarer Osterhase: ESP32-C3 Lötkit mit Touch & Drehpoti

/*
  ============================================================
  Projekt: Programmierbarer Osterhase mit ESP32-C3
  Beschreibung:
  Dieses Programm steuert 7 LEDs auf einem Osterhasen-PCB.
  Über eine Touchfläche kann zwischen verschiedenen LED-Modi
  gewechselt werden. Die Empfindlichkeit der Touchfläche wird
  über ein Drehpotentiometer eingestellt.

  Modi:
  1 = Blume rotiert Stufe 1
  2 = Blume rotiert Stufe 2
  3 = Blume blinkt

  Autor: Stefan Draeger
  ============================================================
*/


// ------------------------------------------------------------
// PIN-DEFINITIONEN
// ------------------------------------------------------------
// Hier werden die GPIO-Pins definiert, an denen die 7 LEDs
// angeschlossen sind.

#define ledPin1 5
#define ledPin2 6
#define ledPin3 7
#define ledPin4 8
#define ledPin5 9
#define ledPin6 10
#define ledPin7 20

// Analoger Eingang für das Drehpotentiometer.
// Darüber wird die Empfindlichkeit des Touchsensors eingestellt.
#define rotaryResistorPin 3

// Analoger Eingang für die Touchfläche.
// Der ESP32-C3 besitzt keine dedizierten Touch-Pins,
// daher werten wir hier eine Spannungsänderung am ADC aus.
#define touchPin 4


// ------------------------------------------------------------
// MODUS-VERWALTUNG
// ------------------------------------------------------------
// 'modus' speichert den aktuell aktiven Effekt.
// MAX_MODI legt fest, wie viele Effekte insgesamt existieren.

int modus = 1;
const int MAX_MODI = 3;


// ------------------------------------------------------------
// LED-ARRAY
// ------------------------------------------------------------
// Die LED-Pins werden in einem Array zusammengefasst.
// So können wir später bequem mit Schleifen über alle LEDs gehen.

const int NUM_LEDS = 7;
int leds[NUM_LEDS] = {
  ledPin1, ledPin2, ledPin3, ledPin4, ledPin5, ledPin6, ledPin7
};


// ------------------------------------------------------------
// ZEITSTEUERUNG FÜR DIE ANIMATIONEN
// ------------------------------------------------------------
// FLOWER_PAUSE bestimmt das Zeitintervall zwischen zwei Schritten
// der LED-Animation.
// flowerLastAction speichert, wann die letzte Änderung stattgefunden hat.

int flowerIndex = 0;
const int FLOWER_PAUSE = 250;
unsigned long flowerLastAction = 0;


// ------------------------------------------------------------
// HILFSVARIABLEN FÜR DEN ERSTEN EFFEKT
// ------------------------------------------------------------
// stampStatus wird genutzt, um eine zusätzliche LED im Wechsel
// blinken zu lassen.
// STAMP_PAUSE und stampLastAction sind aktuell vorbereitet,
// werden in dieser Version aber nicht aktiv verwendet.

const int STAMP_PAUSE = 125;
unsigned long stampLastAction = 0;
bool stampStatus = false;


// ------------------------------------------------------------
// SETUP
// ------------------------------------------------------------
// setup() wird genau einmal beim Start des Mikrocontrollers
// ausgeführt.

void setup() {
  // Serielle Schnittstelle starten, damit wir Messwerte
  // im seriellen Monitor der Arduino IDE ausgeben können.
  Serial.begin(9600);

  // Alle LED-Pins als Ausgänge konfigurieren.
  for (int index = 0; index < NUM_LEDS; index++) {
    pinMode(leds[index], OUTPUT);
  }
}


// ------------------------------------------------------------
// EFFEKT 1: BLUME ROTIERT STUFE 1
// ------------------------------------------------------------
// Bei diesem Effekt wird LED für LED nacheinander eingeschaltet.
// Zusätzlich wird LED 0 in jedem Schritt umgeschaltet.

void flowerRotate() {
  // Wenn wir bei der letzten LED angekommen sind,
  // wird diese ausgeschaltet und der Index zurückgesetzt.
  if (flowerIndex == 6) {
    digitalWrite(leds[6], LOW);
    flowerIndex = 0;
  }

  // Zum nächsten LED-Index wechseln.
  flowerIndex++;

  // Die vorherige LED ausschalten,
  // damit nur eine LED aktiv bleibt.
  if (flowerIndex > 1) {
    digitalWrite(leds[flowerIndex - 1], LOW);
  }

  // Die aktuelle LED einschalten.
  digitalWrite(leds[flowerIndex], HIGH);

  // Zusätzliche LED 0 bei jedem Durchlauf umschalten.
  // Dadurch entsteht ein zusätzlicher Blinkeffekt.
  stampStatus = !stampStatus;
  digitalWrite(leds[0], stampStatus);
}


// ------------------------------------------------------------
// EFFEKT 2: BLUME ROTIERT STUFE 2
// ------------------------------------------------------------
// Dieser Effekt arbeitet mit einem zweiten Index.
// LEDs werden der Reihe nach ein- oder ausgeschaltet.
// Sobald alle LEDs durchlaufen wurden, wird der Zustand
// umgedreht (HIGH <-> LOW).

int flowerRotate2Index = 0;
bool flowerRotate2Status = false;

void flowerRotate2() {
  // Aktuelle LED auf den gespeicherten Status setzen.
  digitalWrite(leds[flowerRotate2Index], flowerRotate2Status);

  // Zum nächsten Index wechseln.
  if (flowerRotate2Index < (NUM_LEDS - 1)) {
    flowerRotate2Index++;
  } else {
    // Wenn alle LEDs durchlaufen wurden:
    // wieder von vorne beginnen und Status umschalten.
    flowerRotate2Index = 0;
    flowerRotate2Status = !flowerRotate2Status;
  }
}


// ------------------------------------------------------------
// EFFEKT 3: BLUME BLINKT
// ------------------------------------------------------------
// Alle LEDs werden gleichzeitig ein- und ausgeschaltet.

void flowerBlink() {
  // Alle LEDs einschalten.
  for (int index = 0; index < NUM_LEDS; index++) {
    digitalWrite(leds[index], HIGH);
  }

  // Kurze Pause mit allen LEDs an.
  delay(FLOWER_PAUSE);

  // Alle LEDs ausschalten.
  for (int index = 0; index < NUM_LEDS; index++) {
    digitalWrite(leds[index], LOW);
  }

  // Kurze Pause mit allen LEDs aus.
  delay(FLOWER_PAUSE);
}


// ------------------------------------------------------------
// TOUCH-STEUERUNG
// ------------------------------------------------------------
// TOUCH_PAUSE dient als einfache Sperrzeit,
// damit nicht mehrere Touchs direkt hintereinander erkannt werden.

const int TOUCH_PAUSE = 500;
unsigned long touchLastAction = 0;


// ------------------------------------------------------------
// VARIABLEN ZUR ÜBERWACHUNG DER ADC-WERTE
// ------------------------------------------------------------
// Diese Variablen dienen dazu, Änderungen am Potentiometer
// und an der Touchfläche nur dann seriell auszugeben,
// wenn sich der Wert tatsächlich verändert hat.

int resistorValue = -1;
int oldResistorValue = -1;

int touchValue = -1;
int oldTouchValue = -1;


// ------------------------------------------------------------
// HAUPTSCHLEIFE
// ------------------------------------------------------------
// loop() wird nach setup() ständig wiederholt.

void loop() {

  // ----------------------------------------------------------
  // DREHPOTENTIOMETER AUSLESEN
  // ----------------------------------------------------------
  // Hier lesen wir den aktuellen ADC-Wert des Potentiometers ein.
  // Dieser Wert dient später als Schwellwert für die Touch-Erkennung.
  resistorValue = analogRead(rotaryResistorPin);

  // Nur bei Änderung seriell ausgeben,
  // damit der Monitor nicht unnötig zugespammt wird.
  if (resistorValue != oldResistorValue) {
    oldResistorValue = resistorValue;
    Serial.print("Sensibilität: ");
    Serial.println(resistorValue);
  }


  // Aktuelle Laufzeit seit Start des Programms in Millisekunden.
  unsigned long currentMillis = millis();


  // ----------------------------------------------------------
  // TOUCHFLÄCHE AUSLESEN
  // ----------------------------------------------------------
  // Auch hier wird ein analoger Wert gelesen.
  // Berührt man die Kupferfläche, verändert sich der Messwert.
  touchValue = analogRead(touchPin);

  // Nur bei Änderung seriell ausgeben.
  if (touchValue != oldTouchValue) {
    oldTouchValue = touchValue;
    Serial.print("Touchsensor: ");
    Serial.println(touchValue);
  }


  // ----------------------------------------------------------
  // TOUCH AUSWERTEN UND MODUS WECHSELN
  // ----------------------------------------------------------
  // Es wird geprüft, ob seit der letzten Touch-Aktion genug Zeit
  // vergangen ist. Das verhindert Mehrfachauslösungen.
  if (currentMillis > (touchLastAction + TOUCH_PAUSE)) {
    touchLastAction = currentMillis;

    // Wenn der gemessene Touch-Wert größer als der Potentiometer-
    // Wert ist, wird dies als Berührung interpretiert.
    if (touchValue > resistorValue) {

      // Wenn der letzte Modus erreicht wurde,
      // wieder von vorne beginnen.
      if (modus == MAX_MODI) {
        modus = 0;
      }

      // Zum nächsten Modus wechseln.
      modus++;
    }
  }


  // ----------------------------------------------------------
  // LED-EFFEKT ZEITGESTEUERT AUSFÜHREN
  // ----------------------------------------------------------
  // Statt delay() wird hier millis() verwendet,
  // damit das Programm weiterhin auf Touch reagieren kann.
  if (currentMillis > (flowerLastAction + FLOWER_PAUSE)) {
    flowerLastAction = currentMillis;

    // Je nach aktivem Modus die passende Effektfunktion aufrufen.
    switch (modus) {
      case 1:
        flowerRotate();
        break;

      case 2:
        flowerRotate2();
        break;

      case 3:
        flowerBlink();
        break;

      default:
        // Falls ein ungültiger Modus gesetzt wurde,
        // auf den ersten Effekt zurückfallen.
        flowerRotate();
        break;
    }
  }
}