Wie funktioniert das Fading eines LEDs mit Arduino? Ein praktischer Überblick.

Im Umgang mit Arduino-Plattformen gibt es grundlegende Konzepte, die das Verständnis und die Programmierung von Projekten erleichtern. Eine dieser Anwendungen ist das Fading von LEDs, eine einfache und häufig verwendete Technik, bei der das Licht einer LED allmählich heller und wieder dunkler wird. In diesem Kapitel betrachten wir, wie man mit einem Arduino-Board und wenigen Zeilen Code eine LED zum Faden bringt und welche grundlegenden Prinzipien dabei zum Tragen kommen.

Die beiden wichtigsten Verbindungen für jedes Arduino-Projekt sind Strom (Power) und Masse (Ground). Diese Verbindungen sind in der Regel rot und schwarz, wobei es in einigen Fällen auch zu einer Umbenennung in Weiß und Schwarz kommen kann, wie es in Kapitel 6 angesprochen wird. Eine weitere Verbindung ist das Signal, das zwischen dem Arduino und dem angeschlossenen Bauteil (z. B. einer LED) den elektrischen Strom überträgt. Die Signalleitungen sind meist in einer anderen Farbe, um sie von den Strom- und Masseleitungen zu unterscheiden.

Im „Fade“-Sketch wird die Helligkeit der LED mittels der Funktion analogWrite() gesteuert. Diese Funktion ermöglicht es, einen Wert zwischen 0 und 255 an einen PWM-fähigen Pin zu senden, wobei 0 für aus (0V) und 255 für voll an (5V) steht. Alle Werte dazwischen regeln die Helligkeit der LED in kontinuierlichen Abstufungen.

Der Arduino-Code, der für dieses Projekt benötigt wird, sieht folgendermaßen aus:

cpp
Copy code
int led = 9;           // Der Pin, an dem die LED angeschlossen ist

int brightness = 0;    // Die Helligkeit der LED
int fadeAmount = 5;    // Wie viele Schritte die Helligkeit verändert wird
void setup() {
  pinMode(led, OUTPUT); // Pin 9 als Ausgang definieren
}
void loop() {
  analogWrite(led, brightness);  // Helligkeit auf den Pin setzen
  brightness = brightness + fadeAmount;  // Helligkeit anpassen
  if (brightness == 0 || brightness == 255) {
    fadeAmount = -fadeAmount; // Richtung des Fadens umkehren
  }
  delay(30);  // Eine kurze Verzögerung, damit der Fading-Effekt sichtbar wird
}

Der Ablauf dieses Codes ist einfach, aber effektiv. Zuerst wird die Helligkeit der LED auf einen Wert zwischen 0 und 255 gesetzt. Der Wert für die Helligkeit wird in jeder Iteration des Hauptprogramms um einen festgelegten Wert (fadeAmount) erhöht oder verringert. Sobald der Wert 0 oder 255 erreicht, kehrt sich die Richtung der Helligkeitserhöhung um, wodurch die LED wieder dunkler wird, bis sie erneut den Wert 0 erreicht, um dann erneut heller zu werden. Diese einfache Technik sorgt für den kontinuierlichen Fading-Effekt.

Beim Programmieren ist es entscheidend, dass der Code fehlerfrei ist. Ein häufiger Fehler tritt auf, wenn die Verbindungen auf dem Breadboard nicht korrekt gesetzt sind. Stellen Sie sicher, dass der lange Bein der LED an Pin 9 und das kurze Bein über einen Widerstand mit dem Ground (GND) verbunden ist. Auch die korrekte Verkabelung auf dem Breadboard ist wichtig, da falsche Verbindungen zu Funktionsstörungen führen können.

Der wichtigste Aspekt dieses Sketches ist das Verständnis für die Variablen und die Logik hinter der analogWrite() Funktion. Diese Funktion ermöglicht es, eine variable Spannung auf einem PWM-fähigen Pin auszugeben, was die Helligkeit der LED steuert. Mit der Variable brightness wird der Helligkeitswert bestimmt, und fadeAmount gibt an, wie stark der Helligkeitswert bei jeder Iteration verändert wird. Wenn die Helligkeit den maximalen Wert 255 erreicht, kehrt sich die Richtung um, und die LED beginnt, ihre Helligkeit zu verringern.

Das Konzept hinter dem Fading

Das Hauptkonzept des Fadens besteht darin, dass eine kontinuierliche Anpassung der Helligkeit der LED über eine Vielzahl von Werten hinweg stattfindet. Dies wird durch die analogWrite() Funktion erreicht, die es ermöglicht, mit einem Wert von 0 bis 255 eine proportionale Spannung auf dem Pin zu erzeugen. Im Gegensatz zu einfachen „Ein-Ausschalter“-Befehlen sorgt diese Funktion dafür, dass die LED schrittweise von ganz aus bis ganz an oder umgekehrt verändert wird.

Eine weitere wichtige Beobachtung ist der Einsatz der if-Bedingung, die sicherstellt, dass die Helligkeit der LED innerhalb des erlaubten Bereichs bleibt. Wenn die Helligkeit 0 oder 255 erreicht, wird die Richtung der Änderung umgekehrt. Ohne diese Bedingung würde die LED entweder dauerhaft an oder aus bleiben, sobald ein Grenzwert erreicht ist. Dies ist ein fundamentales Konzept der Programmlogik, das es ermöglicht, wiederholende, kontinuierliche Veränderungen zu erzeugen, ohne dass der Code manuell angepasst werden muss.

Optimierungen und Anpassungen

Der vorgestellte „Fade“-Sketch ist eine der einfacheren Arten, ein LED-Fading zu realisieren. Es gibt jedoch viele Möglichkeiten, den Code und das Verhalten der LED weiter anzupassen. Man kann beispielsweise die Geschwindigkeit des Fadens ändern, indem man den Wert der delay() Funktion verändert, oder man könnte den fadeAmount variabel gestalten, um einen nicht gleichmäßigen Verlauf zu erzeugen.

Es gibt auch zahlreiche andere Techniken, die in ähnlichen Projekten angewendet werden können. Eine Möglichkeit wäre, statt einer linearen Helligkeitserhöhung eine logarithmische oder exponentielle Änderung zu implementieren, um das Verhalten der LED noch interessanter und komplexer zu gestalten. Solche Anpassungen können die kreativen Möglichkeiten bei der Arbeit mit Arduino erheblich erweitern.

Wie steuert man einen Servo mit Arduino: Grundlagen und fortgeschrittene Anwendungen

Nachdem Sie die Skizze gefunden haben, drücken Sie die Schaltfläche „Kompilieren“, um den Code zu überprüfen. Der Compiler sollte, wie immer, etwaige syntaktische Fehler in Rot im Nachrichtenbereich anzeigen, wenn sie entdeckt werden. Wenn die Skizze ohne Fehler kompiliert, klicken Sie auf „Hochladen“, um die Skizze auf Ihr Board zu laden. Nach dem Hochladen sollte sich der Motor hin und her bewegen und eine Art Tanz auf dem Tisch aufführen. Wenn nichts passiert, sollten Sie Ihre Verkabelung noch einmal überprüfen:

• Stellen Sie sicher, dass Sie Pin 9 für die Datenleitung (weiß/gelb) verwenden.

• Überprüfen Sie, ob die anderen Servo-Leitungen an den richtigen Pins angeschlossen sind.

Verstehen der Sweep-Skizze

Zu Beginn dieser Skizze wird eine Bibliothek eingebunden. Dies ist die Servo-Bibliothek, die Ihnen hilft, mit sehr wenig komplexem Code viel aus Ihrem Servo herauszuholen. Der folgende Code-Schnipsel erstellt ein Servo-Objekt. Die Bibliothek weiß, wie man Servos steuert, benötigt jedoch einen Namen für jedes Servo, um mit ihm zu kommunizieren. In diesem Fall wird das neue Servo-Objekt „myservo“ genannt. Die Wahl des Namens ist frei, solange er im gesamten Code konsistent bleibt und keine reservierten Wörter wie „int“ oder „delay“ verwendet werden.

cpp
Copy code
#include <Servo.h>
Servo myservo;  // Erzeugt ein Servo-Objekt zur Steuerung eines Servos
int pos = 0;     // Variable zur Speicherung der Servo-Position

Im Setup wird lediglich der Pin des Arduino festgelegt, der mit dem Servo kommuniziert. In diesem Beispiel verwenden Sie Pin 9, aber es könnte jeder PWM-fähige Pin sein.

cpp
Copy code
void setup() {

  myservo.attach(9);  // Weist das Servo-Objekt dem Pin 9 zu
}

Die Schleife besteht aus zwei einfachen for-Schleifen, die das Servo erst in eine Richtung und dann in die andere bewegen. Die erste Schleife erhöht den Wert der Position von 0 bis 180 in Schritten von 1. Dabei wird der Wert jedes Mal an das Servo gesendet, wobei die Funktion write() verwendet wird, die speziell für die Servo-Bibliothek vorgesehen ist. Nach jedem Schritt erfolgt eine kurze Verzögerung von 15 Millisekunden, um dem Servo Zeit zu geben, seine neue Position zu erreichen.

cpp
Copy code
void loop() {
  for (pos = 0; pos < 180; pos += 1) {
    myservo.write(pos);   // Weist das Servo an, die Position in der Variable 'pos' anzufahren
    delay(15);             // Wartet 15 ms, bis das Servo die Position erreicht hat
  }
  for (pos = 180; pos >= 1; pos -= 1) {
    myservo.write(pos);   // Bewegt das Servo zurück zur Ausgangsposition
    delay(15);             // Wartet 15 ms, bis das Servo die Position erreicht hat
  }
}

Dies ist das einfachste Servo-Beispiel und eignet sich gut, um zu testen, ob der Servo korrekt funktioniert.

Steuerung des Servos mit einem Potentiometer

Die Knopf-Skizze

Dieses Beispiel zeigt Ihnen, wie Sie mit einem Potentiometer die Position eines Servos einstellen können. Sie benötigen:

• Einen Arduino Uno

• Ein Breadboard

• Ein Servo

• Einen 10k Ohm variablen Widerstand (Potentiometer)

• Jumper-Kabel

Das Servo wird genau wie im Sweep-Beispiel verdrahtet, aber diesmal benötigen Sie zusätzliche Verbindungen zu 5V und GND für das Potentiometer, weshalb Sie ein Breadboard verwenden müssen, um die zusätzlichen Pins bereitzustellen. Verbinden Sie die 5V- und GND-Pins des Arduinos mit den positiven (+) und negativen (-) Reihen auf dem Breadboard. Das Servo wird über das Breadboard verbunden: Das rote Kabel geht an den 5V-Pin, das schwarze/braune Kabel an den GND-Pin und das weiße/gelbe Kabel an Pin 9 des Arduinos. Das Potentiometer wird ebenfalls an das Breadboard angeschlossen, wobei der mittlere Pin an Pin A0 des Arduinos und die anderen beiden Pins an 5V und GND angeschlossen werden.

Nachdem die Schaltung aufgebaut ist, öffnen Sie die Skizze, indem Sie „Datei“ ➪ „Beispiele“ ➪ „Servo“ ➪ „Knopf“ auswählen. Der Code für diese Skizze lautet wie folgt:

cpp
Copy code
#include <Servo.h>

Servo myservo;  // Erzeugt ein Servo-Objekt zur Steuerung eines Servos
int potpin = 0;  // Der analoge Pin, an dem das Potentiometer angeschlossen ist
int val;          // Variable zur Speicherung des Wertes des Potentiometers
void setup() {
  myservo.attach(9);  // Weist das Servo-Objekt dem Pin 9 zu
}
void loop() {
  val = analogRead(potpin);          // Liest den Wert des Potentiometers (zwischen 0 und 1023)
  val = map(val, 0, 1023, 0, 179);   // Skaliert den Wert für das Servo (zwischen 0 und 180)
  myservo.write(val);                // Setzt die Servo-Position gemäß dem skalierten Wert
  delay(15);                         // Wartet, bis das Servo die Position erreicht hat
}

Nach dem Kompilieren und Hochladen des Codes sollten Sie in der Lage sein, die Servo-Position durch Drehen des Potentiometers zu steuern. Wenn dies nicht funktioniert, überprüfen Sie noch einmal Ihre Verkabelung:

• Stellen Sie sicher, dass Sie Pin 9 für die Datenleitung des Servos verwenden.

• Überprüfen Sie, ob der mittlere Pin des Potentiometers korrekt mit dem analogen Pin A0 verbunden ist.

• Vergewissern Sie sich, dass alle Verbindungen auf dem Breadboard korrekt sind.

Verstehen der Knopf-Skizze

In den Deklarationen wird die Servo-Bibliothek, Servo.h, eingebunden und ein neues Servo-Objekt erstellt. Der analoge Eingangspin wird auf 0 gesetzt, was bedeutet, dass Sie den Pin A0 verwenden. Es gibt auch eine Variable, die den Wert des Potentiometers speichert. Dieser Wert wird kontinuierlich gelesen und für die Steuerung des Servos verwendet.

Es ist wichtig, dass Sie bei der Verwendung des analogRead()-Werts die Umrechnung mit der map()-Funktion korrekt durchführen, um sicherzustellen, dass der Wertebereich des Potentiometers (0 bis 1023) in den Bereich des Servos (0 bis 179) übertragen wird. Denken Sie daran, dass der Wertebereich bei Arduino-Skizzen oft von 0 bis 179 reicht, nicht von 0 bis 180, was auf das übliche Konzept des „nullbasierten Indexes“ zurückzuführen ist.

Wie baut und lötet man eine Arduino-Shield-Schaltung sicher und effizient?

Nachdem die Header-Pins auf dem Shield in Reihen korrekt ausgerichtet und fixiert sind, wird jeder Pin sorgfältig verlötet. Diesen Vorgang wiederholt man für alle Segmente des Headers. Der Taster wird einfach an der vorgesehenen Position auf der Oberseite der Platine eingesetzt, wobei seine Beine durch die spezielle Konstruktion einrasten. Gegebenenfalls kann Klebepaste zur zusätzlichen Fixierung verwendet werden. Anschließend wird die Platine umgedreht und die gleichen Löttechniken wie zuvor angewendet. Zum Abschluss ist eine gründliche visuelle Kontrolle unerlässlich, um sicherzustellen, dass keine Lötstellen benachbarter Pins miteinander verbunden sind. Ein Kurzschluss durch verbundene Pins kann die Platine irreparabel beschädigen. Im Zweifelsfall hilft die Durchgangsprüfung am Multimeter, die korrekte elektrische Trennung zu überprüfen – Pins, die nicht verbunden sein sollen, dürfen kein Signal (Piepton) geben.

Ist die Shield-Platine korrekt bestückt, legt man sie auf das Arduino-Board und überprüft den korrekten Sitz. Passt alles, ist die Platine bereit für die eigentliche Schaltung.

Die Anordnung auf der Shield-Platine unterscheidet sich vom Steckbrett, da sie keine durchgehenden Reihen von Löchern hat, sondern einzelne Löcher, die meist für integrierte Schaltkreise (ICs) gruppiert sind. Die Verbindungen zwischen den Bauteilen werden durch kurze Drahtstücke hergestellt, die man passend zuschneidet und vorbereitet. Dabei werden die Beine der Bauteile auf etwa 45 Grad abgewinkelt, um einen festen Halt beim Löten zu gewährleisten. Drahtenden werden abisoliert, mitunter verzinnt, damit sie nicht ausfransen und gut leitend verlötet werden können.

Das eigentliche Löten verlangt ruhige Hände und Sorgfalt. Es gibt keine ästhetisch verbindliche Vorgabe für Lötstellen, wichtig ist, dass die Verbindung mechanisch fest und elektrisch einwandfrei ist. Einige Löter wickeln den Draht um die Bauteilbeine, andere setzen die Drahtenden sauber nebeneinander. Wichtig ist die richtige Polung der Bauteile, besonders bei LEDs.

Als kostengünstige Alternative zu fertigen Arduino-Shields bietet sich der Einsatz von Streifenrasterplatinen (Stripboard) an. Diese besitzen Löcher in einem Raster von 2,54 mm (0,1 Zoll), passend zum Arduino-Pinabstand, und meist längs verlaufende Kupferstreifen, die für elektrische Verbindungen genutzt werden können. So lassen sich eigene, maßgeschneiderte Shields bauen, die zwar mehr Planungsaufwand erfordern, aber wesentlich flexibler und preiswerter sind.

Nach dem erfolgreichen Zusammenbau und Löten wird das Shield auf das Arduino gesteckt und auf Funktion getestet. Ein ordentlicher Aufbau ermöglicht eine saubere und robuste Schaltung, die praktisch einsatzbereit ist.

Neben der beschriebenen praktischen Vorgehensweise ist es für den Leser essenziell, auch die physikalischen und elektrischen Grundlagen zu verstehen, die das Löten und die Schaltungsplanung untermauern. Beispielsweise sollte man sich mit den Eigenschaften der verwendeten Materialien, der richtigen Temperaturführung beim Löten und der Vermeidung von Kaltlötstellen auseinandersetzen. Ebenso wichtig ist die Kenntnis über das Schaltungsdesign hinsichtlich Strombelastbarkeit, Signalstörungen und Kurzschlussvermeidung. Eine wohlüberlegte Planung im Vorfeld spart nicht nur Zeit, sondern erhöht auch die Zuverlässigkeit der fertigen Schaltung maßgeblich. Die Fähigkeit, Schaltpläne zu lesen und in reale Verbindungen umzusetzen, ist hierbei von zentraler Bedeutung und sollte intensiv geübt werden.

Wie verhindert man das Prellen eines Tasters mit Arduino-Code?

Der erste Schritt zur Entschärfung dieses Problems besteht in der zeitlichen Entkopplung der Signalverarbeitung vom momentanen Zustand des Tasters. Dies geschieht durch einen sogenannten Debounce-Mechanismus, der durch die Kombination von Zustandsüberwachung und Zeitmessung realisiert wird. Die technische Umsetzung dieses Mechanismus in Arduino erfolgt durch ein kontrolliertes Ignorieren schneller Änderungen des Eingangssignals, bis ein stabiler Zustand über eine definierte Zeitspanne hinweg gemessen wurde.

Die Implementierung beginnt mit der Definition zweier digitaler Pins: einem Eingang für den Taster und einem Ausgang für die LED. Gleichzeitig werden mehrere Variablen deklariert, die sowohl den aktuellen als auch den vorherigen Zustand des Tasters festhalten, sowie zwei Zeitwerte zur Messung der verstrichenen Zeit seit der letzten gültigen Zustandsänderung.

Im setup()-Block wird der Pin-Modus entsprechend gesetzt – der Taster als Eingang, die LED als Ausgang. Danach beginnt im loop()-Abschnitt der zentrale Ablauf: Der aktuelle Zustand des Tasters wird gelesen und mit dem vorherigen Zustand verglichen. Eine Änderung, unabhängig davon ob sie durch tatsächlichen Tastendruck oder durch Prellen verursacht wurde, setzt den Timer zurück. Erst wenn die gemessene Zeitdifferenz den definierten Schwellenwert (in der Regel 50 Millisekunden) überschreitet, wird diese Änderung als stabil gewertet und weiterverarbeitet.

Es ist erwähnenswert, dass durch diese Methode nicht nur die Reaktion des Systems auf Tastendrücke verbessert wird, sondern auch die Grundlage für komplexere Eingabemuster gelegt wird. Denn sobald der Mikrocontroller verlässlich zwischen echten und fehlerhaften Eingaben unterscheiden kann, lassen sich weitere Funktionalitäten wie Mehrfachklicks, langes Halten oder sequenzielles Tippen implementieren – allesamt auf der gleichen zeitbasierten Logik basierend.

Besonders elegant an dieser Lösung ist ihre vollständige Umsetzung in Software. Während mechanische oder elektronische Alternativen zum Entprellen – wie RC-Filter oder spezielle Entprell-ICs – durchaus existieren, bietet die softwarebasierte Variante maximale Flexibilität und minimalen Materialaufwand. Sie ist leicht anpassbar an unterschiedliche Taster, Systeme oder Timing-Anforderungen und eignet sich hervorragend für Einsteigerprojekte ebenso wie für professionelle Anwendungen mit strikten Anforderungen an die Eingabesicherheit.

Wichtig ist außerdem zu verstehen, dass das hier gezeigte Prinzip des Entprellens nicht nur auf Taster beschränkt ist. Es handelt sich um ein allgemeingültiges Muster zur Behandlung verrauschter digitaler Signale, das in vielfältigen Kontexten Anwendung finden kann – etwa bei Näherungssensoren, Reed-Kontakten oder jeglichen anderen binären Eingaben, die durch physikalische Instabilität beeinflusst werden können.

Ein zentraler Aspekt für weiterführendes Verständnis liegt in der Erkenntnis, dass digitale Systeme, anders als analoge, keine Zwischenzustände kennen. Alles ist entweder "an" oder "aus", "hoch" oder "niedrig", "wahr" oder "falsch". Umso wichtiger wird die präzise Definition der Übergangsbedingungen. Zeit, die in der physikalischen Welt permanent vorhanden ist, wird hier zu einem strukturellen Werkzeug, um Ordnung in ein instabiles System zu bringen.

Wer dieses Prinzip verinnerlicht, kann in der Mikrocontroller-Programmierung wesentlich robuster bauen – nicht nur bei der Tasterabfrage, sondern überall dort, wo zwischen digitalem Signal und physischer Welt eine Brücke geschlagen werden muss.

Wie ist Arduino entstanden und warum ist es für das Interaction Design so bedeutend?

Interaktionsdesign beschäftigt sich mit der Art und Weise, wie Menschen mit technischen Systemen und Umgebungen interagieren – und wie diese Systeme im Gegenzug auf uns wirken. Bill Verplank und Bill Moggridge prägten den Begriff „Interaction Design“ Mitte der 1980er-Jahre. Verplanks Skizze illustriert dabei ein grundlegendes Prinzip: Wer handelt, spürt eine Veränderung – und lernt dadurch etwas über die Welt. Diese Formel beschreibt nicht nur einen kognitiven Prozess, sondern die fundamentale Struktur jeglicher Interaktion zwischen Mensch und Maschine.

Zumeist denkt man beim Interaktionsdesign an die Steuerung von Computern über Peripheriegeräte wie Maus, Tastatur oder Touchscreen. Der Bildschirm ist dabei das Medium, über das der digitale Raum wahrgenommen und beeinflusst wird. Doch ein alternativer Zweig geht weit darüber hinaus: Physical Computing. Hier wird der digitale Raum ausgedehnt – Elektronik ermöglicht es, dass Computer nicht nur Informationen aufnehmen, sondern auch physisch auf ihre Umwelt reagieren können.

Ein erster wichtiger Schritt zur Überwindung dieser Hürde war das Projekt Processing, initiiert 2001 von Casey Reas und Benjamin Fry. Ziel war es, Programmieren visuell erfahrbar zu machen – mit einer digitalen Leinwand, auf der man mit wenig Aufwand Ideen skizzieren konnte. Processing diente also als Brücke zwischen kreativer Vorstellungskraft und technischer Umsetzung.

Im Jahr 2005 entstand schließlich Arduino. Die Motivation war klar: Eine einfache, robuste und preiswerte Plattform für Studierende im Interaction Design. Die offizielle Geschichte besagt, dass der Name „Arduino“ vom italienischen König Arduin von Ivrea stammt. Inoffiziell wird jedoch vermutet, dass der Name eher auf die nahegelegene Bar „Bar di Re Arduino“ zurückgeht – ein Ort, der womöglich eine nicht unbedeutende Rolle im Projekt spielte.

Arduino übernahm nicht nur technische Konzepte von Processing und Wiring, sondern auch kulturelle Prinzipien. So wurde die grafische Benutzeroberfläche (GUI) von Processing übernommen und angepasst. Programme heißen bei Arduino, wie auch bei Processing, Sketches – ein Konzept, das den schnellen, iterativen und experimentellen Charakter der Arbeit unterstreicht. Sketches sind keine fertigen Anwendungen, sondern Entwürfe, Werkzeuge zum Denken.

Die Robustheit der Arduino-Plattform ist ein entscheidender Vorteil. Vorherige Mikrocontroller-Boards waren fehleranfällig – ein falsch eingestecktes Kabel konnte bereits zum Totalschaden führen. Arduino hingegen ist fehlertoleranter, und der Mikrocontroller lässt sich im Fall eines Defekts leicht austauschen. Hinzu kommt der Preis: 2006 war ein Arduino rund viermal günstiger als ein populärer Mikrocontroller wie der Basic Stamp. Der Preis wurde bewusst niedrig gehalten – etwa im Bereich eines einfachen Abendessens, sodass man sich im Zweifel zwischen einem Glas Wein und einem funktionierenden Prototypen entscheiden konnte.

Mit der Zeit entwickelte sich Arduino weiter, sowohl in technischer als auch in konzeptueller Hinsicht. Heute existiert eine breite Palette an Arduino-Boards, von denen viele spezifische Funktionen bieten. Über sogenannte Shields – Aufsteckplatinen – kann ein Arduino etwa zu einem GPS-Empfänger, einem Geigerzähler oder sogar einem einfachen Mobiltelefon erweitert werden. Die Modularität macht es möglich, dass auch komplexe Anwendungen ohne tiefergehendes technisches Wissen realisierbar sind.

Technologie wird nicht nur genutzt, sie wird auch exploriert. Begriffe wie Patching und Hacking beschreiben alternative Zugänge zum Te