Beschreibung
Mit einem LCD kann man Buchstaben und Nummern darstellen. Man kann zum
Beispiel Messwerte oder auch den Zustand in dem sich der Arduino
befindet anzeigen lassen (“fahre vorwärts” / “fahre rückwärts”). Der I2C
Bus (Anschlussschnittstelle) ermöglicht eine simple Verkabelung im
Gegensatz zu einem größeren herkömmlichen Display. Außerdem lässt sich
auf der Rückseite mittels eines Drehreglers der Kontrast einstellen.
Verkabelung

Schaltplan
Code
#include <LiquidCrystal_I2C.h> // LiquidCrystal_I2C Bibliothek einbinden.
#include <Wire.h> // Wire Bibliothek einbinden.
// Bestimmung des Displays:
LiquidCrystal_I2C lcd(0x3f, 16, 2); // HEX-Adresse 0x3f, 16 Zeichen in 2 Zeilen.
// LiquidCrystal_I2C lcd(0x3f, 20, 4); // Für ein LCD mit 20 Zeichen in 4 Zeilen.
// Bei Problemen schaue ins FAQ.
void setup() {
lcd.init(); // Im Setup wird der LCD gestartet.
lcd.backlight(); // Hintergrundbeleuchtung einschalten.
// ( lcd.noBacklight(); schaltet die Beleuchtung aus).
}
void loop() {
lcd.setCursor(0, 0); // Legt die Position des ersten Zeichens fest.
// (0,0) bedeutet das erste Zeichen in der ersten Zeile.
lcd.print("Ich bin ein");
lcd.setCursor(0, 1); // (0,1) bedeutet das erste Zeichen in der zweiten Zeile.
lcd.print("Arduino!");
}
Aufgaben
Beschreibe, was der Code tut!
Es wird ein lcd Objekt angelegt. Das Display im Setup wird initialisiert
und eingeschaltet und die Zeichenpositionen für die Ausgabe angegeben.
Ändert die Ausgabe um in “Hallo” “ihr wissbegierigen”.
Die LED leuchtet bei dem Zeichen “1” und geht aus beim Zeichen “0”. Bei
allen anderen passiert nichts mit der LED.
Warum würde eine Fehlermeldung bei den beiden Ausgaben auftreten?
“Herzlich Willkommen” “ihr wissbegierigen!”
Man würde hierbei eine Fehlermeldung erhalten, da der LCD-Display nur 16
chars, also Zeichen, pro Zeile ausgeben kann, es hier aber deutlich mehr
sind.
Häufige Fragen und Probleme
Mein Display leuchtet aber zeigt nichts an, wieso?
Es gibt je nach Display unterschiedliche I2C Module, die auf der
Unterseite angelötet sind.
Überprüfe anhand der folgenden Bilder ob du in der 5. Zeile des
Codes die richtigen Angaben gemacht hast.

I²C-Modul ohne Lötstellen. HEX-Adresse 0x27

I²C-Modul mit rot markierten Lötstellen. HEX-Adresse 0x3F
Wurde die Library korrekt eingebunden? Siehe PROGRAMM
Mein Display leuchtet nicht!
- Ist die Verkabelung korrekt ? VCC darf nicht an 3,3V angeschlossen
werden (zu wenig Energie)
- Kabel überprüft? Vielleicht hat eines der 4 MW Kabel einen Defekt.
Tauscht alle Kabel einmal aus.
- Funktioniert es, prüft anschließend jedes einzelne Kabel, um das
Defekte zu finden.
Mein Display zeigt Zeichen an, die da nicht hin sollen!
- Soll das Display verschiedene Dinge hintereinander anzeigen? Wird
mit dem Befehl lcd.print(“12345”); die Zeichen “12345” angezeigt und
anschließend lcd.print(“abc”); verwendet, zeigt das Display nun
“abc45” an, da für die 4. und 5. Stelle kein neuer Wert angegeben
wurde. Um dies zu umgehen, kann man zwischendurch mit dem Befehl
lcd.clear(); das Display leeren.
Mein Programm zeigt immer einen Fehler wenn ich den Code übertragen möchte?
Port und Board im Programm überprüft?
Beschreibung
Der Arduino ist ein Mikrocontroller, mit dem man verschiedene technische
Geräte bauen kann. Wir wollen zunächst gemeinsam einen fahrenden Roboter
bauen.
Befestige dazu zwei Motoren mithilfe der Motorhalterungen und Schrauben
an ein Holzbrett (siehe Foto). Bringe dann die Reifen an den Achsen
an.
Es gibt hierzu auch eine genaue Fotoanleitung
(Arbeitsschritte_Roboterfahrzeug_Fotoanleitung.pdf). # Verkabelung
GND | Kabel 1 des linken Motors |
GND | Kabel 1 des rechten Motors |
12 | Kabel 2 des linken Motors |
13 | Kabel 2 des rechten Motors |
Code
// Wir geben den Pins mit Motoren Namen.
int motor_links = 13;
int motor_rechts = 12;
// Dieser Code wird einmal beim Start des Arduinos ausgeführt.
void setup() {
// Wir teilen dem Arduino mit, dass aus den Motorpins Strom kommen soll.
pinMode(motor_links, OUTPUT);
pinMode(motor_rechts, OUTPUT);
}
// Dieser Code wird immer wieder hintereinander ausgeführt.
void loop() {
// Gib beiden Motoren Strom.
digitalWrite(motor_links, HIGH);
digitalWrite(motor_rechts, HIGH);
// Warte 3 Sekunden bis zur Ausführung der nächsten Befehle.
// ACHTUNG: Die Motoren haben weiterhin Strom,
// bis dem Arduino ein gegenteiliger Befehl gegeben wird.
delay(3000);
// Gib beiden Motoren KEINEN Strom.
digitalWrite(motor_links, LOW);
digitalWrite(motor_rechts, LOW);
// Warte.
delay(1000);
}
Aufgaben
Beschreibe, wie die Motoren sich verhalten, wenn du den obigen Code
ausführst?
Der Roboter fährt drei Sekunden gerade aus und bleibt dann eine Sekunde
lang stehen.
Was musst du am Code ändern, damit der Roboter länger stoppt?
Beim zweiten delay
muss eine größere Zahl in die Klammern eingetragen
werden.
Was passiert, wenn du bei einem Motor den GND und Zahlen-Pin vertauscht?
Der Motor wechselt die Fahrtrichtung.
Wie kannst du das Fahrzeug zuerst geradeaus und dann eine Kurve fahren
lassen? Probiere deine Idee aus!
Es gibt verschiedene Möglichkeiten das zu lösen
- Ändere die Zeile
digitalWrite(motor\_right, LOW);
zu
digitalWrite(motor\_right, HIGH);
- Oder ändere die Zeile
digitalWrite(motor\_right, LOW);
zu
digitalWrite(motor\_left, HIGH);
Kannst du Dein Fahrzeug so programmieren, dass es 2m vorwärtsfährt, eine
Kurve fährt und dann genau am Startpunkt wieder ankommt?

Ändere den Code, damit er eine Kurve fährt (s. o.) und passe die Zeit
vom letzten delay
an, sodass eine 180° Kurve gefahren wird. Passe die
Zeit vom ersten ‘delay’ an, sodass 2 Meter gefahren werden.
Denke dir einen interessanten Parcours aus und programmiere diesen!
Beschreibung
Mit einem OLED Display kann man Buchstaben und Nummern darstellen, aber
auch kleine Grafiken. Man kann zum Beispiel Messwerte oder auch den
Zustand in dem sich der Arduino befindet anzeigen lassen (“fahre
vorwärts” / “fahre rückwärts”). Im Vergleich zum LCD lassen sich häufig
mehr Informationen auf dem Display darstellen.
Verkabelung

Schaltplan
Code
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#define I2C_ADDRESS 0x3C
SSD1306AsciiWire oled;
void setup() {
Wire.begin();
Wire.setClock(400000L);
oled.begin(&Adafruit128x64, I2C_ADDRESS);
}
void loop() {
oled.setFont(fixed_bold10x15); // Auswahl der Schriftart
oled.clear(); // Löschen der aktuellen Displayanzeige
oled.println("Viel"); // Text in der ersten Zeile. "println" sorgt dabei für
// einen Zeilensprung.
oled.print("Erfolg!!!"); // Text in der zweiten Zeile. Da es keine dritte
// Zeile gibt, wird hier kein Zeilenumsprung
// benötigt.
delay(2000);
}
Beschreibung
Potentiometer sind einstellbare Widerstände. Ein Potentiometer hat einen
Eingangspin und zwei Ausgangspins. Strom geht in den den Eingangspin
hinein und strömt aus den Ausgangspins hinaus. Der Widerstand des
Potentiometers teilt sich dabei auf die beiden Ausgangspins auf, je
nachdem wie die Drehregler eingestellt ist.
Verkabelung
Baue den Arduino wie folgt auf (die Widerstände kann man bei roten LEDs
auch weglassen):

Code
Da wir einfach nur konstanten Strom aus dem Pin 13 haben möchten, können
wir folgenden Code verwenden:
int leds = 13;
void setup() {
pinMode(leds, OUTPUT);
digitalWrite(leds, HIGH);
}
void loop() {
}
Aufgaben
Beschreibe in eigenen Worten, wie ein Potenziometer funktioniert.
Probiere mit dem obigen Aufbau verschiedene Potentiometer mit
verschiedenen Widerständen aus. Was fällt dir auf?
Wenn der Widerstand zu schwach ist, werden die LED nicht wirklich
dunkel. Ist der Wiederstand zu stark, so lassen sich LEDs schlecht
einstellen.
Beschreibung
Häufig ist es interessant, sich Messdaten von Sensoren über längere Zeit
anzugucken. Sich die Werte über die serielle Schnittstelle auszugeben,
ist nicht immer optimal, da der Arduino mit dem Rechner verbunden
bleiben muss. Dieses Problem kann dadurch gelöst werden, die Werte auf
einer microSD-Karte abzuspeichern.
Verkabelung
GND | GND |
VCC | 5V |
MOSI | 11 |
MISO | 12 |
SCK | 13 |
SS/CS | 10 |
Falls das Modul nur 3.3V Pin hat, dies mit 3.3V statt 5V am Arduino
verbinden.

Schaltplan
Die Reihenfolge der Pins kann verschieden sein. Auf die Beschriftung
achten!
Code
#include <SD.h>
#include <SPI.h>
String logPrefix = "DATEN_"; // Prefix für die Logdateien
String logFileName; // Name der Datei zum Abspeichern der Daten
void setup() {
// Starte die Serielle Schnittstelle
Serial.begin(9600);
// Warte solange bis eine SD-Karte eingesteckt wurde
while (!SD.begin(SS_PIN)) {
Serial.println("Konnte keine Verbindung zur SD-Karte aufbauen.");
Serial.println("Versuche es in 2 Sekunden nochmal");
delay(2000);
}
// Finde Dateinamen der frei ist.
int number = 0;
while (SD.exists(logPrefix + number + ".CSV")) {
number++;
}
logFileName = logPrefix + number + ".CSV"; // Setze den Namen zusammen
Serial.println("Setup erfolgreich. Speichere Daten in: " + logFileName);
}
void loop() {
// sensorValue wird hier beispielsweise mit 42 belegt.
// Dies ersetzen um richtige Werte abzuspeichern.
int sensorValue = 42;
File logFile = SD.open(logFileName, FILE_WRITE); // Oeffne Datei
if (!logFile) {
Serial.println("Konnte die Datei nicht öffnen");
}
// Gebe die Daten aus auf der seriellen Schnittselle
Serial.println(sensorValue);
// Schreibe die Daten wie folgt auf die SD-Karte "sensorValue"
logFile.println(sensorValue);
logFile.close(); // Schliesse die Datei
// Warte 1000 Millisekunden
delay(1000);
}
Damit der Code funktioniert, muss die SD-Karte mit FAT32 formatiert
werden.
Sobald der Arduino mit Strom versorgt wird und die SD-Karte erkannt
wird, wird eine Datei mit dem Namen WERTE_X.CSV
angelegt. X wird dabei
einfach hochgezählt. In dieser wird dann pro Zeile der Wert des Sensors
gespeichert.
Damit nun nicht immer 42 auf die SD-Karte als Wert geschrieben wird,
muss in der Zeile 28 der Wert von sensorValue
auf den Wert des Sensors
gesetzt werden.
Der Code ist so aufgebaut, dass das nach jeder Ausführung am Ende 1000
Millisekunden gewartet wird. Dieses Intervall lässt sich durch das
delay(..)
in Zeile 45 anpassen.
Große SD-Karten Module
Es gibt auch SD-Karten Module für die großen SD-Karten. Wenn man diese
an den Arduino anschließt, wird auf den Datenleitungen 5V benutzt, was
in unserer Erfahrung zu Fehlern führt und die SD-Karte beschädigen kann.
Aufgaben
Beschreibe, was der Code tut!
Es wird zuerst ein Präfix für die Logdateien, der Name der Datei zum
Abspeichern und der Speicherzeitabstand festgelegt. Im Setup wird auf
eine eingesteckte SD-Karte gewartet und versucht eine Verbindung
aufzubauen. Danach wird ein freier Dateiname gesucht und dieser
abgespeichert. In der loop wird der Speicherzeitpunkt aktualisiert,
indem die Datei geöffnet, Daten und Zeitpunkt neu geschrieben werden und
die Karte wieder geschlossen wird.
Häufige Fragen und Probleme
Die SD-Karte wird nicht erkannt.
- Sind die Kabel alle richtig verbunden?
- Wird der Arduino mit ausreichend Strom versorgt? Dies kann auftreten
falls zu viele Sensoren, LEDs etc. angeschlossen sind. Der Arduino
kann über seine Pins nur Sachen mit ca. 150mA versorgen.
- Ist die SD-Karte mit FAT32 formatiert?
Beschreibung
Der Servomotor kann ähnlich wie ein normaler Motor eine programmierbare
Drehbewegung machen. Anders als ein normaler Motor, der sich dauerhaft
im Kreis drehen kann, kann ein Servomotor sich lediglich in einem Winkel
von 180° drehen. Dies bietet natürlich einige Einschränkungen, aber auch
den großen Vorteil, dass wir mit Hilfe des Programms den Servomotor
zwischen 0° und 180° genau positionieren können. Möglich macht dies ein
eingebauter zusätzlicher Sensor, der die Drehposition ermittelt. Der
Motor besitzt drei Kabel mit jeweils einem Weiblich-Anschluss. Der rote
Anschluss ist Vcc, der braune ist GND und der orange ist der Output
Anschluss für den Arduino. Ein Servomotor ist ein Aktor, daher werden
wir ihm mit Hilfe des Programms ein Signal geben, mit dem er arbeiten
kann.
Verkabelung

Schaltplan
Code
Mit dem Programm lässt sich eine simple Schranke bauen. Diese ist für 2
Sekunden unten (0°) und dann für 2 Sekunden oben (90°).
#include <Servo.h> //Wir binden die Bibliothek für den Servomotor ein
Servo servomotor; // Servomotor bekommt den Namen "servomotor"
void setup() {
// put your setup code here, to run once:
servomotor.attach(10); // Bestimme den Digitalen Pin 10 als Anschluss
}
void loop() {
// put your main code here, to run repeatedly:
servomotor.write(0); // Servomotor wird auf 0° gedreht
delay(2000); // Pausiere das Programm für 2 Sekunden
servomotor.write(90); // Servomotor wird auf 90° gedreht
delay(2000); // Pausiere das Programm für 2 Sekunden
}
Aufgaben
Beschreibe, was der Code tut!
Ein Objekt `servomotor´ wird erzeugt und im Setup der Pin 10 als
Anschluss festgelegt. In der Loop wird der Servomotor jeweils um 0° oder
90° gedreht.
Ein Servomotor ist ein Aktor und verhält sich ähnlich wie ein normaler
Motor, jedoch mit der besonderen Eigenschaft, dass er sich nur in einem
Winkel von 180° drehen kann. Dies kann helfen den Servomotor sehr genau
zu positionieren.
Häufige Fragen und Probleme
Mein Servomotor reagiert nicht.
- Wenn dein Servomotor nicht reagiert, dann überprüfe zuerst die
Verkabelung.
- Sind alle Kabel richtig angeschlossen?
- Ist die richtige Farbe mit dem richtigen Pin verbunden?
- Wenn alles richtig angeschlossen ist überprüfe deinen Code. Ist der
richtige Pin angesprochen?
Mein Servomotor steht nicht im richtigen Winkel.
Wenn dein Servomotor einen falschen Winkel anzeigt, liegt das sehr
wahrscheinlich an dem verstellbaren Plastikaufsatz. Setze den Servomotor
mit Hilfe des Programms auf 0°, nimm anschließend den Plastikaufsatz ab,
richte ihn aus und setze ihn wieder richtig drauf. Sollte er weiterhin
einen falschen Winkel anzeigen, überprüfe deine Eingabe im Programm.
Mein Servomotor soll auf einen Sensor reagieren.
Wenn du möchtest, dass dein Servomotor auf das direkte Signal eines
Sensors reagiert, kannst du dir den gewünschten Sensor raussuchen und
ihn wie gehabt in den Code einbinden. Anschließend bindest du das Signal
des Sensors dort ein, wo du dem Servomotor normalerweise den Winkel
angeben würdest.
Ein Beispiel: servomotor.write(analogRead(helligkeitssensor));
Achtung!: Der Servomotor arbeitet nur mit Zahlen zwischen 0 und 180,
daher musst du bei einigen Sensoren einen Teiler einbauen, damit die
höchste Zahl, die den Servomotor erreicht, 180 ist.