Die einfache LED

Eine LED (Light Emitting Diode) ist ein elektronisches Bauteil, das Licht emittiert, wenn Strom durch sie fließt. Sie besteht aus einem Halbleitermaterial, das in einem Gehäuse eingebettet ist. Das Gehäuse schützt den Halbleiter vor äußeren Einflüssen und dient gleichzeitig als Anschlusspunkt für eine Stromquelle.

Die LED hat zwei Anschlüsse: die Anode und die Kathode. Die Anode ist der positive Anschluss und die Kathode der negative. Wenn eine Spannung an Anode und Kathode angelegt wird und Strom durch die LED fließt, beginnt sie zu leuchten. LEDs sind in verschiedenen Farben erhältlich, darunter Rot, Grün, Blau, Gelb und viele mehr. Die Farbe wird durch das verwendete Halbleitermaterial bestimmt. Neben den einfarbigen Varianten gibt es auch RGB-LEDs, die in der Lage sind, verschiedene Farben durch die Kombination von Rot, Grün und Blau zu erzeugen.

LEDs finden häufig Einsatz als Signal- und Statusanzeigen sowie in Beleuchtungsanwendungen wie Lampen, Leuchten und Bildschirmen. Aufgrund ihrer langen Lebensdauer, ihres geringen Energieverbrauchs und ihrer Langlebigkeit sind sie eine beliebte Wahl in der Elektronik.

Die DIP LED ist eine ältere Form von LEDs und steht für "Dual In-Line Package". Sie hat eine rechteckige oder runde Form und besitzt zwei Drahtbeinchen unterschiedlicher Länge: die Anode (länger) und die Kathode (kürzer). Diese Beinchen ermöglichen den Anschluss an eine Schaltung oder eine Leiterplatte. DIP LEDs werden oft in Anwendungen eingesetzt, bei denen eine einzelne LED benötigt wird, wie zum Beispiel in elektronischen Bauteilen, Anzeigetafeln oder kleinen Beleuchtungseinheiten. Sie waren früher weit verbreitet, werden aber zunehmend von den neueren SMD LEDs verdrängt.

SMD LED (Surface Mounted Device LED): Die SMD LED ist eine modernere Art von LED, bei der das Bauteil direkt auf die Oberfläche einer Leiterplatte gelötet wird. "SMD" steht für "Surface Mounted Device". Im Gegensatz zur DIP LED benötigt die SMD LED keine Drahtbeinchen, da sie direkt auf die Leiterplatte gelötet wird.

SMD LEDs haben eine kleinere Bauform und ermöglichen eine kompaktere Bauweise von elektronischen Geräten. Sie sind in unterschiedlichen Größen wie 0805 oder 0603 erhältlich, was ihre Abmessungen in Zehntelmillimetern repräsentiert.

SMD LEDs werden in einer Vielzahl von Anwendungen eingesetzt, darunter Beleuchtungssysteme, Displays, Hintergrundbeleuchtung von Bildschirmen, Leuchtanzeigen, Leuchten, Fernsehgeräten, Mobiltelefonen und vielen anderen elektronischen Geräten. Mit ihrer hohen Lichtleistung und guten Energieeffizienz ermöglichen sie die Integration in kompaktere Designs.

Der Übergang von DIP LEDs zu SMD LEDs hat dazu beigetragen, elektronische Geräte kleiner, effizienter und vielseitiger zu machen, da SMD LEDs leichter auf Leiterplatten montiert werden können und mehr Designfreiheit bieten.

Pseudo-Code – Dein persönlicher Leitfaden

Stell dir vor, du hättest eine Art Übersetzungshilfe, um komplexe Programmabläufe in einfachen Worten zu beschreiben – das ist Pseudo-Code! Er bietet eine bequeme und vereinfachte Darstellung eines Algorithmus oder eines Programmablaufs, ähnlich einer informellen Skizze, bevor du dich in die genauen Details einer spezifischen Programmiersprache vertiefst.

Pseudo-Code ist wie dein persönlicher Dolmetscher zwischen der menschlichen Sprache und der strengen Syntax von Programmiersprachen. Er hilft dir, den roten Faden in deinem Programm zu behalten und ermöglicht es dir, den Fokus auf das große Ganze zu legen, statt dich in den Details der Syntax zu verlieren.

Die Schönheit des Pseudo-Codes ist seine Ungebundenheit. Er ist nicht standardisiert und kann von dir persönlich angepasst werden. Das bedeutet, dass du die Freiheit hast, den Pseudo-Code so zu gestalten, wie du ihn am besten verstehst.

Nun lass uns einen Schritt weiter gehen und sehen, wie wir Pseudo-Code für das Blinken einer LED auf einem Arduino Board verwenden können. Wir teilen den Pseudo-Code in zwei Abschnitte: Abschnitt A für die Vorbereitung und Abschnitt B für den wiederkehrenden Programmablauf.

A. Vorbereitung:
Definiere den Pin 13 als Ausgang: Hierdurch kann unser Arduino digitale Signale aussenden.

B. Wiederkehrender Programmbereich:
Schalte den Pin 13 ein: Die LED leuchtet auf.
Warte eine Sekunde ohne weitere Aktion: Die LED bleibt eingeschaltet.
Schalte den Pin 13 aus: Die LED erlischt.
Warte erneut eine Sekunde ohne Aktion: Die LED bleibt aus.

Hier siehst du, wie der Pseudo-Code als eine Art Roadmap für den Programmablauf dient. Abschnitt A wird einmal ausgeführt, um das Arduino-Board für das Blinken zu konfigurieren. Abschnitt B hingegen enthält den Zyklus, der das Blinken der LED kontinuierlich wiederholt.

Denk daran, dass der Pseudo-Code selbst nicht ausführbar ist. Er ist eher ein Werkzeug zur Planung und Kommunikation, das dir hilft, den Programmablauf zu skizzieren und zu verstehen, bevor er in echten Code umgewandelt wird.

Der echte Code

Schließlich wollen wir den Pseudo-Code in realen Code überführen. Dabei ist es hilfreich, den Pseudo-Code als Kommentar neben den tatsächlichen C-Code zu schreiben. Dein Arduino wird den Pseudo-Code zwar ignorieren, aber er kann dir und anderen dabei helfen, den Code besser zu verstehen. Hier ist ein Beispiel, wie das aussehen könnte:

voidsetup()
{
  pinMode(13, OUTPUT);
  //Modifiziere den Pin 13 als OUTPUT: Wir senden digitale Signale nach außen
}

voidloop()
{
  digitalWrite(13, HIGH);
  // Schalte den Pin 13 ein: Die LED leuchtetdelay(1000);
  // Warte eine Sekunde und mache nichts: Die LED bleibt eingeschaltetdigitalWrite(13, LOW);
  // Schalte den Pin 13 aus: Die LED hört auf zu leuchtendelay(1000);
  // Warte eine Sekunde und mache nichts: Die LED bleibt ausgeschaltet
}

Die Reise beginnt: Anschluss der LED an das Arduino

Dein erstes Abenteuer beginnt mit einer einfachen Aufgabe. Bevor du beginnst, stelle sicher, dass dein Arduino nicht mit Strom versorgt wird. Dies ist ein wichtiger Sicherheitsschritt, um zu verhindern, dass du versehentlich einen Kurzschluss verursachst oder eine der Komponenten beschädigst. Schließe die LED an dein Arduino an. Aber denk daran, GND wird mit GND verbunden und Pin 13 mit dem roten Pin (RED) deines Moduls.

Nachdem du erfolgreich die LED angeschlossen hast, ist es Zeit, den Code hochzuladen und dich an dem leuchtenden Blinken der LED zu erfreuen. Es ist wichtig, dabei auf Details zu achten: Wähle den korrekten Pin für die Verbindung und behalte die Polarität der LED im Auge. Ein interessantes Detail bei LEDs ist, dass sie eine spezifische Ausrichtung haben und nur in einer bestimmten Richtung leuchten können.

Sketch-Details und Erläuterungen

Beim Arbeiten mit Arduino-Sketches begegnest du zwei essentiellen Funktionen, in die du deinen Code einfügst. Diese Funktionen sind als "void setup()" und "void loop()" bekannt. Du kannst sie dir als Behälter vorstellen, in die du deinen Code eingibst:

void setup() 
{
  ... hier kommt dein Code rein
}
  
void loop() 
{
  ... hier kommt dein Code rein
}

Die Unterscheidung zwischen diesen beiden Funktionen ist von großer Bedeutung. Die Funktion "void setup()" wird nur ein einziges Mal durchlaufen. Was auch immer du in die geschweiften Klammern dieser Funktion schreibst, wird einmal ausgeführt und danach nie wieder.

###bild schleife

Die Funktion "void loop()" hingegen wird kontinuierlich wiederholt, solange dein Arduino mit Strom versorgt wird. Du fragst dich vielleicht, warum es notwendig ist, diese beiden Funktionen zu unterscheiden. Warum nicht einfach den Inhalt von "void setup()" in "void loop()" einfügen? Der Grund dafür liegt in der Effizienz. Um Rechenleistung zu sparen, kommt alles, was nur einmal ausgeführt werden muss, in "void setup()". Andernfalls wäre es in "void loop()" nur unnötiger Ballast, der ständig und unnötig durchlaufen würde.

Nun kehren wir zurück zu unserem Pseudo-Code. Diesen platzieren wir in die Funktionen "void setup()" und "void loop()", um ihn später durch realen Code zu ersetzen:

void setup()
{
  // A. Bereite das Arduino vor:
  // Setze Pin 13 als OUTPUT.
}

void loop()
{
  // B. Wiederhole, was innerhalb der geschweiften Klammern steht:
  // Schalte den Pin ein / lass die LED leuchten.
  // Warte eine Sekunde / mache eine Pause.
  // Schalte den Pin aus / die LED leuchtet nicht.
  // Warte eine Sekunde / mache eine Pause.
}

Um eine LED zum Leuchten zu bringen, musst du dem Arduino zunächst mit der so genannten "pinMode"-Funktion sagen, wie der Pin verwendet werden soll.

Die "pinMode"-Funktion enthält zwei Argumente. Das erste Argument ist die Pinnummer 13. Dies ist die Pinnummer, an die deine LED angeschlossen ist. Das zweite Argument, getrennt durch ein Komma, gibt den Modus an. Es kann zwei Zustände haben: INPUT oder OUTPUT. Da du Strom an die LED senden möchtest, ist OUTPUT die richtige Wahl. Der "pinMode()"-Befehl wird mit einem Semikolon beendet.

So sieht der Code aus:

void setup() 
{ 
  pinMode(13, OUTPUT); 
}

Dann springen wir direkt in die Funktion "void loop()". Zur Erinnerung: Alles, was du innerhalb der geschweiften Klammern dieser Funktion schreibst, wird unendlich oft wiederholt. Hier ist der Kern unserer Arbeit zu finden - das Ein- und Ausschalten der LED.

Mit dem Befehl "digitalWrite()" hast du die Kontrolle über den Arduino-Pin. Du kannst damit den Stromfluss an- und abschalten.

Das erste Argument innerhalb der Klammer gibt an, welchen Pin du steuern möchtest - in unserem Fall ist das Pin 13. Das zweite Argument legt den Zustand fest und kann zwei Formen annehmen: HIGH oder LOW. Der Zustand HIGH erhöht die Spannung am Pin 13 von 0V auf 5V, sodass die LED leuchtet. Ein Semikolon markiert das Ende dieses Befehls.

Kommen wir zur nächsten Zeile: Mit "delay()" verzögerst du den weiteren Verlauf des Programms - der Code pausiert also. Nachdem du die LED mit "digitalWrite(13,HIGH)" eingeschaltet hast, bleibt sie durch "delay(1000)" für eine ganze Sekunde eingeschaltet.

Die Verzögerungszeit, die du als Argument einträgst, wird in Millisekunden angegeben. Im obigen Beispiel beträgt diese 1000 Millisekunden, was einer Sekunde entspricht. Nach Ablauf dieser Zeit springt das Programm zur nächsten Befehlszeile.

1000 Millisekunden (ms) = 1 Sekunde (s)

Nun nutzt du noch einmal die Funktion "digitalWrite()". Vorher hast du die LED eingeschaltet, nun schaltest du sie mit "digitalWrite(13, LOW)" wieder aus. Im ersten Argument gibst du erneut die Pinnummer 13 an. Das zweite Argument setzt du diesmal auf LOW - die Spannung sinkt also von 5V auf 0V und die LED leuchtet nicht mehr. Nach dem Ausschalten der LED nutzt du den Befehl "delay(1000);" erneut, um die LED für eine Sekunde ausgeschaltet zu lassen.

Die abschließende geschweifte Klammer signalisiert dem Programm, dass es wieder an den Anfang springen und alles erneut ausführen soll. Mach dich mit dem Code vertraut und experimentiere ein wenig mit den Werten von "delay()". Ändere die Zeiten, lade den Code hoch und sieh dir an, was passiert.

Ein kleiner Einblick in die Farbwelt der Arduino-IDE

Syntax-Highlighting ist ein Feature, das in vielen textbasierten Benutzeroberflächen, insbesondere in Programmierumgebungen, zum Einsatz kommt. Sein Zweck besteht darin, die Lesbarkeit und das Verständnis von Text, besonders von Quellcode, zu verbessern. Es hilft, menschliche Fehler zu minimieren und die Effizienz zu steigern.

Beim Syntax-Highlighting werden verschiedene Teile des Quellcodes in unterschiedlichen Farben und Schriftarten dargestellt. Das System erkennt die Syntax der verwendeten Programmiersprache und hebt bestimmte Elemente wie Schlüsselwörter, Variablen, String-Literale und Kommentare farblich hervor.

In der Arduino-IDE wird Syntax-Highlighting genutzt, um den Quellcode übersichtlicher zu gestalten und das Erkennen von Syntaxelementen zu erleichtern. So werden beispielsweise Funktionen wie "digitalWrite" in Orange dargestellt. Die Farbgebung ist dabei nicht zufällig, sondern folgt einem bestimmten Muster, das vom System für diese Funktion reserviert ist. Wenn du also "digitalWrite" korrekt eingibst, ändert sich die Farbe des Textes automatisch. Das erleichtert nicht nur die Lesbarkeit, sondern hilft auch dabei, Tippfehler oder Syntaxfehler schnell zu erkennen und zu korrigieren.

Es ist jedoch wichtig zu beachten, dass Syntax-Highlighting ein Hilfsmittel ist und nicht die Notwendigkeit ersetzt, die Syntax der verwendeten Programmiersprache zu verstehen. Es soll lediglich dazu beitragen, den Code besser lesbar und verständlicher zu machen.

Die Farbschemata für das Syntax-Highlighting sind oft anpassbar, sodass jeder Entwickler sie nach seinen persönlichen Vorlieben gestalten kann. Manche bevorzugen dunkle Hintergründe mit hellen Schriftfarben, während andere helle Hintergründe mit dunklen Schriftfarben bevorzugen. Die Wahl des Farbschemas kann einen großen Einfluss auf die Augenbelastung und die allgemeine Produktivität haben.

Einen Sketch speichern

Um deinen Sketch zu speichern, hast du verschiedene Möglichkeiten. Du kannst den "Save"-Button anklicken oder alternativ in der Menüleiste unter "Datei" auf "Sichern unter" klicken. Wenn du einen bereits vorhandenen Sketch öffnest und Änderungen daran vornimmst, erscheint ein Sternchen neben dem Sketchnamen im Tab. Sobald du deine Änderungen gespeichert hast, verschwindet dieses Sternchen.

Nach der Standardeinstellung werden Sketches im Ordner "Dokumente" auf einem Mac bzw. "Eigene Dateien" auf Windows in einem Unterordner namens "Arduino" gespeichert. Du kannst aber natürlich auch einen anderen Speicherort auswählen.

Die Arduino-IDE gibt einem neuen Sketch automatisch einen Namen. In der aktuellen Version 1.8.5 setzt sich dieser Name aus dem Wort "sketch", der Abkürzung des aktuellen Monats, dem Tag und einer fortlaufenden Buchstabenfolge zusammen, beispielsweise "sketch_dec04a". Es ist jedoch sinnvoll, einen aussagekräftigen Namen zu wählen, der den Zweck des Sketches widerspiegelt. Beachte dabei, dass die Arduino IDE bestimmte Zeichen, wie zum Beispiel Leerzeichen, nicht akzeptiert. Diese werden durch einen Unterstrich (_) ersetzt.

Bist du verwundert, wenn du deinen gespeicherten Arduino Sketch in einem separaten Ordner vorfindest? Keine Sorge, das ist normal. Die IDE platziert einen Sketch immer in einem gleichnamigen Ordner. Arduino-Dateien sind reine Textdateien und enden mit der Endung ".ino".

Übungsaufgaben

Nun kommen wir zu einigen Aufgaben:

1. Einfaches Blinken
Du hast bereits den Blink-Sketch in der letzten Übung eingetippt. Schaffst du es nun, ihn aus dem Gedächtnis zu tippen? Benutze den Pseudo-Sketch als Hilfe. Wenn du fertig bist, lade den Sketch auf dein Arduino.

 
2. Verändere den Blinkrhythmus
Ändere die Werte in der "delay()"-Funktion und experimentiere mit unterschiedlichen Zeiten. Ab wie vielen Millisekunden bemerkst du das Blinken der LED nicht mehr? Ab welchem Wert scheint sie dauerhaft zu leuchten?

 
3. Lasse die LED nur einmal blinken
Wie könntest du es schaffen, die LED nur einmal blinken zu lassen?

 
4. Warum blinkt die LED nicht?
Im folgenden Sketch fehlen die "delay()"-Befehle. Theoretisch sollte die LED blinken, da sie ein- und ausgeschaltet wird und der Sketch danach wieder an den Anfang springt. Trotzdem leuchtet die LED dauerhaft. Kannst du erklären, warum das so ist? Lade den Sketch auf dein Arduino und überprüfe es.

void setup() 
{
  pinMode(13, OUTPUT); //Setze den Pin 13 auf Ausgabe-Modus
}

void loop() 
{
  digitalWrite(13, HIGH); //Schalte den Pin 13 ein: Die LED leuchtet
  digitalWrite(13, LOW); //Schalte den Pin 13 aus: Die LED erlischt
}

Die Frage stellt sich: Brauchen wir die "delay()"-Funktion überhaupt?

Wir schalten doch die LED ein und aus. Wäre der obige Sketch nicht ausreichend, um sie blinken zu lassen?

Tatsächlich blinkt die LED, auch wenn es auf den ersten Blick nicht so aussieht. Von der Zeile "digitalWrite(13, HIGH);" springt das Programm wieder an den Anfang zu "digitalWrite(13, LOW);". Dabei wird die LED ein- und ausgeschaltet, aber das passiert so schnell, dass unsere Wahrnehmung das "Blinken" nicht mehr erfassen kann. Dies zeigt uns, wie schnell die Loop-Funktion tatsächlich arbeitet.

Darüber hinaus kann die "delay()"-Funktion dazu verwendet werden, Energie zu sparen. Wenn man die LED so schnell blinken lässt, dass sie unterhalb unserer Wahrnehmungsschwelle liegt, haben wir den Eindruck, sie würde dauerhaft leuchten. Wenn die LED innerhalb einer Sekunde (1000 ms) für 100 ms ausgeschaltet ist, sparen wir theoretisch 10% der Energie.

Um das schnelle Blinken sichtbar zu machen, versuche folgendes Experiment: Es funktioniert am besten im Dunkeln. Setze beide "delay()"-Werte auf 100 ms. Nun nimm das Arduino mit der LED und bewege es sehr schnell hin und her. Du wirst den Leuchtschweif der LED sehen, der eine Linie bildet. Diese Linie wird kleine Lücken aufweisen - es wirkt eher wie eine gestrichelte Linie. Ändere nun die "delay()"-Werte. Je kürzer die "delay()" Werte sind, desto kleiner sind die Lücken. Je länger die Werte, desto größer werden die Lücken.