|
http://sites.schaltungen.at/arduino-uno-r4/impulszaehler/7-segment-dis Wels, am 2019-05-10BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I** DIN A4 ausdrucken (Heftrand 15mm / 5mm) siehe http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I* ~015_b_PrennIng-a_arduino.uno.r4-frequenzzaehler-7.segment.dis (xx Seiten)_1a.pdf
1-fach mit Widerstände
Sieben-SegmentdisplaySiebensegment-Display Siebensegment-Anzeige
Seven_Segment_LED_Display.ino
https://create.arduino.cc/projecthub/Crolus/running-light-7-segment-led-416927
https://www.instructables.com/id/Seven-Segment-Display-Tutorial/
Die Siebensegmentanzeige - 7-Segment-Anzeige
In diesem Experiment besprechen wir folgende Themen:
• Ansteuerung einer einzelnen Siebensegmentanzeige • Der komplette Sketch • Analyse des Schaltplans • Aufbau der Schaltung • Workshop Die Siebensegmentanzeige Wenn wir logische Zustände (wahr bzw. falsch) oder Daten (14, 2.5, »Hallo User«) in irgendeiner Form visualisieren wollten, müssen wir im ersten Fall LEDs ansteuern und im zweiten auf den Serial-Monitor zurückgreifen.
In der Elektronik gibt es neben LEDs weitere Anzeigeelemente, eines davon ist die Siebensegmentanzeige.
Wie der Name schon vermuten lässt, besteht diese Anzeige aus sieben einzelnen Elementen, die in einer bestimmten Form angeordnet sind, um Ziffern und in beschränktem Maße auch Zeichen darstellen zu können. In der nachfolgenden Abbildung ist der Aufbau einer solchen Anzeige schematisch dargestellt.
Du kannst erkennen, dass jedes der sieben Segmente mit einem kleinen Buchstaben versehen wurde.
Die Reihenfolge spielt zwar keine unmittelbare Rolle, doch die hier gezeigte Form hat sich eingebürgert und wird fast überall verwendet.
Darum werden wir sie auch beibehalten. Wenn wir die einzelnen Segmente geschickt ansteuern, können wir unsere Ziffern von 0 bis 9 sehr gut abbilden.
Es sind auch Buchstaben möglich, auf die wir etwas später zu sprechen kommen werden.
Du bist im Alltag bestimmt schon vielen dieser Siebensegmentanzeigen begegnet, ohne dass du weiter darüber nachgedacht hast.
Du kannst beim nächsten Stadtbummel ja einmal auf diese Anzeigen achten.
Du wirst schnell realisieren, an wie vielen Stellen sie zum Einsatz kommen. Hier eine kleine Liste der Einsatzmöglichkeiten.
• Preisanzeige an Tankstellen (sie zeigen irgendwie immer zu viel an ...) • Zeitanzeige an hohen Gebäuden • Temperaturanzeige • Digitaluhren • Blutdruck-Messgeräte • elektronische Fieberthermometer In der folgenden Tabelle wollen wir für die zukünftige Programmierung festhalten, bei welchen Ziffern welches der sieben Segmente angesteuert werden muss. 
Der Wert 1 in unserer Tabelle bedeutet nicht unbedingt HIGH-Pegel, sondern es handelt sich um die Ansteuerung des betreffenden Segments.
Das kann entweder mit dem schon genannten HIGH-Pegel (+5V inklusive Vorwiderstand) oder auch mit einem LOW-Pegel (0V) erfolgen.
Du fragst dich jetzt bestimmt, wovon das abhängt, denn für eine Ansteuerung muss man sich ja entscheiden.
Die Entscheidung wird uns durch den Typ der Siebensegmentanzeige abgenommen.
Es gibt zwei unterschiedliche Ansätze:
• gemeinsame Kathode • gemeinsame Anode
Bei einer gemeinsamen Kathode sind alle Kathoden der einzelnen LEDs einer Siebensegmentanzeige intern zusammengeführt und werden extern mit Masse verbunden.
Die Ansteuerung der einzelnen Segmente erfolgt über Vorwiderstände, die entsprechend mit HIGH-Pegel verbunden werden.
Wir verwenden in unserem folgenden Beispiel aber eine Siebensegmentanzeige mit einer gemeinsamen Anode.
Hier ist es genau andersherum als beim vorherigen Typ.
Alle Anoden der einzelnen LEDs sind intern miteinander verbunden und werden extern mit HIGH-Pegel verbunden.
Die Ansteuerung erfolgt über entsprechend dimensionierte Vorwiderstände über die einzelnen Kathoden der LEDs, die nach außen geführt werden.
7-Segm.-Anzeige SA39-11GE mit gem. Anode
Im oben gezeigten Aufbau einer Siebensegmentanzeige mit gemeinsamer Anode werden alle Anoden der einzelnen LEDs im Betrieb mit der Versorgungsspannung +5V verbunden. Die Kathoden werden später mit den digitalen Ausgängen deines Arduino-Boards verbunden und entsprechend der eben gezeigten Ansteuerungstabelle mit unterschiedlichen Spannungspegeln versorgt.
Wir verwenden in unserem Versuchsaufbau eine Siebensegmentanzeige mit gemeinsamer Anode des Typs SA 39-11 GE.
Ich habe die Pinbelegung dieser Anzeige in den folgenden Abbildungen aufgezeigt.
In der linken Grafik sind die verwendeten Pins der Siebensegmentanzeige zu sehen, in der rechten Grafik ist die Pinbelegung des verwendeten Typs dargestellt.
Die Bezeichnung DP ist übrigens die Abkürzung für Dezimalpunkt.
Benötigte Bauteile
Für dieses Beispiel benötigen wir die folgenden Bauteile. 1 x Siebensegmentanzeige (z. B. Typ SA 39-11 GE mit gemeinsamer Anode) 7 x Widerstand 330 Mehrere flexible Steckbrücken in unterschiedlichen Farben und Längen
Arduino Sketch-Code
int segmente[10][7] = {{1, 1, 1, 1, 1, 1, 0}, // 0
{0, 1, 1, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1}, // 2
{1, 1, 1, 1, 0, 0, 1}, // 3
{0, 1, 1, 0, 0, 1, 1}, // 4
{1, 0, 1, 1, 0, 1, 1}, // 5
{1, 0, 1, 1, 1, 1, 1}, // 6
{1, 1, 1, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1}, // 8
{1, 1, 1, 1, 0, 1, 1}}; // 9
int pinArray[] {2, 3, 4, 5, 6, 7, 8};
void setup(){
for(int i = 0; i < 7; i++) pinMode(pinArray[i], OUTPUT);
}
void loop(){
for(int i = 0; i < 10; i++){ for(int j = 0; j < 7; j++) digitalWrite(pinArray[j], (segmente[i][j]==1)?LOW:HIGH); delay(1000); // Pause von 1 Sekunde
}
}
Siebensegmentanzeige z.B. Typ SA-39-11 GE Ziffernhöhe 9,9mm
Kingbright Typ SA-56-11 GE Ziffernhöhe 14,2mm
Ansteuerung der Siebensegmentanzeige
Arduino Sketch-Code
byte segmente[10]= {B01111110, // 0
B00110000, // 1 B01101101, // 2 B01111001, // 3 B00110011, // 4 B01011011, // 5 B01011111, // 6 B01110000, // 7 B01111111, // 8 B01111011}; // 9 int pinArray[] = {2, 3, 4, 5, 6, 7, 8};
void setup(){
for(int i = 0; i < 7; i++) pinMode(pinArray[i], OUTPUT);
}
void loop(){
for(int i = 0; i < 10; i++){ // Ansteuern der Ziffer for(int j = 6; j >= 0; j--){ // Abfragen der Bits für die Segmente digitalWrite(pinArray[6 - j], bitRead(segmente[i], j) == 1?LOW:HIGH);
}
delay(500); // Eine halbe Sekunde warten
}
}
Schaltungsaufbau
Kingbright 4-fach TYC-365GWB Ziffernhöhe 14,2mm
http://www.erik-bartmann.de/arduino-projekt-kapitel-17.html
BUCH: Die elektronische Welt mit Arduino entdecken Seite 567
BUCH:Arduino Workshops - 65 Projekten Seite 139
2-fach mit Widerstände
Reaktionszeit-Tester
BUCH: Die elektronische Welt mit Arduino entdecken Seite 567
2-fach mit 74HC595 Shift Register IC
Projekt Nr. 19: Zwei Siebensegmentanzeigen steuern
In diesem Projekt lernen Sie, wie Sie zwei Siebensegmentanzeigen steuern, um zweistellige Zahlen auszugeben. Sie benötigen folgende Teile: • zwei Schieberegister-IC 74HC595 • zwei Siebensegmentanzeigen mit gemeinsamer Kathode • sechszehn 560-S2-Widerstände (R1 bis R16) • eine große Steckplatine • Verbindungsdrähte • Arduino und USB-Kabel
Der Schaltplan
Den Schaltplan sehen Sie in Abbildung 6-15. Beachten Sie, dass die Daten- und Taktpins der beiden Schieberegister untereinander und dann mit dem Arduino verbunden sind.
Die Datenleitung verläuft vom Digitalpin 6 des Arduino zum ersten Schieberegister und dann von dessen Pin 9 zu Pin 14 des zweiten.
Um Zahlen zwischen 0 und 99 darstellen zu können, brauchen wir einen komplizierteren Sketch.
Bei Zahlen unter 10 können wir einfach die Zahl und dann eine 0 senden, sodass die rechte Anzeige die Zahl ausgibt und die linke nichts.
Für Zahlen ab 10 müssen wir jedoch die beiden einzelnen Stellen bestimmen und getrennt an die beiden Schieberegister senden.
Dazu verwenden wir die mathematische Modulo-Funktion.
Abb. 6-15 Schaltplan für Projekt 19
Modulo
Modulo ist eine Funktion, die den Rest einer Division zurückgibt. Beispielsweise ergibt 10 modulo 7 (oder kurz: 10 mod 7) 3, weil bei der Division von 10 durch 7 der Rest 3 übrig bleibt.
Als Symbol für eine Modulo-Operation verwenden wir das Prozentzeichen.
Das folgende Beispiel zeigt, wie diese Funktion in einem Sketch angewandt werden kann:
int a = 8;
int b = 3;
c = a % b;
In diesem Beispiel hat c den Wert 2.
Diese Modulo-Funktion setzen wir nun ein, um die rechte Stelle einer zweistelligen Zahl zu bestimmen.
Um die Anzeige von ein- und zweistelligen Zahlen zu automatisieren, schreiben wir die Funktion displayNumber().
Wollen wir beispielsweise die Zahl 23 anzeigen, müssen wir als Erstes die linke Stelle isolieren, indem wir 23 durch 10 teilen, was 2 ergibt (und einen Bruchteil, den wir ignorieren). Anschließend bestimmen wir die rechte Stelle mit 23 modulo 10, was 3 ergibt.
Sketch
// Projekt 19: Zwei Siebensegmentanzeigen steuern
#define DATA 6 // Verbindung mit Pin 14 am 74HC595
#define LATCH 8 // Verbindung mit Pin 12 am 74HC595 #define CLOCK 10 // Verbindung mit Pin 11 am 74HC595
void setup()
{
pinMode(LATCH, OUTPUT);
pinMode(CLOCK, OUTPUT); pinMode(DATA, OUTPUT);
}
// Richtet das Array mit den Segmenten für 0 bis 9 und A bis F ein
/1 (aus Tab. 6-2) int digits[] = {252, 96, 218, 242, 102, 182, 190, 224, 254, 246, 238, 62, 156, 122, 158, 142};
void displayNumber(int n)
{
int left, right=0;
if (n < 10) // siehe 1
{
digitalWrite(LATCH, LOW);
shiftOut(DATA, CLOCK, LSBFIRST, digits[n]); shiftOut(DATA, CLOCK, LSBFIRST, 0); digitalWrite(LATCH, HIGH);
}
else if (n >= 10)
{
right = n % 10; // Rest der Division der anzuzeigenden Zahl
// durch 10 siehe 2
left = n / 10; // Quotient aus der anzuzeigenden Zahl und 10 digitalWrite(LATCH, LOW); shiftOut(DATA, CLOCK, LSBFIRST, digits[right]); shiftOut(DATA, CLOCK, LSBFIRST, digits[left]); digitalWrite(LATCH, HIGH);
}
}
void loop() // siehe 3
{
int i;
for ( i = 0 ; i < 100 ; i++ )
{
displayNumber(i);
delay(100);
}
}
Bei siehe 1 prüft die Funktion, ob die anzuzeigende Zahl kleiner als 10 ist.
Wenn ja, werden die Daten für die Zahl und eine Leerstelle an die Schieberegister gesendet.
Bei Zahlen ab 10 werden ihre Stellen bei siehe 2 mithilfe von Division und Modulo getrennt und dann separat an die Register übertragen.
Schließlich richten wir in void loop() bei siehe 3 die Funktion zur Anzeige der Zahlen von 0 bis 99 ein und rufen sie auf.
Projekt Nr. 20: Ein Digitalthermometer konstruieren
In diesem Projekt ergänzen wir die Schaltung mit zweistelliger Zahlenanzeige aus Projekt 19 um den Temperatursensor TMP36 aus Kapitel 4, um ein Digitalthermometer zu bauen.
Der Algorithmus ist einfach:
Wir lesen die vom TMP36 zurückgegebenen Spannungswerte ab (mit den Methoden aus Projekt 12) und rechnen sie in Grad Celsius um.
Die Hardware
Sie benötigen folgende Teile: • die Schaltung mit zweistelliger Zahlenanzeige aus Projekt 19 • einen Temperatursensor TMP36 Schließen Sie den mittleren Anschluss des TMP36 an den Analogpin 5 an, den linken an 5 V und den rechten an GND.
Jetzt ist der Sensor bereit zur Messung.
Der Sketch
Der Sketch sieht wie folgt aus:
// Projekt 20: Ein Digitalthermometer konstruieren
#define DATA 6 // Verbindung mit Pin 14 am 74HC595 #define LATCH 8 // Verbindung mit Pin 12 am 74HC595 #define CLOCK 10 // Verbindung mit Pin 11 am 74HC595
int temp = 0;
float voltage = 0; float celsius = 0; float sensor = 0; int digits[]={252, 96, 218, 242, 102, 182, 190, 224, 254, 246, 238, 62, 156, 122, 158, 142};
void setup()
{ pinMode(LATCH, OUTPUT); pinMode(CLOCK, OUTPUT); pinMode(DATA, OUTPUT); }
void displayNumber(int n)
{
int left, right = 0;
if (n < 10) { digitalWrite(LATCH, LOW); shift0ut(DATA, CLOCK, LSBFIRST, digits[n]); shift0ut(DATA, CLOCK, LSBFIRST, digits[0]); digitalWrite(LATCH, HIGH); } if (n >= 10) { right = n % 10; left = n / 10; digitalWrite(LATCH, LOW); shiftOut(DATA, CLOCK, LSBFIRST, digits[right]); shiftOut(DATA, CLOCK, LSBFIRST, digits[left]); digitalWrite(LATCH, HIGH); } }
void loop()
{ sensor = analogRead(5); voltage = (sensor * 5000) / 1024; // Rechnet Sensorrohwert in mV voltage = voltage - 500; // um Entfernt Spannungsversatz celsius = voltage / 10; // Rechnet mV- in Celsiuswert temp = int(celsius); // um Ändert den Fließkommawert // für die Temperatur // in einen Integerwert displayNumber(temp); delay(500); }
Der Sketch ist einfach und nutzt Code aus früheren Projekten, nämlich displayNumber() aus Projekt 19 und die Temperaturberechnungen aus Projekt 12.
Die Funktion delay(500) in der zweitletzten Zeile verhindert, dass die Anzeige bei schwankender Temperatur zu schnell wechselt.
BUCH:Arduino Workshops - 65 Projekten Seite 144
4-fach mit Widerstände
http://www.circuitbasics.com/arduino-7-segment-display-tutorial/
https://www.electroschematics.com/10512/arduino-4-digit-7-segment-led-display/
4x7 LED-display
4-stelliges Siebensegment-Display mit gem. Kathode
BUCH: Arduino Schaltungsprojekte für Profis Seite 65
Mehrstellige 7-Segment-LED-Anzeige ansteuern - Multiplexing
BUCH: Arduino Kochbuch Seite 274
4-fach mit 74HC595 Shift Register IC
https://circuitdigest.com/microcontroller-projects/arduino-7-segment-display-clock
4-fach mit TM1637 Treiber IC
http://www.zonnepanelen.wouterlood.com/10-four-digit-7-segment-led-display-for-arduino-based-on-the-tm1637-driver/
4-fach mit MAX7221 LED-Treiber - Schieberegister
Mehrstellige 7-Segment-LED-Anzeige mit MAX7221 Schieberegister ansteuern
LTC-4727JR gem. Kathode
Max7221_digits BUCH: Arduino Kochbuch Seite 276
Analoge Anzeigeinstrument 1mA 5k Ohm Vorwiderstand mit PWM
7.15 Ein analoges Anzeigeinstrument nutzen
Problem
Sie wollen den Zeiger einer Analoganzeige aus dem Sketch heraus steuern.
Schwankende Messwerte lassen sich auf einer Analoganzeige leichter Interpretieren und verleihen Ihrem Projekt einen coolen Retro-Look.
Lösung Verbinden Sie die Anzeige über einen Vorwiderstand (5k Ohm sind für ein 1mA Meter üblich) mit einem analogen (PWM) Ausgang (siehe Abbildung 7-17). 
Abbildung 7-17: Eine analoge Anzeige ansteuern
Die Bewegung der Anzeige entspricht der Position eines Potentiometers (variablen Widerstands):
ARDUINO UNO Sketch
/*
* AnalogMeter Sketch * Steuert eine Analoganzeige über einen Arduino-PWM-Pin * Der Pegel der Anzeige wird dabei durch den variablen Widerstand am Analogeingang bestimmt */
const int analogInPin = 0; // Analoger Eingang für Poti
const int analogMeterPin = 9; // Analoger Ausgang für Anzeige
int sensorValue = 0; // Vom Poti eingelesener Wert
int outputValue = 0; // PWM-Ausgabewert
void setup()
{
// Hier ist nichts zu tun
}
void loop()
{
sensorValue = analogRead (analogInPin) ; // Analogwert einlesen
outputValue = map(sensorValue, 0, 1023, 0, 255); // Für analoge Ausgabe skalieren analogWrite(analogMeterPin, outputValue); // Wert an analogen Ausgang schreiben
}
Diskussion
Bei dieser Variante von Rezept 7.2 steuert der Arduino mit analogWrite eine Analoganzeige.
Solche Anzeigen sind üblicherweise viel empfindlicher als LEDs .
Ein Widerstand muss zwischen den Arduino-Ausgang und die Anzeige geschaltet werden, um den Strom entsprechend zu begrenzen.
Der Wert des Vorwiderstands hängt von der Empfindlichkeit der Anzeige ab.
5k Ohm sorgen bei einer 1mA Anzeige für einen Vollausschlag.
Sie können einen 4,7k Widerstand verwenden, da sie leichter zu beschaffen sind als 5k Ohm, allerdings müssen Sie dann den Maximalwert für analogWrite auf etwa 240 beschränken.
Nachfolgend sehen Sie, wie Sie den Wertebereich der map-Funktion anpassen müssen, wenn Sie einen 4,7k Widerstand für eine 1mA Anzeige verwenden:
outputValue = map(sensorValue, 0, 1023, 0, 240); // auf Anzeigebereich abbilden
Arbeitet Ihre Anzeige nicht mit mA, müssen Sie einen anderen Vorwiderstand verwenden.
Die Formel für den Widerstand in Ohm lautet
R=U/I Widerstand = 5000 / mA
Bei einer 500 Mikroampere-Anzeige (0,5 mA) ist das also 5000 / 0,5,
d.h. 10.000 Ohm (10k Ohm).
Eine 10mA Anzeige benötigt 500R (0,5k Ohm), bei 20mA 250 Ohm.
Bei einigen Anzeigen sind bereits interne Vorwiderstände integriert
Sie müssen möglicherweise experimentieren, um den korrekten Wert des Vorwiderstands zu ermitteln, achten Sie aber darauf, die Anzeige nicht mit zu viel Strom zu versorgen.
Siehe auch Rezept 7.2
BUCH: Arduino Kochbuch Seite 285
Flüssigkristallanzeigen - LiquidCrystal 1602 16x2 Zeichen LCD Display Modul HD44780 blau mit Backlight für Arduino
Industriestandard-HD44780 aequivalent LCD-Kontroller
In diesem Kapitel lernen Sie Folgendes:
• Anzeige von Text und numerischen Daten mit LCD-Zeichenmodulen • Gestalten eigener Zeichen zur Wiedergabe auf LCD-Zeichenmodulen • Anzeige von Text und Daten auf großen LCD-Grafikmodulen • Erstellen einer grafischen Darstellung des von einem Thermometer gemessenen Temperaturverlaufs Manchmal ist es erforderlich, dem Benutzer an anderer Stelle als dem Monitor des Desktop-Computers Informationen anzuzeigen.
Eine der einfachsten und vielseitigsten Möglichkeiten dazu bieten LCD-Module (Liquid Crys-tal Display, Flüssigkristallanzeige).
Auf LCD-Zeichenmodulen können Sie Text, selbst gestaltete Zeichen und numerische Daten wiedergeben, auf LCD-Grafikmodulen Bilder.
LCD-Zeichenrnodule Die preiswerteste und am einfachsten zu verwendende Variante von Flüs-sigkristallanzeigen sind Zeichenmodule, die Zeichen wie Buchstaben und Zahlen wiedergeben können.
Es gibt sie in verschiedenen Größen, die nach
Zeilenanzahl und der Anzahl darstellbarer Zeichen pro Zeile unterschieden werden.
Manche verfügen über eine Hintergrundbeleuchtung und erlauben es, die Zeichen- sowie die Hintergrundfarbe auszuwählen.
Jedes LCD-Modul mit HD44780- oder KS0066-kompatibler Schnittstelle sollte für die Arbeit mit dem Arduino geeignet sein.
Als erstes Modell verwenden wir eines, das in zwei Zeilen je 16 Zeichen anzeigen kann und über eine Hintergrundbeleuchtung verfügt (siehe Abb. 7-1).
Das Trimmpotenziometer (der regelbare Widerstand für das LCD-Modul) hat einen Widerstand von 10k Ohm und wird zur Einstellung des Kontrasts verwendet.
Die Pfostenleiste wird in den Löchern oben an der Anzeige festgelötet, um den Anschluss an eine Steckplatine zu vereinfachen.
Diese Löcher sind von 1 bis 16 durchnummeriert, wobei Nr. 1 der Ecke des Moduls am nächsten liegt und im Schaltplan von Abb. 7-2 als VSS bezeichnet ist.
(Dieser Anschluss wird mit GMD verbunden.) Diesen Schaltplan verwenden wir für alle LCD-Beispiele in diesem Buch.
Ein LCD-Zeichenmodul in einem Sketch verwenden
Um das Zeichenmodul aus Abb. 7-1 verwenden zu können, müssen wir zuerst die erforderlichen Funktionen anhand eines einfachen Beispiels kennenlernen.
Geben Sie den einfachen Sketch aus Listing 7-1 ein und laden Sie ihn hoch:
#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9); // Pins für RS, E, DB4, DB5, DB6, DB7
void setup()
{
lcd.begin(16, 2);
lcd.clear();
}
void loop()
{
lcd.setCursor(0, 5);
lcd.print("Hello"); lcd.setCursor(1, 6); lcd.print("world!"); del ay(10000);
}
Listing 7-1 Sketch zur LCD-Demonstration
Abb. 7-1 LCD-Modul (mit 10k Ohm Trimmpotenziometer fehlt immer! )
Sehen wir uns nun an, wie der Sketch aus Listing 7-1 funktioniert.
Als Erstes müssen wir die Bibliothek für LCD-Module einschließen (die automatisch zusammen mit der Arduino-IDE installiert wird) und ihr mitteilen, welche Pins mit dem Arduino verbunden sind.
Dazu fügen wir die beiden folgenden Zeilen vor der Methode setup() ein:
#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9); // Pins für RS, E, DB4, DB5, DB6, DB7
Wenn Sie andere Digitalpins des Arduino verwenden müssen, passen Sie die Nummern in der zweiten Zeile entsprechend an.
Als Nächstes müssen wir dem Arduino in voi d setup() mitteilen, wie groß die Flüssigkristallanzeige ist, also wie viele Zeilen und Spalten sie hat.
Unser Beispielmodul hat zwei Zeilen zu je 16 Zeichen, weshalb wir Folgendes schreiben:
lcd.begin(16, 2);
Text anzeigen
Nachdem das LCD-Modul eingerichtet ist, müssen wir die Anzeige wie folgt leeren:
lcd.clear();
Anschließend platzieren wir wie folgt den Cursor, also den Ausgangspunkt . für den Text:
lcd.setCursor(x, y);
Dabei gibt x die Spalte an (0 bis 15) und y die Zeile (0 oder 1).
Um jetzt beispielsweise das Wort »Text« anzuzeigen, müssen Sie Folgendes eingeben:
lcd.print("text");
Damit sind Sie in der Lage, Text zu positionieren.
Als Nächstes wollen wir Variablendaten anzeigen.
Variablen und Zahlen anzeigen
Um den Inhalt von Variablen auf dem LCD-Bildschirm anzuzeigen, verwenden Sie folgende Zeile:
lcd.print(variable);
Bei Fließkommavariablen können Sie angeben, wie viele Dezimalstellen ausgegeben werden sollen.
Beispielsweise wird der Arduino im folgenden Beispiel mit lcd.print(pi, 3) angewiesen, den Wert von Pi auf drei Dezimalstellen genau anzuzeigen, wie Sie in Abb. 7-4 sehen:
float pi = 3.141592654;
lcd.print("pi: "); lcd.print(pi, 3);
Abb. 7-4 Anzeige einer Fließkommazahl auf einem LCD-Bildschirm
Integerwerte können Sie auch in Hexadezimal- und in Binärform ausgeben, wie Listing 7-2 zeigt.
int zz = 170;
lcd.setCursor(0, 0); lcd.print("Binary: "); lcd.print(zz, BIN); // Zeigt 170 in Binärform an lcd.setCursor(0, 1); lcd.print("Hexadecimal: "); lcd.print(zz, HX); // Zeigt 170 in Hexadezimalform an
Listing 7-2 Funktionen zur Anzeige von Binär- und Hexadezimalzahlen
Das LCD-Modul zeigt den Text wie in Abb. 7-5 an.
Abb. 7-5 Das Ergebnis von Listing 7-2
Projekt Nr. 25: Eigene Zeichen definieren
Neben den über die Tastatur verfügbaren Standardbuchstaben, -ziffern und -symbolen können Sie pro Sketch auch bis zu acht eigene Zeichen definieren.
Im LCD-Modul besteht jedes Zeichen aus acht Zeilen zu je fünf Punkten oder Pixeln.
In Abb. 7-6 sehen Sie eine Detailaufnahme.
Abb. 7-6 Jedes Zeichen besteht aus acht Zeilen zu je fünf Pixeln.
Um ein eigenes Zeichen anzeigen zu können, müssen Sie es erst in Form eines Arrays definieren.
Für unseren Smiley können wir das folgende Array verwenden:
Byte a[8] = B00000,
B01010, B01010, B00000, B00100, B10001, B01110, B00000 };
Jede Zahl in diesem Array spricht ein einzelnes Pixel der Anzeige an.
Mit 0 wird das entsprechende Pixel ausgeschaltet, mit 1 eingeschaltet.
Die Elemente im Array stellen die Pixelzeilen der Anzeige dar, wobei das oberste Elemente für die oberste Zeile steht, das nächste für die zweite usw.
Es kann sehr hilfreich sein, eigene Zeichen auf kariertem Papier zu entwerfen.
Jedes ausgefüllte Kästchen müssen Sie dann im Array durch eine 1 darstellen und jedes leere durch eine 0.
In diesem Beispiel sind alle Pixel der obersten Zeile ausgeschaltet, da das erste Element B00000 lautet.
In der zweiten Zeile wird mit B01010 jedes zweite Pixel eingeschaltet, wobei die Einsen für die oberen Teile der Augen stehen.
Mit allen weiteren Zeilen und Pixeln wird das Zeichen weiter ausgefüllt.
Als Nächstes weisen Sie das Array mit der folgenden Funktion in void setup() der ersten von acht Möglichkeiten für eigene Zeichen zu:
lcd.createChar(0, a); // Weist das Array a[8] dem eigenen Zeichen Nr. 0 zu
Um das Zeichen anzuzeigen, fügen Sie in void loop() folgende Zeile ein:
lcd.write(0);
Insgesamt brauchen wir zur Anzeige unseres eigenen Zeichens folgenden Code:
// Projekt 25: Eigene Zeichen definieren
#include <LiquidCrystal.h> LiquidCrystal lcd(4, 5, 6, 7, 8, 9); // pins for RS, E, DB4, DB5, DB6, DB7
byte a[8] = { B00000,
B01010, B01010, B00000, B00100, B10001, B01110, B00000 };
void setup()
{
lcd.begin(16, 2);
lcd.createChar(0, a);
}
void loop()
{
lcd.write(byte(0)); // Schreibt das eigene Zeichen Nr. 0
// an die nächste Cursorposition
}
Abb. 7-7 zeigt die Wiedergabe unseres Smileys auf dem LCD-Bildschirm.
Abb. 7-7 Das Ergebnis von Projekt 25
Mit unseren bisherigen Kenntnissen können wir damit zum Beispiel ein ausgefeiltes Digitalthermometer konstruieren, indem wir den LCD-Bildschirm mit der Temperaturmessung von Projekt 20 kombinieren.
Wenn Sie jedoch sehr viele Daten oder grafische Elemente darstellen wollen, brauchen Sie ein LCD-Grafikmodul.
#include <LiquidCrystal.h>LiquidCrystal lcd(12, 11, 5, 4, 3, 2);void setup() {lcd.begin(16, 2);}void loop() {lcd.setCursor(0, 0);lcd.print("Oben"); //Beginn beim ersten Zeichen in der ersten Zeile mit dem Text „Oben“.delay (2000); //Zwei Sekunden warten.lcd.clear(); //Display löschen.lcd.setCursor(5, 1);lcd.print("unten"); //Erneuter Beginn beim fünften Zeichen in der zweiten Zeile mit dem Text „Unten“.delay (2000); //Zwei Sekunden warten.lcd.clear(); //Display löschen.}
https://funduino.de/nr-13-lcd-display
BUCH:Arduino Workshops - 65 Projekten Seite 163
DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]ENDE |
Impulszähler >