Shelly Plug S Gen3 mit Arduino UNO und Ethernet Shield steuern

So schaltest du einen Shelly Aktor direkt aus einem Arduino-Webserver heraus – ganz ohne Cloud.

In diesem Beitrag geht es um ein kleines, aber sehr interessantes Praxisprojekt: Ein Arduino UNO R3 mit Ethernet Shield stellt bereits einen einfachen Webserver im lokalen Netzwerk bereit. Über diesen Webserver sollen nun zusätzlich Shelly Aktoren geschaltet werden – konkret ein Shelly Plug S Gen3.

Auf den ersten Blick wirkt das fast ein wenig ungewöhnlich. Warum sollte man im Jahr 2026 noch einen klassischen Arduino UNO mit Ethernet Shield verwenden, wenn ein ESP32 deutlich mehr Leistung bietet, WLAN bereits integriert hat und für IoT-Projekte fast schon der Standard geworden ist?

Genau deshalb ist dieses Projekt spannend.

Denn nicht jedes Smart-Home-Projekt braucht sofort den modernsten Mikrocontroller. Manchmal ist eine einfache, kabelgebundene und gut nachvollziehbare Lösung genau das Richtige. Der Arduino UNO ist zwar betagt, aber robust, gut dokumentiert und für viele Einsteiger noch immer ein sehr greifbarer Einstieg in die Welt der Mikrocontroller. In Kombination mit einem Ethernet Shield wird daraus ein kleiner Webserver im eigenen LAN.

Der Shelly Plug S Gen3 bringt die moderne Smart-Home-Seite in dieses Projekt. Er kann lokal im Netzwerk per HTTP-Befehl geschaltet werden. Damit muss der Arduino keine Shelly-App bedienen, keine Cloud ansprechen und auch kein komplexes Smart-Home-System nachbilden. Er muss im Prinzip nur eines können: beim Klick auf einen Link einen HTTP-Request an den Shelly senden.

Das klingt simpel – und genau das ist der Reiz daran.

In diesem Beitrag schauen wir uns an, wie man einen Shelly Plug S Gen3 aus einem Arduino-Webserver heraus schalten kann, warum der Arduino UNO trotz seiner begrenzten Leistung für diesen Zweck ausreicht und wo die Grenzen gegenüber einem ESP32 liegen.

Bevor wir in das eigentliche Projekt einsteigen, möchte ich mich an dieser Stelle bei Alfred H. bedanken. Er ist mit genau diesem Problem auf mich zugekommen und hat mir damit den Anstoß für diesen Beitrag gegeben.

Solche Fragen aus der Community sind für meinen Blog besonders wertvoll, denn sie zeigen sehr schön, welche Themen nicht nur theoretisch interessant sind, sondern in der Praxis wirklich gebraucht werden. Oft entstehen genau daraus die spannendsten Projekte: ein konkretes Problem, eine vorhandene Hardware und die Frage, wie man daraus eine funktionierende Lösung baut.

In diesem Fall geht es um einen Arduino UNO mit Ethernet Shield, der bereits als kleiner Webserver im lokalen Netzwerk läuft. Die Erweiterungsidee: Über diesen Webserver sollen nun zusätzlich Shelly Aktoren geschaltet werden – lokal, direkt und ohne Cloud.

Warum überhaupt ein Arduino UNO und kein ESP32?

Wenn man heute ein neues IoT-Projekt plant, landet man sehr schnell beim ESP32. Das ist auch absolut nachvollziehbar. Der ESP32 bietet WLAN, Bluetooth, deutlich mehr Speicher, mehr Rechenleistung und ist für viele Smart-Home-Projekte eine sehr gute Wahl.

Der Arduino UNO R3 spielt in einer anderen Liga. Er ist langsamer, hat wenig Speicher und bringt von Haus aus keine Netzwerkfunktion mit. Für WLAN oder Ethernet wird zusätzliche Hardware benötigt. In diesem Projekt ist das ein Ethernet Shield.

Trotzdem hat der Arduino hier einen entscheidenden Vorteil: Die Aufgabe ist sehr klar begrenzt.

Er muss keine aufwendige Weboberfläche rendern, keine verschlüsselte Cloud-Verbindung halten und keine großen Datenmengen verarbeiten. Der Arduino stellt eine einfache lokale Webseite bereit. Klickt man dort auf einen Link oder Button, soll ein HTTP-Befehl an den Shelly Plug S Gen3 gesendet werden.

Mehr nicht.

Und genau an dieser Stelle zeigt sich: Für einfache lokale Steuerungsaufgaben muss es nicht immer der leistungsstärkste Mikrocontroller sein. Ein alter Arduino UNO kann hier immer noch sinnvoll eingesetzt werden, wenn man die Aufgabe passend zuschneidet.

Was wird für das Projekt benötigt?

Für den Aufbau wird nur wenig Hardware benötigt:

• ein Arduino UNO R3*
• ein Ethernet Shield*
• ein Shelly Plug S Gen3*

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Voraussetzungen im Netzwerk

Damit die Steuerung funktioniert, müssen sich der Arduino UNO und der Shelly Plug S Gen3 im selben lokalen Netzwerk befinden.

Der Arduino ist über das Ethernet Shield per LAN verbunden und stellt dort seinen kleinen Webserver bereit. Gleichzeitig kann er HTTP-Anfragen an andere Geräte im Netzwerk senden.

Der Shelly Plug S Gen3 sollte eine feste IP-Adresse oder eine feste DHCP-Zuweisung im Router bekommen. Dadurch bleibt die Adresse des Shelly gleich und der Arduino kann ihn zuverlässig erreichen.

Warum eine feste IP-Adresse sinnvoll ist

Damit der Arduino den Shelly Plug S Gen3 zuverlässig erreichen kann, sollte sich dessen IP-Adresse nicht ändern. Wird die IP-Adresse automatisch per DHCP vergeben, kann der Router dem Shelly später unter Umständen eine andere Adresse zuweisen.

In diesem Fall würde der Arduino weiterhin versuchen, die alte Adresse aufzurufen, und der Schaltbefehl käme nicht mehr beim Shelly an.

Deshalb ist es sinnvoll, dem Shelly entweder direkt im Router eine feste DHCP-Zuweisung zu geben oder in der Shelly-Oberfläche eine feste IP-Adresse einzutragen.

Für viele Heimnetzwerke ist die feste DHCP-Zuweisung im Router die einfachere Variante. Dabei merkt sich der Router die MAC-Adresse des Shelly und vergibt ihm immer wieder dieselbe IP-Adresse.

Der Arduino-Sketch für den Webserver

Nun kommen wir zum eigentlichen Arduino-Sketch. Der Arduino UNO R3 übernimmt in diesem Projekt zwei Aufgaben gleichzeitig:

Er stellt eine kleine Webseite im lokalen Netzwerk bereit und reagiert auf die dort angeklickten Schaltflächen. Wird zum Beispiel der Button EIN angeklickt, dann ruft nicht der Browser direkt den Shelly auf, sondern der Arduino selbst sendet einen HTTP-Request an den Shelly Plug S Gen3.

Genau das ist der wichtige Punkt an diesem Aufbau.

Der Arduino wird damit zu einer kleinen lokalen Steuerzentrale. Die Webseite ist nur die Bedienoberfläche. Die eigentliche Aktion, also der Schaltbefehl an den Shelly, wird vom Arduino ausgeführt.

IP-Adressen im Sketch anpassen

Bevor der Sketch auf den Arduino UNO R3 übertragen wird, müssen im Konfigurationsbereich die IP-Adressen angepasst werden:

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

// IP-Adresse des Shelly Plug S Gen3
IPAddress shellyIp(192, 168, 178, 165);

arduinoIp ist die Adresse, unter der später die Webseite des Arduino-Webservers im Browser geöffnet wird.

shellyIp ist die Adresse des Shelly Plug S Gen3, an den der Arduino später den HTTP-Schaltbefehl sendet.

Die Werte müssen zu deinem eigenen Netzwerk passen. Aus der Shelly-Adresse 172.20.100.12 wird im Sketch zum Beispiel:

IPAddress shellyIp(172, 20, 100, 12);

Der vollständige Arduino-Sketch

Den vollständigen Sketch habe ich in den folgenden Detail-Block gepackt. So bleibt der Beitrag besser lesbar, und wer den Code direkt übernehmen oder anpassen möchte, kann ihn einfach aufklappen.

/*
  shellyWebserver.ino

  Arduino UNO R3 + Ethernet Shield (W5100/W5500)
  ------------------------------------------------
  Der Arduino stellt eine eigene Testseite fuer einen Shelly Plug bereit.
  Klickt man dort auf einen der Buttons, ruft NICHT der Browser den Shelly
  direkt auf, sondern der ARDUINO SELBST schickt als HTTP-Client die
  passende Anfrage an den Shelly (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

  Dadurch bleibt die Steuerung zentral auf dem Arduino und man kann sie
  später leicht um eigene Relaiskarten (z.B. Treppenhauslicht) erweitern.

  Anpassen muss man nur den Block "Konfiguration" weiter unten.
*/

#include <SPI.h>
#include <Ethernet.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
// (an das jeweilige Heimnetz anpassen, z.B. 172.20.100.50 bei Herrn Heuer)
IPAddress arduinoIp(192, 168, 178, 50);

// IP-Adresse des Shelly, der die Infrarotheizung schaltet
IPAddress shellyIp(192, 168, 178, 165);
const uint16_t shellyPort = 80;

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

EthernetServer server(80);

// 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];

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

  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() {
  EthernetClient client = server.available();
  if (!client) {
    return;
  }

  liesAnfrageZeile(client, requestBuffer, REQUEST_BUFFER_SIZE);

  if (strstr(requestBuffer, "GET /shelly/an3") != nullptr) {
    schalteShelly(true, 3);
    sendeRedirect(client);
  } else if (strstr(requestBuffer, "GET /shelly/an") != nullptr) {
    schalteShelly(true, 0);
    sendeRedirect(client);
  } else if (strstr(requestBuffer, "GET /shelly/aus") != nullptr) {
    schalteShelly(false, 0);
    sendeRedirect(client);
  } else {
    sendeStartseite(client);
  }

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

// 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, um ihn ein- oder
// auszuschalten. timerSekunden > 0 schaltet den Shelly nach der
// angegebenen Zeit automatisch wieder aus (nur bei einschalten == true).
void schalteShelly(bool einschalten, unsigned int timerSekunden) {
  EthernetClient shellyClient;

  if (!shellyClient.connect(shellyIp, 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(shellyIp);
  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:420px;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(".buttons{display:flex;flex-direction:column;gap:14px;}"));
  client.println(F("a.btn{display:flex;align-items:center;justify-content:center;gap:10px;"));
  client.println(F("padding:16px;border-radius:10px;text-decoration:none;font-size:15px;"));
  client.println(F("font-weight:600;letter-spacing:.5px;color:#fff;"));
  client.println(F("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("footer{margin-top:28px;font-size:11px;color:#4b5563;"));
  client.println(F("font-family:Consolas,monospace;}"));
  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 &middot; Ethernet Relay Gateway</p>"));
  client.println(F("<div class=\"buttons\">"));
  client.println(F("<a class=\"btn an\" href=\"/shelly/an\">&#9889; EIN</a>"));
  client.println(F("<a class=\"btn aus\" href=\"/shelly/aus\">&#9209; AUS</a>"));
  client.println(F("<a class=\"btn timer\" href=\"/shelly/an3\">&#9201; EIN für 3 Sekunden</a>"));
  client.println(F("</div>"));

  client.print(F("<footer>Ziel-Gerät: "));
  client.print(shellyIp);
  client.println(F("</footer>"));
  client.println(F("</div>"));

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

Wichtig: Vor dem Hochladen müssen im Sketch die IP-Adressen für den Arduino UNO und den Shelly Plug S Gen3 angepasst werden.

Was passiert im Sketch?

Der Sketch wirkt auf den ersten Blick etwas umfangreicher, die eigentliche Idee dahinter ist aber recht einfach.

Der Arduino UNO R3 übernimmt in diesem Projekt zwei Rollen. Zum einen ist er ein kleiner Webserver, der eine Webseite im lokalen Netzwerk bereitstellt. Zum anderen ist er ein HTTP-Client, der selbst einen Schaltbefehl an den Shelly Plug S Gen3 sendet.

Wird die Startseite des Arduino-Webservers im Browser geöffnet, liefert der Arduino die kleine Bedienoberfläche mit den Schaltflächen aus. Über diese Schaltflächen wird aber nicht direkt der Shelly aufgerufen. Stattdessen ruft der Browser nur eine Adresse auf dem Arduino auf.

Zum Beispiel:

/shelly/an

Der Arduino erkennt diesen Aufruf im Sketch und sendet anschließend selbst den passenden HTTP-Request an den Shelly Plug S Gen3.

Die Zuordnung sieht dabei so aus:

Der Ablauf ist also:

• Der Browser öffnet die Webseite des Arduino-Webservers.
• Der Nutzer klickt auf einen Button.
• Der Arduino erkennt den passenden Pfad.
• Der Arduino baut eine Verbindung zum Shelly Plug S Gen3 auf.
• Der Arduino sendet den HTTP-Schaltbefehl.
• Der Browser wird wieder zurück auf die Startseite geleitet.

Diese Weiterleitung ist wichtig. Würde der Browser nach dem Schalten einfach auf der Aktionsadresse stehen bleiben, könnte ein erneutes Laden der Seite denselben Schaltbefehl noch einmal ausführen. Durch den Redirect zurück auf die Startseite wird genau das verhindert.

Besonders interessant ist dabei die Trennung zwischen Bedienoberfläche und Schaltlogik. Die Webseite dient nur als Oberfläche. Die eigentliche Steuerung übernimmt der Arduino. Dadurch bleibt der Arduino die zentrale Stelle im Projekt und kann später leichter um weitere Funktionen erweitert werden, zum Beispiel um zusätzliche Relaiskarten, weitere Shelly-Geräte oder eigene Zeitlogik.

Alternative Idee: Shelly-Steuerung mit ESP32 und OLED-Display

Auch wenn der Fokus in diesem Beitrag bewusst auf dem Arduino UNO R3 mit Ethernet Shield liegt, gibt es natürlich moderne Alternativen. Eine spannende Möglichkeit ist ein kleiner LilyGo-Mikrocontroller mit ESP32-Chip.

Der Vorteil liegt auf der Hand: Der ESP32 bringt WLAN bereits mit. Es wird also kein Ethernet Shield benötigt. Einige dieser kleinen Boards lassen sich außerdem direkt über USB betreiben und können zum Beispiel direkt in ein USB-Ladegerät gesteckt werden. Dadurch entfällt ein zusätzlicher Aufbau mit Netzwerkkabel und separater Stromversorgung.

Besonders interessant sind Varianten mit kleinem OLED-Display. Auf diesem Display könnte man zum Beispiel die aktuelle IP-Adresse des Webservers anzeigen lassen. Das ist in der Praxis sehr hilfreich, denn man sieht direkt am Gerät, unter welcher Adresse die Steuerseite im Browser erreichbar ist.

Damit wäre ein ähnliches Projekt auch mit einem ESP32 denkbar:

• ESP32 startet einen kleinen Webserver
• IP-Adresse wird auf dem OLED-Display angezeigt
• Webseite bietet Buttons zum Schalten des Shelly Plug S Gen3
• ESP32 sendet den HTTP-Request direkt an den Shelly
• Kommunikation bleibt lokal und ohne Cloud

Das wäre technisch moderner und kompakter als die Arduino-UNO-Variante. Gleichzeitig zeigt es aber auch sehr schön den Unterschied zwischen beiden Ansätzen: Der Arduino UNO mit Ethernet Shield ist kabelgebunden und klassisch, der ESP32 mit OLED-Display wäre kompakter, flexibler und eher die moderne IoT-Variante.

Für diesen Beitrag bleibt der Arduino UNO aber bewusst im Mittelpunkt, weil genau darin der Reiz des Projekts liegt: Eine einfache, vorhandene Lösung wird sinnvoll erweitert, ohne direkt die komplette Hardware austauschen zu müssen.

Fazit: Alter Arduino, modernes Smart Home

Dieses Projekt zeigt sehr schön, dass ein Arduino UNO R3 auch heute noch sinnvoll eingesetzt werden kann. Natürlich ist ein ESP32 moderner, leistungsfähiger und bringt WLAN direkt mit. Für viele IoT-Projekte ist das ein klarer Vorteil.

In diesem Fall geht es aber nicht darum, möglichst viel Leistung auf dem Mikrocontroller zu haben. Die Aufgabe ist klar begrenzt: Ein kleiner Webserver soll im lokalen Netzwerk eine einfache Bedienoberfläche bereitstellen und bei Bedarf einen HTTP-Schaltbefehl an einen Shelly Plug S Gen3 senden.

Genau dafür reicht der Arduino UNO mit Ethernet Shield aus.

Besonders spannend finde ich an diesem Aufbau die Trennung zwischen Bedienoberfläche und Schaltlogik. Der Browser ruft nicht direkt den Shelly auf, sondern spricht nur den Arduino-Webserver an. Der Arduino entscheidet anschließend, welcher Schaltbefehl an den Shelly gesendet wird. Dadurch bleibt die Steuerung zentral auf dem Arduino und kann später leichter erweitert werden.

Denkbar wären zum Beispiel weitere Shelly-Geräte, zusätzliche Relaiskarten, Zeitfunktionen oder einfache Sicherheitsabfragen. Aus einem kleinen Arduino-Webserver wird damit Schritt für Schritt eine lokale Steuerzentrale für einfache Smart-Home-Aufgaben.

Für mich ist dieses Projekt auch ein gutes Beispiel dafür, warum Fragen aus der Community so wertvoll sind. Aus einem konkreten Problem entsteht ein praxisnaher Beitrag, der nicht nur theoretisch zeigt, was möglich ist, sondern eine echte Anwendung aus dem Alltag aufgreift.

Der Arduino UNO ist also nicht der modernste Mikrocontroller. Aber wenn die Aufgabe klar definiert ist, kann genau diese einfache und robuste Technik noch immer eine gute Lösung sein.

Letzte Aktualisierung am: 13. Juli 2026