USB Anschluss
Über den USB-Port kannst du den Mikrocontroller programmieren und ihn mit Strom versorgen.
Pin 13
An den Pins (Anschlüssen) kannst du Bauteile wie Leuchtdioden, Displays, Motoren oder Sensoren anschließen. In unserer ersten Projekt-Box steht die LED im Mittelpunkt, du kannst mehrere LEDs anschließen und jeden Pin (= jede LED) einzeln programmieren.
onBoard-LED
Eine kleine LED direkt auf dem Mikrocontroller, sie ist mit „L“ beschriftet.
Genau hier startet unsere Projekt-Box: Die onBoard-LED wird automatisch mit Pin 13 programmiert und wir zeigen dir, wie du eigene Programme schreibst, Bauteile anschließt und deine Projekte zum Leben erweckst.
GND
Auf dem Mikrocontroller findest du 3 GND-Anschlüsse. Baust du eine Schaltung auf, fließt der Strom durch deine Schaltung und muss am Ende immer wieder zurück zu GND. Dabei ist es egal, welchen GND-Pin du verwendest.
Der Mikrocontroller ist das Gehirn unserer Schaltung: Du programmierst die Pins am Mikrocontroller, schaltest den Strom ein und aus und kannst alles mit deinem Code steuern. Klicke auf die gelben Punkte, um mehr zu erfahren.
In der Bonus-Lektion erfährst du mehr über den Mikrocontroller, lernst die wichtigsten Bereiche auf dem Board kennen und entdeckst die unterschiedlichen Pins mit ihren Funktionen. Es ist eine Zusatzlektion, du kannst sie also auch überspringen.
Um eine LED zu programmieren, brauchen wir 2 Befehle: Wo (an welchem Pin) ist die Hardware angeschlossen und wie ist der Zustand am Pin (HIGH/LOW)? Achte dabei auf die Schreibweise und das Semikolon ;
Mit dem Befehl pinMode legst du fest, welche Pins du verwendest und was der Mikrocontroller damit machen soll. Mit OUTPUT wird der Pin als Ausgang vorbereitet, sodass er später ein- und ausgeschaltet werden kann.
Mit dem Befehl digitalWrite schaltest du den Pin ein oder aus. Auch hier musst du festlegen, welchen Pin du gerade steuerst und welchen Zustand er haben soll: HIGH setzt den Pin auf 5 V und die LED leuchtet, LOW schaltet den Pin aus und die LED ist aus.
Funktionen erkennst du an dem void und den geschweiften Klammern. Alle Befehle stehen im Anweisungsblock.
Befehle erkennst du an dem Semikolon ; Alle Befehle müssen zwischen die geschweiften Klammern der Funktionen
Kommentare sind für den Menschen, um beispielsweise Codeabschnitte zu erklären oder sich Notizen zu machen.
Programmiere die onBoard-LED so, dass sie permanent leuchtet. Du programmierst sie genau wie oben über Pin 13.
Wenn du den Mikrocontroller zum ersten Mal mit dem USB-Kabel verbindest und er Strom bekommt, beginnt die Onboard-LED zu blinken und die ON-LED leuchtet grün.
Auf dem Mikrocontroller ist schon ein Sketch gespeichert, der die LED an Pin 13 ansteuert und zum Blinken bringt. Das gilt für echte Hardware genauso wie für TinkerCAD. In TinkerCAD siehst du dieses Programm auch jedes Mal, wenn du ein neues Projekt startest.
Die onBoard-LED hat auch einen eigenen Befehl/Pin: LED_BUILTIN
digitalWrite(LED_BUILTIN, HIGH);
Wir verwenden stattdessen: Den digitalen Pin 13
digitalWrite(13, HIGH);
Wir gehen direkt einen Schritt weiter: Wir programmieren die LED direkt mit dem Pin 13. Danach können wir direkt (zusätzliche) externe Bauteile anschließen und sie genau so programmieren, wie wir es jetzt lernen.
Arbeitest du mit einem Hardware-Set, kannst du deinen Code mit der Arduino-IDE auf den Mikrocontroller laden. Falls noch nicht passiert, musst du jetzt deine Hardware vorbereiten.
void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13, HIGH);
}
In TinkerCAD arbeitest du ohne Materialien und baust deine Schaltung direkt am Bildschirm auf.
void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13, HIGH);
}
Erweitere deinen Code so, dass die onBoard-LED blinkt (lange an, kurz aus). Nutze dafür den delay-Befehl.
Dein Programm wird Codezeile für Codezeile ausgeführt. Du musst mehrere Codezeilen ergänzen. Denk daran, dass jeder Befehl zwischen den geschweiften Klammern stehen muss!
Mehr dazu erfährst du in der Lösung.
void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(500);
}
Das Gehirn hinter unseren Projekten ist der Mikrocontroller, unser Entwicklerboard. Wir können jeden Anschluss (Pin) einzeln steuern, eigene Programme schreiben und viele verschiedene Bauteile anschließen.
Mit den Bauteilen erwecken deine Projekte zum Leben: Schließe LEDs und Taster an, erfasse deine Umgebung mit Sensoren, kommuniziere über LCD-Displays oder bewege Objekte mit Servomotoren.
Um die Bauteile mit dem Arduino zu verbinden, brauchst du das passende Zubehör: Entwickle deine eigenen Schaltungen mit der Hilfe von Breadboards, Jumperkabeln und Widerständen.
Um eine elektrisch leitende Verbindung herzustellen, gibt es mehrere Möglichkeiten: Wir nutzen Jumper-Kabel und ein Breadboard, um unsere Bauteile mit dem Mikrocontroller zu verbinden.
Im Inneren der Jumper-Kabel befindet sich ein Kupferdraht. Während der Strom durch den Draht im Inneren fließt, soll die bunte Schicht außen das Kabel lediglich isolieren. Die Farbe spielt also keine Rolle!
Das Ende mit dem SMA-Stecker wird als männlich bezeichnet.
Das Ende mit der Buchse wird als weiblich bezeichnet.
Da jedes Kabel 2 Enden und damit 2 Anschlüsse besitzt, können sie in M-M, M-W, W-W unterteilt werden. Die Anschlüsse sind genormt und besitzen ein Durchmesser (Raster) von 2,54mm.
In der Steckplatine (eng. breadboard) sind sogenannte Federkontakte, in die die Bauteile gesteckt werden. Klicke die Bilder an, um sie zu vergrößern.
Frage: Welche Schaltungen ist richtig angeschlossen?
Findest du die Fehler? In zwei der Schaltungen kommt der Strom nicht durch das Steckbrett – nur eine der Schaltungen funktioniert! Der Strom soll links unten hinein und rechts unten wieder hinausfließen:
Die Widerstände schützen nicht nur die Bauteile, sondern auch deinen Mikrocontroller vor zu hohen Strömen. Die wichtigsten Widerstände für den Anfang sind 100Ω und 220Ω (später kommen noch weitere hinzu). In vielen Hardware-Sets sind immer mehrere Widerstände mit einem Papierstreifen zusammen.
Wir unterscheiden zwischen 2 Arten von Widerständen: Kohleschicht (braun mit 4 Ringen) und Metallschicht (blau mit 5 Ringen). Welche Art von Widerstand wir verwenden, ist egal. Die Werte (Größe der Widerstände) können wir mithilfe der farbigen Ringe unterscheiden. Der letzte Ring beschreibt dabei die Toleranz und kann vernachlässigt werden.
LEDs sind polarisierte Bauteile: Sie leuchten nicht, wenn du sie falsch herum anschließt: Ziehe sie heraus und stecke sie anders herum wieder ins Breadboard. Den Widerstand, den wir verwenden ist abhängig von der Farbe:
In den letzten Aufgaben hast du die onBoard-LED mit Pin 13 so programmiert, dass sie blinkt. Schließt du an diesen Pin jetzt eine (externe) LED an, macht sie genau dasselbe wie die onBoard-LED.
Achte beim Steckbrett auf die grünen Punkte im Bild. Ein oft gemachter Fehler ist, dass die Kabel in die falsche Reihe gesteckt werden! Klicke das Bild an, um es zu vergrößern.
Polarisierte Bauteile
Die LED leuchtet nicht, wenn sie falsch herum angeschlossen wurde: Ziehe sie heraus und stecke sie anders herum wieder ins Breadboard.
Kurzes Bein muss an GND
Langes Bein muss an Pin 13
Mithilfe der Seitenleiste des Breadboards können wir jetzt auch problemlos mehrere LEDs anschließen. Wichtig ist, dass der Aufbau zum Code passt: Jedes Bauteil muss im Code einzeln angesteuert werden (braucht einen eigenen Befehl).
Beim Mikrocontroller kannst (und musst) du jeden Pin einzeln steuern: Im Beispiel sind 2 LEDs an die Pins 12 und 13 angeschlossen, die beide gleichzeitig leuchten.
void setup(){
pinMode(13, OUTPUT); // Pin 13 konfigurieren
pinMode(12, OUTPUT); // Pin 12 konfigurieren
}
void loop(){
digitalWrite(13, HIGH); // LED an Pin 13 an
digitalWrite(12, HIGH); // LED an Pin 12 an
}
Baue eine Schaltung mit 2 LEDs auf und erweitere den Code so, dass die LEDs abwechselnd blinken.
void setup(){
pinMode(13, OUTPUT); // Pin 13 konfigurieren
pinMode(12, OUTPUT); // Pin 12 konfigurieren
}
void loop(){
digitalWrite(13, HIGH); // LED an Pin 13 an
digitalWrite(12, LOW); // LED an Pin 12 aus
delay(500); // Warten
digitalWrite(13, LOW); // LED an Pin 13 aus
digitalWrite(12, HIGH); // LED an Pin 12 an
delay(500); // Warten
}
4 LEDs (2x weiß, 2x blau) werden so Programmiert, dass ein Blaulicht entsteht: Lass sie abwechseln schnell aufleuchten. Klicke auf das Bild, um den Schaltplan zu vergrößern.
// Projekt: Blaulicht
// LEDs an Pins 7, 6, 5, 4
void setup(){
pinMode(7, OUTPUT);
pinMode(6, OUTPUT);
pinMode(5, OUTPUT);
pinMode(4, OUTPUT);
}
void loop(){
// Mit 200ms blinkt es relativ schnell
digitalWrite(7, HIGH);
digitalWrite(6, HIGH);
digitalWrite(5, LOW);
digitalWrite(4, LOW);
delay(200);
digitalWrite(7, LOW);
digitalWrite(6, LOW);
digitalWrite(5, HIGH);
digitalWrite(4, HIGH);
delay(200);
}
Bis zu 10 LEDs, in Reihe geschaltet und so programmiert, dass das Licht von einer zur nächsten springt: Ein perfektes Projekt für Einsteiger!
Überlege dir genau, welche LEDs du wann an- und wann ausschalten musst: Beim Start sind alle LEDs (automatisch) aus. Du musst also nicht alle LEDs für jeden Schritt ansteuern!
Geschwindigkeit: Wie schnell das Licht wechselt, kannst du flexibel mit dem delay/warten festlegen. Im Video sind es 500ms.
Rücklauf: Du entscheidest selbst, wie du programmierst. Soll das Licht am Ende wieder zurück zum Anfang laufen oder am Ende einfach wieder nach vorne „springen“ wie in unserem Video?
Wir haben 7 LEDs verwendet, du kannst natürlich selbst entscheiden, wie viele LEDs und welche Farben du verbaust.
➔ 200mA / 20mA = 10
➔ max. 10 LEDs verwenden
Erklärung
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
pinMode(9, OUTPUT);
pinMode(8, OUTPUT);
pinMode(7, OUTPUT);
}
void loop() {
digitalWrite(7, LOW);
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
digitalWrite(12, HIGH);
delay(500);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
delay(500);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
delay(500);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
delay(500);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(500);
digitalWrite(8, LOW);
digitalWrite(7, HIGH);
delay(500);
// optional mit Rücklauf, hier ohne
}
Programmiere eine (zeitgesteuerte) Ampel mit 3 LEDs: ROT/GELB/GRÜN und achte darauf, dass alle Ampelphasen abgespielt werden. Die Autos sollen dabei lange grün und kurz Rot haben.
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
}
void loop() {
// Grün
digitalWrite(11, HIGH);
delay(4000);
// Gelb
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
delay(1000);
// Rot
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(2000);
// Rot+Gelb
digitalWrite(12, HIGH);
delay(1000);
// Grün
digitalWrite(12, LOW);
digitalWrite(13, LOW);
// Grün geht automatisch an -> loop
// Dann aber auch ohne delay()
}
Baue als nächstes Taster ein und erweitere deine Schaltung: In der Projekt-Box „Kontrollstrukturen“ arbeitest du mit neuen Bauteilen und lernst neue Themen kennen. Steuere deine Ampel auf Tastendruck!
Baue als nächstes Taster ein und erweitere deine Schaltung: In der Projekt-Box „Kontrollstrukturen“ arbeitest du mit neuen Bauteilen und lernst neue Themen kennen. Steuere deine Ampel auf Tastendruck!
Dein Mikrocontroller wird zum Instrument. Programmiere Noten, spiele die Tonleiter und komponiere ganze Lieder. Mit deinem Code steuerst du, was passiert: Töne, Dauer und Pausen werden zur Melodie und lassen Musik erklingen. Noten lesen musst du hier nicht, wir haben alles für dich vorbereitet, damit dein Mikrocontroller direkt zu spielen beginnt.
Aus einzelnen Linien werden Zahlen und du kannst sie programmieren: Experimentiere mit den Bauteilen, steuere jedes Segment gezielt an und bestimme, welche Linien aufleuchten und welche dunkel bleiben. Um den Code zu entwickeln, verwenden wir selbst entwickelte Funktionen und verbinden sie zu einem automatischen Counter: Lass die Ziffern aufleuchten.
Steuere deinen Mikrocontroller auf Tastendruck. Kontrollstrukturen steuern, was in deinem Code passiert. Programmiere den elektronischen Würfel oder finde im Reaktionsspiel mit LEDs den richtigen Moment für den entscheidenden Tastendruck. Mit Verzweigungen, Schleifen und Bedingungen entwickelst du Programme, die entscheiden, was ausgeführt wird und was nicht.