Mehrere Shellys mit Arduino steuern – lokal und ohne Cloud

/*
  arduinoR4WifiShelly.ino

  Arduino UNO R4 WiFi + Ethernet Shield (W5100) + Modulino Buttons +
  Modulino Knob (Rotary Encoder) + Modulino Pixels (8x RGB LED)
  -----------------------------------------------------------------------------------------------
  Portierung von "shellyWebserver.ino" (UNO R3) auf den UNO R4 WiFi.

  Der Arduino stellt weiterhin eine Weboberflaeche per Ethernet bereit
  (http://<arduinoIp>/). Dort gibt es fuer JEDEN konfigurierten Shelly einen
  eigenen Block mit drei Buttons (EIN / AUS / EIN fuer 3s), erreichbar unter:

    GET /shelly/<index>/an    -> Shelly <index> EIN
    GET /shelly/<index>/aus   -> Shelly <index> AUS
    GET /shelly/<index>/an3   -> Shelly <index> EIN fuer 3 Sekunden

  <index> ist die Position in der Liste "shellys" weiter unten (0, 1, 2, ...).
  Ein Klick auf einen dieser Buttons waehlt den betroffenen Shelly zugleich
  als "aktiven" Shelly aus (siehe naechster Absatz).

  Zusaetzlich koennen die drei physischen Taster des Button-Modulinos
  (I2C/Qwiic) dieselben Aktionen fuer den aktuell ausgewaehlten Shelly
  ausloesen:

    Taste 0 (A) -> ausgewaehlter Shelly EIN
    Taste 1 (B) -> ausgewaehlter Shelly AUS
    Taste 2 (C) -> ausgewaehlter Shelly EIN fuer 3 Sekunden

  Mit dem Modulino Knob (Rotary Encoder) wird ebenfalls ausgewaehlt, welcher
  von bis zu 8 Shellys gerade der "aktive" ist (Liste "shellys" weiter
  unten). Drehen wechselt die Auswahl (mit Wraparound), das Pixel-Modulino
  zeigt den ausgewaehlten Shelly als GELBE LED an der zugehoerigen Position
  an (LED-Index = Index des Eintrags in "shellys").

  Web-Buttons, physische Taster und Encoder-Auswahl rufen letztlich alle
  dieselbe zentrale Funktion schalteUndAktualisiere() auf, die den jeweiligen
  Shelly per HTTP-Client-Anfrage schaltet (klassische Gen1-Relay-API):

    http://<SHELLY_IP>/relay/0?turn=on
    http://<SHELLY_IP>/relay/0?turn=on&timer=3
    http://<SHELLY_IP>/relay/0?turn=off

  Alle Modulino-Module (Buttons, Knob, Pixels) haengen ueber Qwiic-Kabel in
  Reihe am selben I2C-Bus des Arduino und werden gemeinsam ueber
  Modulino.begin() initialisiert.

  Anpassen muss man nur den Block "Konfiguration" weiter unten - dort auch
  die Liste "shellys" um weitere Geraete ergaenzen (max. 8 Stueck, da das
  Pixel-Modulino 8 LEDs hat).
*/

#include <SPI.h>
#include <Ethernet.h>
#include <Wire.h>
#include <Arduino_Modulino.h>
#include <stdio.h>

// ---------- Konfiguration ----------

// MAC-Adresse des Ethernet Shields (frei waehlbar, muss im Netz eindeutig sein)
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Feste IP-Adresse, unter der der Arduino-Webserver erreichbar sein soll
IPAddress arduinoIp(192, 168, 178, 50);

// Ein Eintrag pro steuerbarem Shelly. Die Reihenfolge legt fest, an welcher
// LED-Position (0..7) des Pixel-Modulinos der Eintrag ausgewaehlt angezeigt
// wird, wenn man ihn per Rotary Encoder anwaehlt.
struct ShellyGeraet {
  const char* name;
  IPAddress ip;
};

ShellyGeraet shellys[] = {
  { "Shelly 1", IPAddress(192, 168, 178, 199) },
  { "Shelly 2", IPAddress(192, 168, 178, 106) },
  { "Shelly 3", IPAddress(192, 168, 178, 163) },
};
const uint8_t ANZAHL_SHELLYS = sizeof(shellys) / sizeof(shellys[0]);
static_assert(sizeof(shellys) / sizeof(shellys[0]) <= 8,
              "Maximal 8 Shellys moeglich (8 LEDs am Pixel-Modulino)");

const uint16_t shellyPort = 80;

// Helligkeit der Auswahl-LED (0-100)
const uint8_t ledHelligkeit = 25;

// ------------------------------------

EthernetServer server(80);

ModulinoButtons buttons;
ModulinoKnob knob;
ModulinoPixels leds;

// Puffer fuer die erste Zeile der eingehenden HTTP-Anfrage, z.B.
// "GET /heizung/an HTTP/1.1"
const size_t REQUEST_BUFFER_SIZE = 64;
char requestBuffer[REQUEST_BUFFER_SIZE];

// Index des per Rotary Encoder ausgewaehlten Shellys (Index in "shellys").
uint8_t aktiverShellyIndex = 0;

void setup() {
  Serial.begin(9600);

  Modulino.begin();
  buttons.begin();
  knob.begin();
  leds.begin();
  aktualisiereAuswahlLed();

  Ethernet.begin(mac, arduinoIp);
  delay(1000); // dem Shield etwas Zeit zur Initialisierung geben

  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println(F("Kein Ethernet Shield gefunden."));
    while (true) {
      delay(1);
    }
  }

  if (Ethernet.linkStatus() == LinkOFF) {
    Serial.println(F("Achtung: Ethernet-Kabel scheint nicht verbunden zu sein."));
  }

  server.begin();
  Serial.print(F("Webserver gestartet: http://"));
  Serial.println(Ethernet.localIP());
}

void loop() {
  behandleTaster();
  behandleEncoder();

  EthernetClient client = server.available();
  if (client) {
    liesAnfrageZeile(client, requestBuffer, REQUEST_BUFFER_SIZE);

    if (behandleShellyRoute(requestBuffer)) {
      sendeRedirect(client);
    } else {
      sendeStartseite(client);
    }

    delay(1);
    client.stop();
  }
}

// Fragt die drei Taster des Button-Modulinos ab und loest bei einem
// Tastendruck dieselbe Aktion aus wie der entsprechende Web-Button.
void behandleTaster() {
  if (!buttons.update()) {
    return;
  }

  if (buttons.isPressed(0)) {
    Serial.println(F("Taste 0 (A) gedrueckt: Shelly EIN"));
    schalteUndAktualisiere(true, 0);
  } else if (buttons.isPressed(1)) {
    Serial.println(F("Taste 1 (B) gedrueckt: Shelly AUS"));
    schalteUndAktualisiere(false, 0);
  } else if (buttons.isPressed(2)) {
    Serial.println(F("Taste 2 (C) gedrueckt: Shelly EIN fuer 3 Sekunden"));
    schalteUndAktualisiere(true, 3);
  }
}

// Liest die Drehrichtung des Rotary-Encoder-Modulinos aus und wechselt
// damit den aktuell ausgewaehlten Shelly (mit Wraparound ueber die Liste).
void behandleEncoder() {
  int8_t richtung = knob.getDirection();
  if (richtung == 0) {
    return;
  }

  aktiverShellyIndex = (aktiverShellyIndex + ANZAHL_SHELLYS + richtung) % ANZAHL_SHELLYS;
  aktualisiereAuswahlLed();

  Serial.print(F("Ausgewaehlter Shelly: "));
  Serial.print(shellys[aktiverShellyIndex].name);
  Serial.print(F(" ("));
  Serial.print(shellys[aktiverShellyIndex].ip);
  Serial.println(F(")"));
}

// Schaltet den aktuell ausgewaehlten Shelly (per Encoder oder zuletzt per
// Web-Button gewaehlt).
void schalteUndAktualisiere(bool einschalten, unsigned int timerSekunden) {
  schalteShelly(shellys[aktiverShellyIndex].ip, einschalten, timerSekunden);
}

// Erkennt Web-Anfragen der Form "GET /shelly/<index>/<aktion> HTTP/1.1"
// (z.B. "/shelly/1/an3") und schaltet damit gezielt einen der konfigurierten
// Shellys. Waehlt den betroffenen Shelly dabei zugleich als "aktiv" aus, so
// dass Auswahl-LED und physische Taster ab sofort auf ihn wirken.
// Gibt true zurueck, wenn eine gueltige Schaltanfrage erkannt wurde.
bool behandleShellyRoute(const char *zeile) {
  if (strncmp(zeile, "GET /shelly/", 12) != 0) {
    return false;
  }

  int index = -1;
  char aktion[8] = "";
  if (sscanf(zeile + 12, "%d/%7s", &index, aktion) != 2) {
    return false;
  }
  if (index < 0 || index >= ANZAHL_SHELLYS) {
    return false;
  }

  aktiverShellyIndex = (uint8_t)index;
  aktualisiereAuswahlLed();

  if (strcmp(aktion, "an3") == 0) {
    schalteUndAktualisiere(true, 3);
  } else if (strcmp(aktion, "an") == 0) {
    schalteUndAktualisiere(true, 0);
  } else if (strcmp(aktion, "aus") == 0) {
    schalteUndAktualisiere(false, 0);
  } else {
    return false;
  }

  return true;
}

// Zeigt auf dem Pixel-Modulino (8 LEDs), welcher Shelly aktuell ausgewaehlt
// ist: Die LED an der Position von aktiverShellyIndex leuchtet GELB, alle
// anderen LEDs sind aus.
void aktualisiereAuswahlLed() {
  leds.clear();
  leds.set(aktiverShellyIndex, YELLOW, ledHelligkeit);
  leds.show();
}

// Liest die erste Zeile der HTTP-Anfrage (z.B. "GET /shelly/an HTTP/1.1")
// in buffer und verwirft anschliessend den Rest der Header, damit der
// Client sauber geschlossen werden kann.
void liesAnfrageZeile(EthernetClient &client, char *buffer, size_t bufferSize) {
  size_t index = 0;
  buffer[0] = '\0';

  unsigned long start = millis();
  while (client.connected() && millis() - start < 2000) {
    if (client.available()) {
      char c = client.read();
      if (c == '\n') {
        break;
      }
      if (c != '\r' && index < bufferSize - 1) {
        buffer[index++] = c;
      }
    }
  }
  buffer[index] = '\0';

  // restliche Header-Zeilen einfach verwerfen
  start = millis();
  while (client.connected() && millis() - start < 200) {
    while (client.available()) {
      client.read();
      start = millis();
    }
  }
}

// Schickt als HTTP-Client eine Anfrage an den Shelly mit der angegebenen IP,
// um ihn ein- oder auszuschalten. timerSekunden > 0 schaltet den Shelly nach
// der angegebenen Zeit automatisch wieder aus (nur bei einschalten == true).
void schalteShelly(IPAddress ip, bool einschalten, unsigned int timerSekunden) {
  EthernetClient shellyClient;

  if (!shellyClient.connect(ip, shellyPort)) {
    Serial.println(F("Verbindung zum Shelly fehlgeschlagen."));
    return;
  }

  shellyClient.print(F("GET /relay/0?turn="));
  shellyClient.print(einschalten ? F("on") : F("off"));
  if (einschalten && timerSekunden > 0) {
    shellyClient.print(F("&timer="));
    shellyClient.print(timerSekunden);
  }
  shellyClient.println(F(" HTTP/1.1"));

  shellyClient.print(F("Host: "));
  shellyClient.println(ip);
  shellyClient.println(F("Connection: close"));
  shellyClient.println();

  // Antwort des Shelly abwarten und verwerfen, bevor die Verbindung
  // geschlossen wird
  unsigned long start = millis();
  while (shellyClient.connected() && millis() - start < 2000) {
    while (shellyClient.available()) {
      shellyClient.read();
      start = millis();
    }
  }
  shellyClient.stop();

  Serial.print(F("Shelly geschaltet: "));
  if (einschalten && timerSekunden > 0) {
    Serial.print(F("AN (Timer "));
    Serial.print(timerSekunden);
    Serial.println(F("s)"));
  } else {
    Serial.println(einschalten ? F("AN") : F("AUS"));
  }
}

// Leitet den Browser nach einer Aktion zurueck auf die Startseite,
// damit ein Neuladen der Seite die Aktion nicht wiederholt.
void sendeRedirect(EthernetClient &client) {
  client.println(F("HTTP/1.1 303 See Other"));
  client.println(F("Location: /"));
  client.println(F("Connection: close"));
  client.println();
}

// Liefert die Startseite mit den Schalt-Buttons aus.
void sendeStartseite(EthernetClient &client) {
  client.println(F("HTTP/1.1 200 OK"));
  client.println(F("Content-Type: text/html; charset=UTF-8"));
  client.println(F("Connection: close"));
  client.println();

  client.println(F("<!DOCTYPE html><html lang=\"de\"><head>"));
  client.println(F("<meta charset=\"UTF-8\">"));
  client.println(F("<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">"));
  client.println(F("<title>Shelly Control</title>"));
  client.println(F("<style>"));
  client.println(F("*{box-sizing:border-box;}"));
  client.println(F("body{margin:0;min-height:100vh;display:flex;align-items:center;"));
  client.println(F("justify-content:center;background:radial-gradient(circle at top,#1b2735,#090a0f);"));
  client.println(F("font-family:'Segoe UI',Roboto,Consolas,monospace;color:#e6edf3;}"));
  client.println(F(".card{background:#111820;border:1px solid #1f2937;border-radius:16px;"));
  client.println(F("padding:36px 40px;box-shadow:0 0 40px rgba(61,220,132,.08),0 8px 24px rgba(0,0,0,.6);"));
  client.println(F("max-width:460px;width:90%;text-align:center;}"));
  client.println(F(".badge{display:inline-flex;align-items:center;gap:6px;background:#0d2818;"));
  client.println(F("color:#3ddc84;border:1px solid #1f6b45;padding:4px 12px;border-radius:20px;"));
  client.println(F("font-size:11px;letter-spacing:1px;text-transform:uppercase;margin-bottom:18px;}"));
  client.println(F(".dot{width:8px;height:8px;border-radius:50%;background:#3ddc84;"));
  client.println(F("box-shadow:0 0 8px #3ddc84;}"));
  client.println(F("h1{font-size:22px;letter-spacing:2px;margin:0 0 4px;text-transform:uppercase;}"));
  client.println(F("p.sub{color:#6b7684;font-size:13px;margin:0 0 28px;}"));
  client.println(F(".devices{display:flex;flex-direction:column;gap:16px;}"));
  client.println(F(".device{border:1px solid #1f2937;border-radius:12px;padding:14px 16px;"));
  client.println(F("background:#0d131a;text-align:left;}"));
  client.println(F(".device.aktiv{border-color:#d4b106;box-shadow:0 0 0 1px #d4b106 inset;}"));
  client.println(F(".device-name{font-size:14px;font-weight:600;letter-spacing:.3px;margin-bottom:10px;}"));
  client.println(F(".device-ip{color:#6b7684;font-weight:400;font-size:12px;}"));
  client.println(F(".device-buttons{display:flex;gap:8px;}"));
  client.println(F(".device-buttons a.btn{flex:1;display:flex;align-items:center;justify-content:center;"));
  client.println(F("gap:6px;padding:10px 4px;border-radius:8px;text-decoration:none;font-size:13px;"));
  client.println(F("font-weight:600;letter-spacing:.3px;color:#fff;border:1px solid rgba(255,255,255,.08);}"));
  client.println(F(".an{background:linear-gradient(135deg,#1f9d55,#0c6b34);"));
  client.println(F("box-shadow:0 4px 14px rgba(31,157,85,.35);}"));
  client.println(F(".aus{background:linear-gradient(135deg,#d64545,#8f1f1f);"));
  client.println(F("box-shadow:0 4px 14px rgba(214,69,69,.35);}"));
  client.println(F(".timer{background:linear-gradient(135deg,#2f7fd6,#14417d);"));
  client.println(F("box-shadow:0 4px 14px rgba(47,127,214,.35);}"));
  client.println(F("</style></head><body>"));

  client.println(F("<div class=\"card\">"));
  client.println(F("<div class=\"badge\"><span class=\"dot\"></span>Gateway Online</div>"));
  client.println(F("<h1>Shelly Control</h1>"));
  client.println(F("<p class=\"sub\">Arduino UNO R4 WiFi &middot; Ethernet Relay Gateway</p>"));

  client.println(F("<div class=\"devices\">"));
  for (uint8_t i = 0; i < ANZAHL_SHELLYS; i++) {
    client.print(F("<div class=\"device"));
    if (i == aktiverShellyIndex) {
      client.print(F(" aktiv"));
    }
    client.println(F("\">"));

    client.print(F("<div class=\"device-name\">"));
    client.print(shellys[i].name);
    client.print(F(" <span class=\"device-ip\">("));
    client.print(shellys[i].ip);
    client.println(F(")</span></div>"));

    client.println(F("<div class=\"device-buttons\">"));

    client.print(F("<a class=\"btn an\" href=\"/shelly/"));
    client.print(i);
    client.println(F("/an\">&#9889; EIN</a>"));

    client.print(F("<a class=\"btn aus\" href=\"/shelly/"));
    client.print(i);
    client.println(F("/aus\">&#9209; AUS</a>"));

    client.print(F("<a class=\"btn timer\" href=\"/shelly/"));
    client.print(i);
    client.println(F("/an3\">&#9201; 3s</a>"));

    client.println(F("</div>")); // device-buttons
    client.println(F("</div>")); // device
  }
  client.println(F("</div>")); // devices

  client.println(F("</div>")); // card

  client.println(F("</body></html>"));
}