Funduino Elevator - modelo de ascensor para la enseñanza

FunduinoÚltima actualización el

Die Module des Aufzugmodells einzeln programmieren

Das Aufzugmodell Funduino Elevator besteht aus mehreren Baugruppen: einem Motor mit Treiberplatine, vier Lichtschranken zur Stockwerkserkennung, einem Servomotor für die Tür, einem OLED-Display, einem MP3-Modul mit Lautsprecher und mehreren Tastern.

Statt gleich das komplette Programm zu schreiben, nimmst du jedes Modul einzeln in Betrieb. Jedes Kapitel bringt dir eine Baugruppe bei und endet mit einer kleinen Aufgabe. Am Ende kennst du alle Bausteine, die du für ein eigenes Aufzugprogramm brauchst.

Als Board kommt ein Arduino MEGA zum Einsatz – der UNO hat zu wenig Anschlüsse für alle Module gleichzeitig.

Funduino Elevator: Aufzugmodell mit Turm und Bodenplatte
Der Funduino Elevator

Was der Funduino Elevator ist

Der Funduino Elevator ist ein Aufzugmodell, auf dem typische elektronische Module vorinstalliert sind, die mit der Arduino-Entwicklungsumgebung programmiert und angesteuert werden. Das Herzstück ist ein Arduino MEGA 2560 R3.

Damit ist der Aufzug nicht nur für den Informatikunterricht interessant – die Arbeit mit ihm vermittelt auch Grundkenntnisse aus Elektronik und Technik.

Die Programmierung kann zu einem komplexen Programm führen, das der Funktion eines echten Aufzugs sehr nahekommt. Du kannst aber auch kleinschrittig vorgehen und die einzelnen Module der Reihe nach kennenlernen und programmieren. Genau so ist diese Anleitung aufgebaut: Die Module werden einzeln beschrieben, eine vollständige Lösung wird bewusst nicht vorgegeben.

Diese Anleitung vermittelt nicht die Grundlagen der Arduino-Programmierung. Dafür eignen sich die Starterkits. Der Funduino Elevator ist eine deutlich komplexere Programmieraufgabe mit hohem Alltagsbezug.

Die Bauteile der Bodenplatte

  • Auf der Unterseite der MEGA-2560-Mikrocontroller
  • Dargestelltes Bedienpanel aus dem Inneren der Aufzuggondel auf der Vorderseite
  • Kleiner Speaker für Statusgeräusche
  • Eingang für externe Spannungsversorgung auf der Rückseite
  • Schiebeschalter für die Zufuhr der externen Spannungsversorgung an den Mikrocontroller
  • Schiebeschalter für die Zufuhr der externen Spannungsversorgung an den Motortreiber
  • Motortreiber
  • Bluetooth-Schnittstelle
  • MP3-Modul mit microSD-Karte
  • Lautsprecheranschluss für die Ausgabe des MP3-Moduls

Die Bauteile des Aufzugturms

  • Auf der Vorderseite an jedem Flur je ein Taster für „Auf“ und „Ab“
  • Auf der Vorderseite oben ein OLED-Display
  • Oben auf dem Rahmen der DC-Motor für den Antrieb der Gondel
  • Auf der Rückseite links mittig der Anschluss für den Servo der Tür (braunes Kabel = GND)
  • Auf der Rückseite oben rechts frei belegbare Kontakte (D19, D18, 5V und GND)
  • Auf der Rückseite oben rechts ein Steckplatz für einen 360°-Servo (D36, 5V, GND), der alternativ als Motor für die Gondel dienen kann
  • Auf der Rückseite oben rechts die Kontakte M1 und M2 für den Anschluss des DC-Motors – sie kommen vom Motortreiber

Die Pinbelegung im Überblick

Kapazitive Schalter auf der Grundplatte (jeweils PWR / OUT): Door Close D32/D33, Door Open D34/D35, Floor 0 D30/D31, Floor 1 D28/D29, Floor 2 D26/D27, Floor 3 D24/D25, Alarm D22/D23.

Kapazitive Schalter am Aufzugturm (jeweils PWR / OUT): Floor 0 Hoch D39/D38, Floor 1 Runter D41/D40, Floor 1 Hoch D43/D42, Floor 2 Runter D45/D44, Floor 2 Hoch D47/D46, Floor 3 Runter D49/D48.

  • Speaker (passiver Buzzer): D9
  • Bluetooth: Serial3 (D14, D15)
  • MP3-Modul: RX D11, TX D10
  • Motortreiber: PWM D8, Motor A D6, Motor B D7
  • Servo der Aufzugtür: D37
  • Steckplatz für einen 360°-Servo: D36
  • Frei verfügbare Ports: D19, D18
  • Lichtschranken: D50, D51, D52, D53
  • OLED-Display: SDA D20, SCL D21
Kapazitiver Touch-Schalter mit VCC, GND und OUT
Kapazitiver Schalter
Passiver Buzzer auf der Grundplatte
Passiver Lautsprecher an D9
Bluetooth-Modul des Aufzugs
Bluetooth an Serial3
MP3-Modul DFPlayer Mini mit microSD-Karte
MP3-Modul an D10 und D11
Motortreiber auf der Grundplatte des Aufzugs
Motortreiber an D6, D7 und D8
Steckplatz für den Servomotor der Aufzugtür
Servo der Tür an D37
Lichtschrankenmodul am Aufzugturm
Lichtschranken an D50 bis D53
OLED-Display am Aufzugturm
Display an SDA D20 und SCL D21
1 / 8

Der kapazitive Schalter

Die Schalter am Aufzugmodell haben eine Touch-Funktion: Es braucht keinen mechanischen Anschlag, eine Sensorik erkennt den sich nähernden Finger. Sobald der Schalter berührt wurde, gibt er an seinem Ausgangskontakt eine Spannung aus und die Hintergrundbeleuchtung wird aktiviert. Bei einem erneuten Kontakt erlischt beides wieder.

Technisch funktioniert der Schalter wie ein offener Kondensator: Zwischen Messelektrode und GND-Elektrode wird ein elektrisches Feld aufgebaut. Dringt ein Material mit einer Dielektrizitätszahl größer als Luft in dieses Feld ein, vergrößert sich die Kapazität. Die Elektronik auf dem Modul wertet diese Änderung aus und schaltet den Ausgang.

Jeder Schalter hat drei Kontakte: VCC für die Spannungsversorgung, GND und OUT für das Signal. Am Aufzug ist jeder Taster mit zwei digitalen Pins verbunden – einer versetzt den Schalter in den Betriebszustand, der andere fragt den Schaltzustand ab.

Für das erste Beispiel verwenden wir den Schalter unten rechts auf der Aufzugbasis, der für die Türöffnung vorgesehen ist: Versorgung über Pin 34, Abfrage über Pin 35.

In diesem ersten Sketch wird PowerPin zwar als OUTPUT definiert, aber nie auf HIGH gesetzt. Damit bekommt der Schalter keine Spannung und der Ausgang bleibt LOW. Die fehlende Zeile digitalWrite(PowerPin, HIGH); steht erst im nächsten Beispielcode – ohne dass der Artikel darauf hinweist.

Kapazitiver Touch-Schalter mit VCC, GND und OUT
Kapazitiver Schalter
Kapazitiven Schalter auslesen
int PowerPin = 34; // Sensor Pin
int sensorPin = 35; // Sensor Pin
void setup()
{
 Serial.begin(9600); // Starten der seriellen Schnittstelle
 pinMode(PowerPin, OUTPUT); // Der Sensor wird am Mikrocontroller als Eingang definiert.
 pinMode(sensorPin, INPUT); // Der Sensor wird am Mikrocontroller als Eingang definiert.
}
void loop()
{
 int sensorWert = digitalRead(sensorPin); //  Sensorwert auslesen
 // Wurde der Sensor berührt?
 if (sensorWert == HIGH)
{
    Serial.println("Der Sensor wurde aktiviert!");
    delay(500);
 }
}

Beleuchtung schalten und Schalter zurücksetzen

Das Modul ist so gebaut, dass du die LED der Hintergrundbeleuchtung selbst ein- und ausschalten kannst: Du setzt den pinMode des Signalpins von INPUT auf OUTPUT und den Pin auf HIGH. Denk daran, den Pin wieder auf INPUT zu setzen, wenn du danach den Schaltstatus auslesen willst.

Ein Schalter bleibt normalerweise so lange aktiv, bis ihn jemand erneut berührt. Mit einem kleinen Trick kannst du ihn auch per Mikrocontroller zurücksetzen: Du nimmst kurzzeitig die Spannungsversorgung über den digitalen Pin weg. Danach ist der Schaltzustand aus und die Hintergrundbeleuchtung erloschen – die Sensorik bleibt aber aktiv.

Beispielcode 1 schaltet den Schalter eine Sekunde nach der Berührung ab und gleich wieder ein.

Beispielcode 2 schaltet stattdessen die LED des Schalters selbst. In diesem Modus lässt sich der Schaltstatus allerdings nicht auslesen.

Der Unterschied zwischen beiden Verwendungen liegt allein darin, ob der Pin des Mikrocontrollers als Ausgang oder als Eingang definiert ist. Das muss nicht im Setup geschehen – du kannst es auch im laufenden Programm ändern.

Beispielcode 1 setzt sensorPin auf 2, obwohl der Schalter im ganzen Artikel an D35 liegt. Der Kommentar daneben nennt außerdem Pin 3 als Spannungsversorgung, während im Code 34 steht. Beispielcode 2 hat beide Werte richtig.

Beispielcode 1: Schalter nach der Berührung zurücksetzen
int PowerPin = 34; // Spannungsversorgung über den Pin 3 geht an VCC des Sensors.
int sensorPin = 2; // Sensor Ausgangs-Pin
void setup() {
 Serial.begin(9600);
 pinMode(sensorPin, INPUT); // Sensoreingang am Mikrocontroller
 pinMode(PowerPin, OUTPUT); // Spannungsausgang für den Schalter
 digitalWrite(PowerPin, HIGH);
}
void loop() {
 int sensorWert = digitalRead(sensorPin); // Lese Sensorwert.
 // Wurde der Sensor berührt?
 if (sensorWert == HIGH) {
    Serial.println("Der Sensor wurde berührt!");
    delay(1000);
    // Schalte sensor aus.
    digitalWrite(PowerPin, LOW); // Schalte den Strom vom Schalter aus.
    delay(500);
    digitalWrite(PowerPin, HIGH); // Schalte den Strom vom Schalter wieder ein.
 }
}
Beispielcode 2: Hintergrundbeleuchtung selbst schalten
int PowerPin = 34; // VCC von dem Sensor.
int sensorPin = 35; // Sensor Pin
void setup() {
 Serial.begin(9600);
 pinMode(sensorPin, OUTPUT); // Hier wird der Pin des Mikrocontrollers, der mit dem AusagnagsPin des Moduls verbunden ist, als Ausgang festgelegt.
 pinMode(PowerPin, OUTPUT);
 digitalWrite(PowerPin, HIGH); //Schalter aktivieren
}
void loop()
{
    digitalWrite(sensorPin, HIGH); // LED des Touch-Moduls aktivieren
    delay(500);
    digitalWrite(sensorPin, LOW); // LED des Touch-Moduls deaktivieren
    delay(500);
 }

Der Lautsprecher ohne MP3

Aufgabe: Mit dem passiven Lautsprecher sollen unterschiedliche Töne und eine Melodie erzeugt werden.

Die einfachste Art der Tonerzeugung ist ein aktiver Lautsprecher, der nur an 5 V angeschlossen wird – die Tonerzeugung übernimmt eine eingebaute Elektronik. Der Nachteil: Er kann nur einen einzigen Ton erzeugen.

Im Aufzug sitzt ein passiver Lautsprecher. Weil in ihm keine Elektronik den Ton vorgibt, kannst du damit verschiedene Töne, Melodien und Sirenensignale erzeugen.

Die Tonerzeugung basiert auf dem Befehl tone(x, y): x ist der Pin, an dem der Lautsprecher mit der positiven Seite angeschlossen ist, y gibt die Tonhöhe an. Am Aufzug ist der Lautsprecher an Pin 9 und GND angeschlossen – diese Verkabelung ist bereits vorhanden.

Im zweiten Codebeispiel ertönen zwei Töne abwechselnd wie bei einer Sirene, ohne Pause dazwischen.

Im zweiten Codebeispiel steht Tone(9, 200) mit großem T. Der Arduino-Befehl heißt tone – so geschrieben lässt sich der Sketch nicht übersetzen.

Passiver Buzzer auf der Grundplatte
Passiver Lautsprecher an D9
Schema: tone und noTone
tone(9, 100); // Der Lautsprecher an Pin 9 wird mit der Tonhöhe „100“ aktiviert
delay(1000); // Pause mit 1000 Millisekunden, also 1 Sekunde – Der Lautsprecher bleibt für diese Zeit aktiv.
noTone(9); // Der Lautsprecher an Pin 8 wird deaktiviert
Codebeispiel 1: Einfache Tonerzeugung
void setup(){} //Im Setup werden keine Informationen benötigt. Die Spannungsausgabe für den Pin an dem der Lautsprecher eine Spannungsausgabe benötigt (PinMode OUTPUT), wird im Sketch durch den Befehl "tone" automatisch festgelegt.
void loop()
{
    tone(9, 100);   //Im Hauptteil wird nun mit dem Befehl "tone ( x , y )" ein Ton abgegeben…
    delay(1000);    //…mit einer Dauer von 1 Sekunde.
    noTone(9);    //Der Ton wird abgeschaltet.
    delay(1000);    //Der Lautsprecher bleibt eine Sekunde aus.
}
Codebeispiel 2: Abwechselnde Tonhöhen
void setup(){}
void loop()
{
    tone(9, 100);
    delay(1000);
    noTone(9);  //An dieser Stelle geht der erste Ton aus.
    Tone(9, 200); // Der zweite Ton mit der neuen Tonhöhe “200” ertönt.
    delay(1000);  //… und zwar für eine Sekunde.
    noTone(9);  // An dieser Stelle geht der zweite Ton aus und der Loop-Teil des Sketches beginnt von vorn.
}

Die Lichtschranken

Aufgabe: Eine Lichtschranke wird verwendet, um die Anzahl der Lichtstrahlunterbrechungen zu zählen.

Eine Lichtschranke besteht aus einem Sender, der Licht aussendet, und einem Empfänger, der es detektiert. Im Kleinformat ist die Lichtquelle eine Infrarot-LED, deren Licht das menschliche Auge nicht sieht. Unterbricht ein Objekt den Lichtstrahl, erkennt die Lichtschranke das.

Das Modul hat eine Status-LED, die leuchtet, sobald das Modul Spannung bekommt. Wird die Lichtschranke unterbrochen, erlischt sie, und am Signalausgang liegen 5 V an.

Am Aufzug sind vier Sensoren vorhanden, die mit D50, D51, D52 und D53 verbunden sind. Für diese Anleitung verwenden wir Sensor 1 an D50 und lassen uns das Signal im Seriellen Monitor anzeigen.

Die Aufgabe verlangt, die Unterbrechungen zu zählen – der Sketch gibt den Zustand aber nur aus. Ein Zähler fehlt im Original.

Lichtschrankenmodul am Aufzugturm
Lichtschranken an D50 bis D53
Lichtschranke auslesen
int messwert = 0; //Unter der Variablen "Messwert" wird später der Messwert der Lichtschranke gespeichert.
void setup()
{ //Hier beginnt das Setup.
    Serial.begin(9600); //Die Kommunikation mit dem Seriellen Port wird gestartet.
}
void loop() //Hier beginnt der Hauptteil
{
    messwert = digitalRead(50); //Die Signalausgabe der Lichtschranke wird ausgelesen und unter der Variable „messwert“ gespeichert. Wenn die Lichtschranke unterbrochen wird, speichert der Mikrocontroller den Wert "1", ansonsten "0".
    Serial.print("Lichtschrankensignal= "); //Ausgabe am seriellen Monitor
    Serial.println(messwert); //…und im Anschluss der Messwert "1" bei unterbrochener Schranke, ansonsten "0".
}

Der Lautsprecher mit MP3

Im Aufzug ist ein MP3-Player-Modul mit der Bezeichnung „DFPlayer Mini“ verbaut. An das Modul kann direkt ein Miniaturlautsprecher angeschlossen werden, ohne dass ein Verstärker nötig ist.

SD-Karte vorbereiten: Die Karte muss FAT16 oder FAT32 formatiert sein. Über einen Rechtsklick auf den Wechseldatenträger wählst du „Formatieren…“ und unter „Dateisystem“ den Eintrag FAT32. Achtung: Alle Daten auf der Karte werden dabei gelöscht.

Danach brauchst du ein paar Sounddateien im MP3-Format. Du kannst sie selbst aufnehmen oder im Netz nach „Text zu MP3“ suchen. Die Dateien benennst du 0001.MP3, 0002.MP3, 0003.MP3 und so weiter – immer vier Stellen mit vorangestellten Nullen.

Bibliothek und Beispielcode: Über den Bibliotheksverwalter installierst du die Library von DFRobot. Den Einstiegssketch findest du unter Datei → Beispiele → DFRobotDFPlayerMini → GetStarted. Lade ihn unverändert hoch und öffne sofort den Seriellen Monitor – er zeigt dir, ob das Modul richtig angeschlossen und einsatzbereit ist.

Praxistipp: Die Datenübertragung erfolgt in diesem Sketch mit 115200 statt 9600 Baud. Der Wert muss im Seriellen Monitor eingestellt werden, sonst erscheinen nur unleserliche Zeichen. Hörst du nichts, erhöhe die Lautstärke: In der Zeile myDFPlayer.volume(10); trägst du den Maximalwert 30 ein.

Für einen Einstiegssketch ist der GetStarted-Code recht unübersichtlich. Deshalb hier die Minimalform.

In der Minimalform fehlt der Aufruf myDFPlayer.begin(mySoftwareSerial);. Ohne ihn wird das Modul nie initialisiert, und der Sketch spielt nichts ab.

MP3-Modul DFPlayer Mini mit microSD-Karte
MP3-Modul an D10 und D11
DFPlayer-Bibliotheken in der Bibliotheksverwaltung
Passende Bibliotheken für den DFPlayer
Beispielsketch GetStarted der DFRobot-Bibliothek
Datei → Beispiele → GetStarted
1 / 3
MP3-Modul in Minimalform
#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
SoftwareSerial mySoftwareSerial(10, 11); // RX, TX
DFRobotDFPlayerMini myDFPlayer;
void setup()
{
    mySoftwareSerial.begin(9600);
    myDFPlayer.volume(30);  //Lautstärke auf Maximum (30)
}
void loop()
{
    myDFPlayer.play(1);  //Spielt die erste MP3-Datei ab
    delay(3000); // Nach dem Abspielen der Datei pausiert der Sketch für drei Sekunden.
}

Der Servomotor der Aufzugtür

Aufgabe: Ein Servomotor soll vom Mikrocontroller angesteuert werden. Er soll drei verschiedene Positionen anfahren und zwischen den Positionen kurz warten.

Servomotoren sind nicht mit regulären Elektromotoren vergleichbar: Die Drehachse ist nur in einem kleinen Winkelbereich beweglich, meist rund 180 Grad. Im Inneren sitzt ein Potentiometer, das die vorgegebene Winkelposition permanent überwacht. Eine kleine Regelelektronik hält die Position auch bei äußeren mechanischen Einflüssen.

Auf der Rückseite des Aufzugturms – mittig links – ist der Steckplatz für den Servomotor. Achte darauf, dass das braune Kabel auf GND kommt. Nach dem Einstecken ist die Signalleitung mit Pin D37 verbunden.

Wenn sich die Tür langsam auf und zu bewegen soll, setzt du die Winkelangaben in eine Programmschleife, in der sich der Drehwinkel nur langsam verändert.

Servomotor der Aufzugtür im Steckplatz, braunes Kabel auf GND
Braunes Kabel auf GND
Servomotor der Aufzugtür
#include <Servo.h>  //Die Servobibliothek wird aufgerufen.
Servo servoblau;  //Erstellt für das Programm ein Servo mit dem Namen „servoblau“.
void setup()
{
    servoblau.attach(37); //Servo wird mit Pin 37 verbunden.
}
void loop()
{
    servoblau.write(0);    //Position 1 ansteuern mit dem Winkel 0°.
    delay(3000);       //Das Programm stoppt für 3 Sekunden.
    servoblau.write(90);   //Position 2 ansteuern mit dem Winkel 90°.
    delay(3000);       //Das Programm stoppt für 3 Sekunden.
    servoblau.write(180);  //Position 3 ansteuern mit dem Winkel 180°.
    delay(3000);       //Das Programm stoppt für 3 Sekunden.
}

Den Motor über den Motortreiber steuern

Der Motortreiber sorgt dafür, dass der Motor in beiden Richtungen mit genügend Energie betrieben werden kann. Die Ausgänge des Mikrocontrollers liefern nur eine sehr geringe Stromstärke, mit der sich der Motor nicht bewegen würde.

Das Modul hat zwei Kanäle und könnte zwei Motoren getrennt betreiben – am Aufzug wird nur einer verwendet. Die Spannungsversorgung ist über die Platine bereits hergestellt.

Drehrichtung: Zwei digitale Eingänge an D6 und D7 bestimmen über HIGH und LOW die Richtung:

  • D6 = LOW und D7 = LOW – Stillstand
  • D6 = HIGH und D7 = HIGH – Stillstand
  • D6 = LOW und D7 = HIGH – linksdrehend
  • D6 = HIGH und D7 = LOW – rechtsdrehend

Geschwindigkeit: Die Geschwindigkeit richtet sich nach der Spannungsversorgung und dem PWM-Signal am Eingangspin. Der Befehl lautet analogWrite(GSM1, 200); der Zahlenwert kann zwischen 0 und 255 liegen. GSM1 steht dabei für Pin D8.

Motortreiber auf der Grundplatte des Aufzugs
Motortreiber an D6, D7 und D8
Motor über den Motortreiber steuern
int GSM1 = 8;
int in1 = 6;
int in2 = 7;
void setup()
{
  pinMode(GSM1, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
}
void loop()
{
  digitalWrite(in1, HIGH);  // Motor 1 beginnt zu rotieren
  digitalWrite(in2, LOW);
  analogWrite(GSM1, 200);   // Motor 1 soll mit der Geschwindigkeit "200" (max. 255) rotieren
  delay(2000);
  digitalWrite(in1, LOW);   // Durch die Veränderung von HIGH auf LOW (bzw. LOW auf HIGH) wird die Richtung der Rotation verändert.
  digitalWrite(in2, HIGH);
  delay(2000);
  digitalWrite(in1, LOW);   // Anschließend sollen die Motoren 2 Sekunden ruhen.
  digitalWrite(in2, LOW);
  delay(2000);
}

Das OLED-Display

Der Aufzug hat eine Anzeige mit 128 × 64 Pixeln, die in einer Header-Buchse steckt und sich daher gegen andere Displays tauschen lässt. Angesteuert wird sie über den I²C-Bus; auf der Platine sitzt der Treiberchip SSD1306.

OLED-Displays sind sehr dünn und kontraststark. Die kleinen Displays im Mikroelektronikbereich sind in der Regel monochrom. Selbst zweifarbige OLEDs wie dieses sind monochrom: Im oberen Bereich (Reihe 1–16) können die Pixel nur gelb leuchten, unten (Reihe 17–64) nur blau.

Die Bibliothek: Für OLED-Displays gibt es viele Bibliotheken. Sie bringen alle Beispielsketche mit, belegen aber auch viel internen Speicher – für das Auswerten von Sensordaten bleibt dann zu wenig übrig. Deshalb arbeiten wir mit der speicheroptimierten Bibliothek „SSD1306Ascii“.

Zum Kennenlernen eignet sich der Sketch Datei → Beispiele → SSD1306Ascii → FontSamplesWire. Er zeigt die hinterlegten Schriftarten – belegt auf dem UNO aber 96 Prozent des Speichers. Für eigene Programmierungen ist der kleinere Sketch HelloWorldWire besser geeignet.

Ausblick: Eine sehr umfangreiche Bibliothek ist „U8g2“. Sie kann eine Vielzahl von Displays ansteuern und hilft besonders bei grafischen Anwendungen. Dafür musst du in jedem Beispielsketch das richtige Display aktivieren, indem du die passende Zeile auskommentierst – je nachdem, ob dein Display den SSD1306- oder den SH1106-Chip hat.

Die kleine Bibliothek beherrscht außerdem seitliches Scrollen, dauerhaftes Auf- und Abscrollen, das Drehen des Displays um 180 Grad, das Invertieren einzelner Zeilen oder des gesamten Displays, größere Buchstabenabstände und automatisches Scrollen am Bildschirmende.

OLED-Display am Aufzugturm
Display an SDA D20 und SCL D21
Bibliothek SSD1306Ascii in der Bibliotheksverwaltung
Die Bibliothek SSD1306Ascii
Schriftarten des Beispielsketches FontSamplesWire auf dem OLED
Schriftarten aus FontSamplesWire
Beispielsketche der SSD1306Ascii-Bibliothek im Menü
Die mitgelieferten Beispielsketche
Bibliothek U8g2 in der Bibliotheksverwaltung
Die Bibliothek U8g2
Codeauszug mit den auskommentierten Displayzeilen der U8g2
Das richtige Display aktivieren
Grafikausgabe der U8g2-Bibliothek auf dem OLED
Ergebnis mit der U8g2
1 / 7
OLED-Display beschriften
#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(System5x7); // 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);
}

Codereferenz

Mathematik: map() wandelt einen Zahlenbereich in einen anderen um. max(x,y) gibt den höheren, min(x,y) den kleineren Wert zurück.

Digitale Ein- und Ausgänge: pinMode(pin, INPUT | OUTPUT | INPUT_PULLUP) setzt den Modus. digitalWrite(pin, HIGH | LOW) schaltet den Pin auf 5 V oder 0 V. digitalRead(pin) liest den Status und liefert HIGH oder LOW.

Analoge Ein- und Ausgänge: analogWrite(pin, var) gibt einen Wert zwischen 0 und 255 aus. analogRead(pin) liest den analogen Pin und liefert beim MEGA einen Wert zwischen 0 und 1023.

Zeit: delay(Zeit) pausiert in Millisekunden, delayMicroseconds(Zeit) in Mikrosekunden. millis() und micros() liefern die vergangene Zeit seit dem Programmstart.

Erweiterte Funktionen: tone(pin, freq) erzeugt eine Rechteckwelle der vorgegebenen Frequenz, tone(pin, freq, zeit) für eine vorgegebene Dauer. noTone(pin) beendet sie.

Datentypen: boolean (true/false), char (8 Bit, ASCII), byte (8 Bit, 0 bis 255), int (16 Bit, −32.768 bis 32.767), long (32 Bit, −2.147.483.648 bis 2.147.483.647), float (32 Bit mit Nachkommastellen).

Vergleichsoperatoren: == gleich, != nicht gleich, < kleiner, > größer, <= kleiner oder gleich, >= größer oder gleich.

Boolesche Operatoren: && und, || oder, ! nicht.

Kommentare: // für eine Zeile, /* … */ für mehrere Zeilen.

Struktur: void setup() {} läuft einmal zu Beginn, void loop() {} wiederholt sich, solange das Board Spannung hat.

Kontrollstrukturen: if(Bedingung) {} und else {} für Verzweigungen, for(Initialisierung; Bedingung; Zuwachs) {} für Wiederholungen mit fester Häufigkeit.

In der Codereferenz des Artikels steht, analogRead liefere einen Wert zwischen 0 und 255 und 2,5 Volt entsprächen dem Wert 128. Richtig ist der Bereich 0 bis 1023 – 2,5 Volt entsprechen also rund 512. Der Bereich 0 bis 255 gilt für analogWrite. Außerdem heißt es dort zweimal, tone() brauche einen PWM-fähigen Pin; der Befehl arbeitet aber mit einem Hardware-Timer und funktioniert an jedem digitalen Pin.

Calificar la guía

Comentarios

Haz una pregunta o comparte tu experiencia

Schreib uns, wenn etwas nicht funktioniert. Nenne dabei dein Board und die Fehlermeldung.

Revisamos cada comentario antes de publicarlo. Tu dirección de correo electrónico permanece con nosotros.